operationParamsBuilder.addArguments(CollectionUtils.toList(Preconditions.checkNotNull(arguments)));
        return getThis();
    }

    @Override
    public T setStandardOutput(OutputStream outputStream) {
        operationParamsBuilder.setStdout(outputStream);
        return getThis();
    }

    @Override
    public T setStandardError(OutputStream outputStream) {

        withConnection { connection ->
            connection.newBuild()
                .forTasks(":ba")
                .addProgressListener(listener)
                .setStandardError(System.err)
                .setStandardOutput(System.out)
                .addArguments("--info")
                .run()
        }

        then:
        thrown(BuildException)
        listener.problems.isEmpty()
    }

        def e = TestFiles.execHandleFactory().newExec()
                .commandLine(commandLine)
                .redirectErrorStream()
                .setStandardInput(input)
                .setStandardOutput(output)
                .workingDir(new File(".").absoluteFile) //does not matter
                .build()
        e.start()
        def result = e.waitForFinish()
        result.rethrowFailure()

        }

        private ExecHandle executeTest(String testName, OutputStream outputStream, OutputStream errorStream) {
            execHandleBuilder.setArgs(toTestArgs(testName));
            execHandleBuilder.setStandardOutput(outputStream);
            execHandleBuilder.setErrorOutput(errorStream);
            return execHandleBuilder.build();
        }

        private static List<String> toTestArgs(String testName) {

        }

        def execHandleFactory = Mock(ExecHandleFactory)
        def exec = Mock(ExecHandleBuilder)
        execHandleFactory.newExec() >> exec
        PrintStream output
        exec.setStandardOutput(_ as OutputStream) >> { OutputStream outputStream ->
            output = new PrintStream(outputStream)
            null
        }
        def handle = Mock(ExecHandle)
        handle.start() >> handle

        ByteArrayOutputStream output = new ByteArrayOutputStream()
        withConnection {
            BuildLauncher launcher = it.newBuild().setStandardOutput(output)
            config(launcher)
            launcher.run()
        }
        return output.toString()
    }

            } else if (hasAdditionalEnvVars()) {
                spec.environment(getParameters().getAdditionalEnvironmentVariables().get());
            }
            spec.setStandardOutput(stdout);
            spec.setErrorOutput(stderr);
        });
        return new ExecOutputData(r, stdout.toByteArray(), stderr.toByteArray());
    }

    @Override
    public String getDisplayName() {

            String mainClassname = Files.getNameWithoutExtension(probe.getName());
            exec.args("-Xmx32m", "-Xms32m", "-cp", ".", mainClassname);
            exec.setStandardOutput(out);
            exec.setErrorOutput(errorOutput);
            exec.setIgnoreExitValue(true);
            ExecResult result = exec.build().start().waitForFinish();
            int exitValue = result.getExitValue();

    }

    private ExecHandle buildExecHandle() {
        AbstractExecHandleBuilder builder = execHandleFactory.create();
        assert builder != null;
        return builder
            .setStandardOutput(standardOutputCapturer.getOutputStream())
            .setErrorOutput(errorOutputCapturer.getOutputStream())
            .build();
    }

    private void printExecHandleSettings() {

    }

    void vswhereResults(String jsonResult) {
        OutputStream outputStream

        1 * execActionFactory.newExecAction() >> execAction
        1 * execAction.setStandardOutput(_ as OutputStream) >> { args ->
            outputStream = args[0]
            return null
        }
        1 * execAction.execute() >> {
            outputStream.write(jsonResult.bytes)