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()) {

    }

    @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)
    }

  llvm::InitLLVM y(argc, argv);
  llvm::cl::ParseCommandLineOptions(argc, argv);
  auto file_or_err = llvm::MemoryBuffer::getFileOrSTDIN(inputFileName.c_str());
  if (std::error_code error = file_or_err.getError()) {
    llvm::errs() << argv[0] << ": could not open input file '" << inputFileName
                 << "': " << error.message() << "\n";
    return 1;
  }
  auto buffer = file_or_err->get();

    }

    @Override
    public StandardStreamContent getStandardError() {
        return new DefaultStandardStreamContent(dataProvider.map(transformer(ExecOutputData::getError)));
    }

    private static class DefaultStandardStreamContent implements StandardStreamContent {
        private final Provider<byte[]> bytesProvider;