String gradleStderr = result.getError();
        if (!outputs.isEmpty()) {
            gradleStdout = fileContents(outputs.get(0).stdout);
            gradleStderr = fileContents(outputs.get(0).stderr);
        }
        System.out.println(result.getOut());
        System.out.println(gradleStdout);
        System.out.println(gradleStderr);
        System.out.println(result.getError());

package main

/*
char *geterror() {
	return "cgo error";
}
*/
import "C"
import (
	"fmt"
)

func init() {
	register("CgoPanicDeadlock", CgoPanicDeadlock)
}

type cgoError struct{}

func (cgoError) Error() string {
	fmt.Print("") // necessary to trigger the deadlock
	return C.GoString(C.geterror())
}

func CgoPanicDeadlock() {
	panic(cgoError{})

        if (!vsWhereOutput.getError().trim().isEmpty()) {
            throw new IllegalStateException(String.format("Could not determine the location of MSBuild %s: %s", vsVersion.getMajor(), vsWhereOutput.getError()));
        }

        String location = vsWhereOutput.getOut().trim();
        TestFile msbuild;
        if (!location.isEmpty()) {

	}

	fd := int(netns.Fd())
	resp, err := latestConn.send(ctx, data, &fd)
	if err != nil {
		return err
	}

	if resp.GetAck().GetError() != "" {
		log.Errorf("add-workload: got ack error: %s", resp.GetAck().GetError())
		return fmt.Errorf("got ack error: %s", resp.GetAck().GetError())
	}
	return nil
}

// TODO ctx is unused here
// nolint: unparam

    }

    @Override
    public TestLogging getError() {
        return perLevelTestLogging.get(LogLevel.ERROR);
    }

    @Override
    public void setError(TestLogging logging) {
        perLevelTestLogging.put(LogLevel.ERROR, logging);
    }

    @Override
    public void error(Action<TestLogging> action) {
        action.execute(getError());
    }

    @Override

        // the error output only if xcodebuild failed most likely due to Gradle.
        System.out.println(result.getOut());
        System.out.println(result.getError());
        return OutputScrapingExecutionFailure.from(result.getOut(), result.getError());
    }

    private TestFile findXcodeBuild() {
        TestFile xcodebuild = new TestFile("/usr/bin/xcodebuild");

    }

    @Override
    public GroupedOutputFixture getGroupedOutput() {
        return delegate.getGroupedOutput();
    }

    @Override
    public String getError() {
        return delegate.getError();
    }

    @Override
    public String getOutputLineThatContains(String text) {
        return delegate.getOutputLineThatContains(text);
    }

    @Override

        succeeds("run")

        then:
        def output = result.groupedOutput.task(':run').output
        output.contains(EXPECTED_OUTPUT)
        def errorOutput = errorsShouldAppearOnStdout() ? output : result.getError()
        errorOutput.contains(EXPECTED_ERROR)
    }

    def "JavaExec task output is grouped with its task output"() {
        given:
        generateMainJavaFileEchoing(EXPECTED_OUTPUT, EXPECTED_ERROR)

        executer.expectDeprecationWarning(expectedOutput)
        succeeds('compileJava')

        then:
        def actualOutput = errorsShouldAppearOnStdout() ? result.groupedOutput.task(':compileJava').output : result.getError()
        actualOutput.contains(expectedOutput)
    }

    public boolean hasErrorOutput(String expectedOutput) {
        return getError().contains(expectedOutput);
    }

    @Override
    public ExecutionResult assertHasErrorOutput(String expectedOutput) {
        return assertContentContains(errorContent.withNormalizedEol(), expectedOutput, "Error output");
    }

    @Override
    public String getError() {
        return error.withNormalizedEol();
    }