platform.getOperatingSystem() >> Mock(OperatingSystemInternal) { getName() >> "os" }
        2 * toolChain.select(platform) >> platformToolChain
        2 * platformToolChain.newCompiler({CCompileSpec.class.isAssignableFrom(it)}) >> cCompiler
        pch.objectFile >> temporaryFolder.file("pchObjectFile").createFile()
        pch.name >> "testPch"
        pch.projectPath >> ":"

        platform.getOperatingSystem() >> Mock(OperatingSystemInternal) { getName() >> "os" }
        1 * toolChain.select(platform) >> platformToolChain
        1 * platformToolChain.newCompiler({ObjectiveCppPCHCompileSpec.class.isAssignableFrom(it)}) >> objCppPCHCompiler
        1 * objCppPCHCompiler.execute({ ObjectiveCppPCHCompileSpec spec ->
            assert spec.sourceFiles*.name== ["sourceFile"]

        platform.getOperatingSystem() >> Mock(OperatingSystemInternal) { getName() >> "os" }
        1 * toolChain.select(platform) >> platformToolChain
        1 * platformToolChain.newCompiler({ObjectiveCPCHCompileSpec.class.isAssignableFrom(it)}) >> objCPCHCompiler
        1 * objCPCHCompiler.execute({ ObjectiveCPCHCompileSpec spec ->
            assert spec.sourceFiles*.name== ["sourceFile"]

		IntroducedVersion: version.MajorMinor(1, 999),
		EnvOptions:        []celgo.EnvOption{library.Test()},
	})
	if err != nil {
		t.Fatal(err)
	}
	compiler := NewCompiler(extended)

	for _, tc := range cases {
		envType := tc.envType
		if envType == "" {
			envType = environment.NewExpressions
		}
		t.Run(tc.name, func(t *testing.T) {

        this.targetPlatform = objectFactory.property(NativePlatform.class);
        this.toolChain = objectFactory.property(NativeToolChain.class);
        incrementalCompiler = getIncrementalCompilerBuilder().newCompiler(this, source, includes, macros, Providers.FALSE);
        getInputs().property("outputType", new Callable<String>() {
            @Override
            public String call() {

type Compiler interface {
	CompileCELExpression(expressionAccessor ExpressionAccessor) (CompilationResult, error)
}

type compiler struct {
	envSet *environment.EnvSet
}

// NewCompiler returns a new Compiler.
func NewCompiler(env *environment.EnvSet) Compiler {
	return &compiler{
		envSet: mustBuildEnv(env),
	}
}

func (c compiler) CompileCELExpression(expressionAccessor ExpressionAccessor) (CompilationResult, error) {

        platform.getOperatingSystem() >> Mock(OperatingSystemInternal) { getName() >> "os" }
        2 * toolChain.select(platform) >> platformToolChain
        2 * platformToolChain.newCompiler({ ObjectiveCCompileSpec.class.isAssignableFrom(it) }) >> objCCompiler
        pch.includeString >> "header"
        pch.prefixHeaderFile >> temporaryFolder.file("prefixHeader").createFile()

        platform.getOperatingSystem() >> Mock(OperatingSystemInternal) { getName() >> "os" }
        1 * toolChain.select(platform) >> platformToolChain
        1 * platformToolChain.newCompiler({AssembleSpec.class.isAssignableFrom(it)}) >> assembler
        1 * assembler.execute({ AssembleSpec spec ->
            assert spec.sourceFiles*.name == ["sourceFile"]
            assert spec.args == ['arg']

        platform.getOperatingSystem() >> Mock(OperatingSystemInternal) { getName() >> "os" }
        1 * toolChain.select(platform) >> platformToolChain
        1 * platformToolChain.newCompiler({CPCHCompileSpec.class.isAssignableFrom(it)}) >> cPCHCompiler
        1 * cPCHCompiler.execute({ CPCHCompileSpec spec ->
            assert spec.sourceFiles*.name== ["sourceFile"]
            assert spec.args == ['arg']

        this.projectCacheDir = projectCacheDir;
        this.problems = problems;
    }

    @Override
    public Compiler<GroovyJavaJointCompileSpec> newCompiler(GroovyJavaJointCompileSpec spec) {
        MinimalGroovyCompileOptions groovyOptions = spec.getGroovyCompileOptions();
        CompilerWorkerExecutor compilerWorkerExecutor =
            groovyOptions.isFork() ?