Java 6 and 7 can be used for <<building_java_projects.adoc#sec:java_cross_compilation,compilation>> but are deprecated for use with testing. Testing with Java 6 and 7 will not be supported in Gradle 9.0.

Any fully supported version of Java can be used for compilation or testing.
However, the latest Java version may only be supported for compilation or testing, not for running Gradle.

            @org.codehaus.groovy.transform.GroovyASTTransformationClass("MyASTTransformation")
            public @interface MyAnnotation {}
        """
    }

    def 'always recompile if compilation avoidance is not enabled'() {
        given:
        settingsFile.text = settingsFile.text.readLines().findAll { !it.contains("enableFeaturePreview") }.join('\n')
        buildFile << """
            project(':b') {

                @ReplacesEagerProperty
                public abstract Property<String> getSourceCompatibility();
            }
        """

        when:
        Compilation compilation = compile(givenSource)

        then:
        assertThat(compilation)
            .generatedFile(CLASS_OUTPUT, "META-INF/gradle/instrumentation/upgraded-properties.json")
            .contentsAsString(StandardCharsets.UTF_8)

  // have been produced by this client.
  absl::StatusOr<std::string> SerializeExecutable(
      const xla::PjRtLoadedExecutable& executable) override;

  // PjRt doesn't support AOT compilation yet. Builds a PjRtLoadedExecutable and
  // serializes it to string.
  absl::StatusOr<std::string> BuildSerializedExecutable(
      const XlaCompiler::Options& options,

    implementation 'commons-lang:commons-lang:2.6'
    testImplementation 'junit:junit:4.+'
}

// tag::java-cross-compilation[]
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(7)
    }
}
// end::java-cross-compilation[]

tasks.withType(Test) {
    systemProperty('targetJavaVersion', project.findProperty('targetJavaVersion'))
}

    implementation("commons-lang:commons-lang:2.6")
    testImplementation("junit:junit:4.+")
}

// tag::java-cross-compilation[]
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(7)
    }
}
// end::java-cross-compilation[]

tasks.withType<Test>().configureEach {
    project.findProperty("targetJavaVersion")?.let { systemProperty("targetJavaVersion", it) }
}

	if testLang(t, "go9.99", src, outfile) == nil {
		t.Error("compilation with -lang=go9.99 succeeded unexpectedly")
	}

	// This test will have to be adjusted if we ever reach 1.99 or 2.0.
	if testLang(t, "go1.99", src, outfile) == nil {
		t.Error("compilation with -lang=go1.99 succeeded unexpectedly")
	}

	if testLang(t, "go1.8", src, outfile) == nil {
		t.Error("compilation with -lang=go1.8 succeeded unexpectedly")
	}

  // 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.

}

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

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

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