isFoundInDirectory(cacheDir, "sensitive_env_var_value".getBytes()) == !enabled
        isFoundInDirectory(cacheDir, "sensitive_value3".getBytes()) == !enabled
        isFoundInDirectory(cacheDir, "sensitive_convention".getBytes()) == !enabled
        isFoundInDirectory(cacheDir, "sensitive".getBytes()) == !enabled
        isFoundInDirectory(cacheDir, "SENSITIVE".getBytes()) == !enabled

                throw new RuntimeException(e);
            }
            return false;
        }
    }

    @Override
    public Optional<byte[]> getBytes(URI relativeSource) {
        try {
            Path tempPath = null;
            try {
                tempPath = Files.createTempFile("transport-get", "tmp");
                if (get(relativeSource, tempPath)) {

        // Encode as ascii
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        try {
            byteArrayOutputStream.write(daemonGreeting().getBytes());
            OutputStream outputStream = new EncodedStream.EncodedOutput(byteArrayOutputStream);
            FlushableEncoder encoder = new OutputStreamBackedEncoder(outputStream);

 */
public class ForwardInput extends InputMessage {
    private final byte[] bytes;

    public ForwardInput(byte[] bytes) {
        this.bytes = bytes;
    }

    public byte[] getBytes() {
        return bytes;
    }

        "exec"     | "java.io.ByteArrayInputStream" | "new ByteArrayInputStream('Gradle'.getBytes('UTF-8'))"
        "exec"     | "java.io.FileInputStream"      | "new FileInputStream(file('input.txt'))"
        "javaExec" | "java.io.ByteArrayInputStream" | "new ByteArrayInputStream('Gradle'.getBytes('UTF-8'))"
        "javaExec" | "java.io.FileInputStream"      | "new FileInputStream(file('input.txt'))"
    }

        when:
        async {
            10.times {
                start {
                    100.times {
                        outstr.write('write '.getBytes())
                        outstr.print(it)
                        outstr.println()
                    }
                }
            }
        }

        then:
        output.size() == 1000

            @Override
            public void onInput(ForwardInput input) {
                LOGGER.debug("Writing forwarded input on this process' stdin.");
                stdInStream.received(input.getBytes());
            }

            @Override
            public void onUserResponse(UserResponse input) {
                inputReader.putInput(new UserInputReader.TextResponse(input.getResponse()));
            }

     */
    @SuppressWarnings("StringCharset")
    private String getHash(String string) {
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            byte[] bytes = string.getBytes("UTF-8");
            messageDigest.update(bytes);
            return new BigInteger(1, messageDigest.digest()).toString(36);
        } catch (Exception e) {

    private static final int TESTROUNDS = 10000
    private static final String TEST_STRING = "Hello \u00f6\u00e4\u00e5\u00d6\u00c4\u00c5"
    private static final byte[] TEST_STRING_BYTES = TEST_STRING.getBytes('UTF-8')

    static byte[] testbuffer = new byte[256 * TESTROUNDS]

    @CompileStatic
    def setupSpec() {
        for (int i = 0; i < TESTROUNDS; i++) {
            for (int j = 0; j < 256; j++) {

        this.handler = handler;
        buffer = new StreamByteBuffer(bufferLength);
        this.lineMaxLength = lineMaxLength;
        output = buffer.getOutputStream();
        byte[] lineSeparatorBytes = lineSeparator.getBytes(StandardCharsets.UTF_8);
        lastLineSeparatorByte = lineSeparatorBytes[lineSeparatorBytes.length - 1];
    }

    /**