def stdOut = new ByteArrayOutputStream()
        tapi.withConnection { ProjectConnection connection ->
            connection.newBuild()
                .withArguments(arguments)
                .setStandardOutput(stdOut)
                .setStandardError(stdOut)
                .run()
        }
        stdOut
    }

                        .setStandardOutput(tee)
                        .run()
                    break
                case LauncherApi.BUILD_LAUNCHER:
                    connection.newBuild()
                        .forTasks(task, "--tests", testClass)
                        .setStandardOutput(tee)
                        .run()
                    break
            }

        GradleProject project = withConnection { ProjectConnection connection ->
            connection.model(GradleProject.class)
                .withArguments("--continuous")
                .setStandardOutput(stdout)
                .setStandardError(stderr)
                .get()
        }

        then:
        project != null
        def logOutput = stdout.toString()
        !logOutput.contains(waitingMessage)

            builder.setExecutable(getJavaLauncher().get().getExecutablePath().getAsFile());
            builder.getMainModule().set("jdk.httpserver");
            builder.setStandardOutput(System.out);
            builder.setErrorOutput(System.err);
            builder.setArgs(Arrays.asList("-p", getPort().get(), "-d", getDocsDirectory().get().getAsFile().getAbsolutePath()));

        usingToolingConnection(workingDir) { connection ->
            connection.newBuild()
                .withArguments(args)
                .addJvmArguments(jvmArgs)
                .setStandardOutput(new TeeOutputStream(output, System.out))
                .setStandardError(new TeeOutputStream(error, System.err))
                .run()
        }

            def build = connection.newBuild()
                .addProgressListener(progressEventCollector)
                .forTasks('test')
            if (enableStdoutProxying) {
                build.setStandardOutput(System.out).setStandardError(System.err)
            }
            build.run()
        }
    }

    protected static class TestFailureEventCollector implements ProgressListener {

        StreamByteBuffer errOutput = new StreamByteBuffer();
        StreamByteBuffer stdOutput = new StreamByteBuffer();
        toolExec.setErrorOutput(errOutput.getOutputStream());
        toolExec.setStandardOutput(stdOutput.getOutputStream());

        try {
            toolExec.execute();
            invocation.getLogger().operationSuccess(description.getDisplayName(), combineOutput(stdOutput, errOutput));

        ExecResult result = getExecOperations().exec(spec -> {
            spec.commandLine("git", "remote", "get-url", "origin");
            spec.setIgnoreExitValue(true);
            spec.setStandardOutput(output);
            spec.setWorkingDir(directory);
        });
        String outputString = output.toString().trim();
        return result.getExitValue() == 0 && url.equals(outputString);
    }

        execHandleBuilder.setErrorOutput(outputStream); // verbose output is written to stderr
        execHandleBuilder.setStandardOutput(new ByteArrayOutputStream());
        execHandleBuilder.build().start().waitForFinish().assertNormalExitValue();
    }

     * {@inheritDoc}
     * @since 5.0
     */
    @Override
    T addArguments(Iterable<String> arguments);

    /**
     * {@inheritDoc}
     * @since 1.0-milestone-3
     */
    @Override
    T setStandardOutput(OutputStream outputStream);

    /**
     * {@inheritDoc}
     * @since 1.0-milestone-3
     */
    @Override
    T setStandardError(OutputStream outputStream);

    /**
     * {@inheritDoc}