}

dependencies {
    implementation 'commons-collections:commons-collections:3.2.2'
    testImplementation 'junit:junit:4.13'
}

// tag::force-compilation[]
tasks.withType(ScalaCompile) {
    scalaCompileOptions.with {
        force = true
    }
}

  // Runs the graph using specified batch size both with and without XLA JIT
  // compilation. Returns an error if the results between the two do not match.
  Status ExecuteWithBatch(const GraphDef& graph, int batch);

  // Adds the suffix "_altered" to the HLO module names of all of the persistent
  // XLA compilation cache entries found at the specified directory. If none are
  // found, returns NOT_FOUND error.

# Tests golang.org/issue/48490
# cmd/go should enable concurrent compilation by default

# Reset all experiments, since one of them can disable
# concurrent compilation, e.g: fieldtrack.
env GOEXPERIMENT=none

env GOMAXPROCS=4
go build -n -x -a fmt

    def 'compilation can be cached'() {
        when:
        withBuildCache().run compilationTask

        then:
        compileIsNotCached()

        when:
        withBuildCache().succeeds 'clean', compilationTask

        then:
        compileIsCached()
    }

    @Issue("https://github.com/gradle/gradle/issues/12860")
    def 'compilation is cached if the project version changes'() {

    /**
     * Get the consumable configuration which produces the {@code apiElements} variant of this feature.
     * This configuration includes all API compilation dependencies as well as the feature's
     * compilation outputs, but does not include {@code implementation}, {@code compileOnly},
     * or {@code runtimeOnly} dependencies.
     *
     * @return The {@code apiElements} configuration.
     */

					Expression: "user.username == 'foo'",
				},
			},
			wantErr: `compilation failed: ERROR: <input>:1:1: undeclared reference to 'user' (in container '')`,
		},
		{
			name: "invalid ClaimMappingCondition",
			expressionAccessors: []ExpressionAccessor{
				&ClaimMappingExpression{
					Expression: "claims + 1",
				},
			},

        }

        if (annotationProcessingConfigured) {

        return incremental;
    }

    /**
     * Used to enable or disable incremental compilation after a failure.
     * <p>
     * By default, incremental compilation after a failure is enabled for Java and Groovy.
     * It has no effect for Scala. It has no effect if incremental compilation is not enabled.
     * <p>

                """#if swift(>=5.0)
                        XCTFail("Compilation unit compiled with Swift 5+ instead of Swift 4.x");
                    #elseif swift(>=4.0)
                        // Do nothing
                    #else
                        XCTFail("Compilation unit compiled with Swift 3- instead of Swift 4.x");
                    #endif
                """)
        ]
    }

  return s;
}

// Rewrites shape inference graph for outside compilation:
// 1) If XlaSendFromHost also exists in `host_graph`, copy nodes from
//    `host_graph`. Because we might still have outside compilation to outside
//    compilation placeholder nodes in shape inference graph, which will prevent
//    us from inferring XlaSendFromHost shape. But in `host_graph`, we already