public byte[] decode(String code) {
      ByteArrayOutputStream baos = new ByteArrayOutputStream((code.length() * 3 / 4));

      StringReader sr;

      if (code.endsWith(Character.toString(padding))) {
        sr = new StringReader(code.substring(0, code.indexOf(padding)));
      } else {
        sr = new StringReader(code);
      }

      char[] c = new char[4];
      int[] b = new int[4];
      int len;
      try {
        int count = 0;
        while ((len = sr.read(c, 0, 4)) == 4) {
          b[0] = decode[c[0]];
          b[1] = decode[c[1]];
          b[2] = decode[c[2]];
          b[3] = decode[c[3]];

          baos.write(((b[0] & 0x3f) << 2) | ((b[1] & 0x30) >> 4));
          baos.write(((b[1] & 0x0f) << 4) | ((b[2] & 0x3c) >> 2));
          baos.write(((b[2] & 0x03) << 6) | (b[3] & 0x3f));

          count++;
          if (count == 19) {
            sr.mark(1);
            count = 0;

            if (sr.read() != 10) {
              sr.reset();
            }
          }
        }

        b[0] = decode[c[0]];
        b[1] = decode[c[1]];
        b[2] = decode[c[2]];
        b[3] = decode[c[3]];

        if (len == 2) {
          baos.write(((b[0] & 0x3f) << 2) | ((b[1] & 0x30) >> 4));
        } else if (len == 3) {
          baos.write(((b[0] & 0x3f) << 2) | ((b[1] & 0x30) >> 4));
          baos.write(((b[1] & 0x0f) << 4) | ((b[2] & 0x3c) >> 2));
        }

        return baos.toByteArray();
      } catch (java.io.IOException e) {
        return null;
      } catch (RuntimeException e) {
        return null;
      }
    }
 /**
  * Compile a string into a function or SimpleVariable.
  *
  * <p>Called by {@link #compileString(String)} when that has detected "${".
  *
  * <p>Calls {@link CompoundVariable#getNamedFunction(String)} if it detects: '(' - start of
  * parameter list '}' - end of function call
  *
  * @param reader points to input after the "${"
  * @return the function or variable object (or a String)
  */
 Object makeFunction(StringReader reader) throws InvalidVariableException {
   char[] current = new char[1];
   char previous = ' '; // TODO - why use space?
   StringBuilder buffer = new StringBuilder();
   Object function;
   try {
     while (reader.read(current) == 1) {
       if (current[0] == '\\') {
         if (reader.read(current) == 0) {
           break;
         }
         previous = ' ';
         buffer.append(current[0]);
         continue;
       } else if (current[0] == '(' && previous != ' ') {
         String funcName = buffer.toString();
         function = CompoundVariable.getNamedFunction(funcName);
         if (function instanceof Function) {
           ((Function) function).setParameters(parseParams(reader));
           if (reader.read(current) == 0 || current[0] != '}') {
             reader.reset(); // set to start of string
             char[] cb = new char[100];
             reader.read(cb); // return deliberately ignored
             throw new InvalidVariableException(
                 "Expected } after " + funcName + " function call in " + new String(cb));
           }
           if (function instanceof TestListener) {
             StandardJMeterEngine.register((TestListener) function);
           }
           return function;
         } else { // Function does not exist, so treat as per missing variable
           buffer.append(current[0]);
         }
         continue;
       } else if (current[0] == '}') { // variable, or function with no parameter list
         function = CompoundVariable.getNamedFunction(buffer.toString());
         if (function instanceof Function) { // ensure that setParameters() is called.
           ((Function) function).setParameters(new LinkedList<CompoundVariable>());
         }
         buffer.setLength(0);
         return function;
       } else {
         buffer.append(current[0]);
         previous = current[0];
       }
     }
   } catch (IOException e) {
     log.error("Error parsing function: " + buffer.toString(), e);
     return null;
   }
   log.warn("Probably an invalid function string: " + buffer.toString());
   return buffer.toString();
 }
 private void execute() {
   try {
     Method mth = PreparedStatement.class.getDeclaredMethod(this.methodName, this.argClasses);
     mth.invoke(wrapped, args);
     if (args[1] instanceof StringReader) {
       StringReader sr = (StringReader) args[1];
       sr.reset();
     }
     if (args[1] instanceof InputStream
         && ("setAsciiStream".equals(methodName) || "setUnicodeStream".equals(methodName))) {
       ((InputStream) args[1]).reset();
     }
   } catch (Exception e) {
     throw new RuntimeException(e);
   }
 }
 /**
  * Repositions this stream to the position at the time the <code>mark</code> method was last
  * called on this input stream.
  */
 public void reset() throws IOException {
   in.reset();
 }