builder.executable 'my-app'
        builder.standardOutput = new ByteArrayOutputStream()
        builder.errorOutput = new ByteArrayOutputStream()

        def result = builder.run()
        result.assertNormalExitValue()

        assert builder.standardOutput.toString().contains('Greetings from the sample application.')
        assert builder.errorOutput.toString() == ''
    }

        execHandle.state == ExecHandleState.SUCCEEDED
        result.exitValue == 0
        out.toString() == "output args: [arg1, arg2]"
        err.toString() == "error args: [arg1, arg2]"
        result.assertNormalExitValue()
        1 * buildCancellationToken.addCallback(_) >> {
            assert it[0].class == ExecHandleShutdownHookAction
            true
        }
        1 * buildCancellationToken.removeCallback(_) >> {

                    "--scan-folder", new File(bundleDir, "Contents/Frameworks").getAbsolutePath()
                );
            }
        }).assertNormalExitValue();
    }

    /**
     * Returns the script file that can be used to run the install image.
     */
    @Internal
    public Provider<RegularFile> getRunScriptFile() {

                // anything else is considered an execution failure
                if (result.getExitValue() != 0 && result.getExitValue() != 1) {
                    result.rethrowFailure().assertNormalExitValue();
                }
            } catch (ExecException e) {
                stdOut.endOfStream(e);
                stdErr.endOfStream(null);
            } finally {
                execHandle = null;

        StreamByteBuffer errorBuffer = new StreamByteBuffer();
        execAction.setStandardOutput(buffer.getOutputStream());
        execAction.setErrorOutput(errorBuffer.getOutputStream());
        execAction.execute().assertNormalExitValue();
        return buffer.readAsString().trim();
    }

    private Map<String, String> parseDefines(String output, File gccBinary) {
        BufferedReader reader = new BufferedReader(new StringReader(output));

            this.displayName = displayName;
        }

        @Override
        public int getExitValue() {
            return exitValue;
        }

        @Override
        public ExecResult assertNormalExitValue() throws ExecException {
            if (exitValue != 0) {
                throw new ExecException(format("Process '%s' finished with non-zero exit value %d", displayName, exitValue));
            }

        1 * action.setStandardOutput(_) >> { OutputStream outputStream -> outputStream.write(to.bytes) }
        1 * action.execute() >> execResult
        _ * execResult.assertNormalExitValue()
    }

    Transformer transformer(constant) {
        transformer { constant }
    }

    Transformer transformer(Closure closure) {
        new Transformer() {