*/
public interface ExecResult {
    /**
     * Returns the exit value of the process.
     */
    int getExitValue();

    /**
     * Throws an {@link org.gradle.process.internal.ExecException} if the process exited with a non-zero exit value.
     *
     * @return this
     * @throws ExecException if the process exited with a non-zero exit value
     */
    ExecResult assertNormalExitValue() throws ExecException;

        then:
        1 * execHandle.waitForFinish() >> execResult
        1 * execResult.rethrowFailure()
        1 * execResult.getExitValue() >> FAILURE_EXIT_VALUE
        0 * resultAssertion.execute(_)
        1 * execHandle.getDirectory() >> EXEC_HANDLE_DIR
        1 * execHandle.getCommand() >> EXEC_HANDLE_CMD
        1 * execHandle.getArguments() >> EXEC_HANDLE_ARGS
        1 * execResult.toString() >> executionResultMessage

        String stderr = stderrFuture.get()
        return new ExecResult(stderr: stderr, stdout: stdout, returnCode: returnCode)
    }

    static String getStdout(String command) {
        ExecResult execResult = exec(command)

        assert execResult.returnCode == 0: "$command failed with return code: $execResult"
        return execResult.stdout
    }

        1 * execResult.rethrowFailure() >> execResult
        1 * execResult.assertNormalExitValue() >> execResult
        1 * execHandle.abort()
        1 * acceptor.stop()
    }

    def startThrowsExceptionOnChildProcessFailureAndCleansUp() {
        ExecHandleListener listener
        def execResult = Mock(ExecResult)
        def failure = new RuntimeException('broken')

        when:

        super(fileResolver, executor, buildCancellationToken);
    }

    @Override
    public ExecResult execute() {
        ExecHandle execHandle = build();
        ExecResult execResult = execHandle.start().waitForFinish();
        if (!isIgnoreExitValue()) {
            execResult.assertNormalExitValue();
        }
        return execResult;
    }

        out << ["not sure about this", ""]
    }

    def "handles failure to execute swiftc"() {
        given:
        def visitor = new TreeFormatter()
        def action = Mock(ExecAction)
        def execResult = Mock(ExecResult)

        and:
        def metadataProvider = new SwiftcMetadataProvider(execActionFactory)
        def binary = new File("swiftc")

        when:

    private final Class<T> taskType;
    private final Property<ExecResult> execResult;
    private final DefaultExecSpec execSpec;

    public AbstractExecTask(Class<T> taskType) {
        execSpec = getObjectFactory().newInstance(DefaultExecSpec.class);
        execResult = getObjectFactory().property(ExecResult.class);
        this.taskType = taskType;
    }

    @Inject

    }

    private ExecutionResult waitForStop(boolean expectFailure) {
        ExecResult execResult = getExecHandle().waitForFinish();
        if (durationMeasurement != null) {
            durationMeasurement.stop();
        }
        execResult.rethrowFailure(); // nop if all ok

        String output = getStandardOutput();
        String error = getErrorOutput();

        this.processOperations = processOperations;
    }

    @Override
    public ExecResult exec(Action<? super ExecSpec> action) {
        return processOperations.exec(action);
    }

    @Override
    public ExecResult javaexec(Action<? super JavaExecSpec> action) {
        return processOperations.javaexec(action);
    }

		},
		{ // Probe fails
			probe:          execProbe,
			execResult:     probe.Failure,
			expectedResult: results.Failure,
		},
		{ // Probe succeeds
			probe:          execProbe,
			execResult:     probe.Success,
			expectedResult: results.Success,
		},
		{ // Probe result is warning
			probe:          execProbe,
			execResult:     probe.Warning,
			expectedResult: results.Success,
		},