ExecutionFailure result = executer.runWithFailure();
                outputStream.write((result.getOutput() + result.getError()).getBytes());
            } else {
                ExecutionResult result = executer.run();
                outputStream.write(result.getOutput().getBytes());

                if (shouldCheckLoadingFromConfigurationCache()) {
                    rerunReusingStoredConfigurationCacheEntry(args, flags);

    assertThat(encoding.encode(decoded.getBytes(UTF_8))).isEqualTo(encoded);
  }

  private static void testEncodesWithOffset(
      BaseEncoding encoding, String decoded, int offset, int len, String encoded) {
    assertThat(encoding.encode(decoded.getBytes(UTF_8), offset, len)).isEqualTo(encoded);
  }

        FilterChain filterChainWithCharset = new FilterChain(charset);
        filterChainWithCharset.expand(WrapUtil.toMap("prop", 1), escapeBackslashProperty());
        byte[] source = "éàüî $prop".getBytes(charset);

        InputStream transformedInputStream = filterChainWithCharset.transform(new ByteArrayInputStream(source));
        String actualResult = new String(ByteStreams.toByteArray(transformedInputStream), charset);

        def action = Mock(TextStream)
        def lineSeparator = SystemProperties.instance.lineSeparator
        def output = new LineBufferingOutputStream(action, lineSeparator)
        def input = new ByteArrayInputStream(text.getBytes("utf-8"))
        def runner = new ExecOutputHandleRunner("test", input, output, bufferLength, new CountDownLatch(1))

        when:
        runner.run()

        then:
        1 * action.text(text1)

            return (byte[]) o;
        } else if (o == null) {
            return null;
        } else {
            assertArgument("o", o instanceof String, o.getClass().toString());
            return ((String) o).getBytes();
        }
    }

	if err != nil {
		return 0
	}
	meshYaml, err := f.GetString()
	if err != nil {
		return 0
	}
	mc, err := mesh.ApplyMeshConfigDefaults(meshYaml)
	if err != nil {
		return 0
	}
	inData, err := f.GetBytes()
	if err != nil {
		return 0
	}
	in := bytes.NewReader(inData)
	var got bytes.Buffer
	warn := func(s string) {}
	revision, err := f.GetString()
	if err != nil {
		return 0
	}

        return new String(getRaw(), UTF16LE);
    }


    /**
     * @param targetName
     * @return
     */
    private static byte[] encode ( String targetName ) {
        return targetName.getBytes(UTF16LE);
    }

  private final TestByteSource byteSource;

  public TestCharSource(String content, TestOption... options) {
    this.byteSource = new TestByteSource(content.getBytes(UTF_8), options);
  }

  @Override
  public boolean wasStreamOpened() {
    return byteSource.wasStreamOpened();
  }

  @Override
  public boolean wasStreamClosed() {

            this.statusCode = statusCode;
        }

        @Override
        public void writeTo(int requestId, HttpExchange exchange) throws IOException {
            byte[] bytes = content.getBytes(Charsets.UTF_8);
            exchange.sendResponseHeaders(statusCode, bytes.length);
            exchange.getResponseBody().write(bytes);
        }
    }

            }
        };
        File file = File.createTempFile("test", ".properties");
        file.deleteOnExit();
        FileUtil.writeBytes(file.getAbsolutePath(), "ldap.security.principal=******@****.***".getBytes("UTF-8"));
        DynamicProperties systemProps = new DynamicProperties(file);
        SingletonLaContainerFactory.getContainer().register(systemProps, "systemProperties");