private final ModularitySpec modularity;
    private File previousCompilationDataFile;
    private final Property<JavaCompiler> javaCompiler;

    public JavaCompile() {
        ObjectFactory objectFactory = getObjectFactory();
        compileOptions = objectFactory.newInstance(CompileOptions.class);
        modularity = objectFactory.newInstance(DefaultModularitySpec.class);

            </tr>
            <tr>
                <td>modularity</td>
                <td/>
            </tr>
            <tr>
                <td>javaCompiler</td>
                <td><literal>java.toolchain</literal></td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>

        def javaCompile = project.tasks.create("compileJava", JavaCompile)
        javaCompile.destinationDirectory.fileValue(new File('somewhere'))
        def invalidExecutable = temporaryFolder.file("invalidExecutable")

        when:
        javaCompile.options.fork = true
        javaCompile.options.forkOptions.executable = invalidExecutable
        javaCompile.createSpec()

        then:

        def javaCompile = project.tasks.create("compileJava", JavaCompile)
        javaCompile.destinationDirectory.fileValue(temporaryFolder.createDir())
        def invalidJavaHome = "invalidJavaHome"

        when:
        javaCompile.options.fork = true
        javaCompile.options.forkOptions.javaHome = new File("invalidJavaHome")
        javaCompile.createSpec()

        then:

        if (javaCompileTask instanceof JavaCompile) {
            JavaCompile javaCompile = (JavaCompile) javaCompileTask;
            if (javaCompile.getModularity().getInferModulePath().get()) {
                List<File> sourceRoots = CompilationSourceDirs.inferSourceRoots((FileTreeInternal) javaCompile.getSource());
                return JavaModuleDetector.isModuleSource(true, sourceRoots);

                            ]
                        },
                        {
                            "type": "org.gradle.api.tasks.compile.JavaCompile",
                            "member": "Method org.gradle.api.tasks.compile.JavaCompile.getSources()",
                            "acceptation": "Deprecated method removed",
                            "changes": [

import spock.lang.Issue

class DaemonJavaCompilerIntegrationTest extends AbstractJavaCompilerIntegrationSpec {

    @Override
    String compilerConfiguration() {
        """
            tasks.withType(JavaCompile) {
                options.fork = true
            }
        """
    }

    @Override
    String logStatement() {
        "compiler daemon"
    }

    def setup() {

import org.gradle.api.tasks.TaskContainer
import org.gradle.api.tasks.compile.JavaCompile
import org.gradle.kotlin.dsl.*


/**
 * Strict compilation options honored by [gradlebuild.Strict_compile_gradle].
 */
abstract class StrictCompileExtension(val tasks: TaskContainer) {

    fun ignoreDeprecations() {
        tasks.withType<JavaCompile>().configureEach {
            options.compilerArgs.add("-Xlint:-deprecation")
        }

import org.gradle.api.tasks.compile.JavaCompile

import static org.gradle.util.TestUtil.objectFactory

class DefaultJvmLanguageUtilitiesTest extends AbstractJvmPluginServicesTest {
    def "can register a new source directory set compiled with Java"() {
        def sourceSet = Mock(SourceSet)
        def sourceSetOutput = Mock(DefaultSourceSetOutput)
        def compileTask = Mock(JavaCompile)

                if (compile instanceof JavaCompile) {
                    JavaCompile javaCompile = (JavaCompile) compile;
                    if (javaCompile.getOptions().getRelease().isPresent()) {
                        return JavaVersion.toVersion(javaCompile.getOptions().getRelease().get());
                    }
                    if (rawConvention != null) {