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);

    private FileCollection classpath = getProject().files();
    private final ModularitySpec modularity;

    private String executable;
    private final Property<JavadocTool> javadocTool;

    public Javadoc() {
        ObjectFactory objectFactory = getObjectFactory();
        this.modularity = objectFactory.newInstance(DefaultModularitySpec.class);

            </tr>
            <tr>
                <td>mainModule</td>
                <td><literal>null</literal></td>
            </tr>
            <tr>
                <td>modularity</td>
                <td/>
            </tr>
            <tr>
                <td>args</td>
                <td><literal>[]</literal></td>
            </tr>
            <tr>

    private String applicationName;
    private String optsEnvironmentVar;
    private String exitEnvironmentVar;
    private FileCollection classpath;
    private final ModularitySpec modularity;
    private ScriptGenerator unixStartScriptGenerator = new UnixStartScriptGenerator();
    private ScriptGenerator windowsStartScriptGenerator = new WindowsStartScriptGenerator();

    public CreateStartScripts() {

                <td/>
            </tr>
            <tr>
                <td>failFast</td>
                <td><literal>false</literal></td>
            </tr>
            <tr>
                <td>modularity</td>
                <td/>
            </tr>
            <tr>
                <td>javaLauncher</td>
                <td><literal>java.toolchain</literal></td>
            </tr>
            <tr>

    private final SourceSetContainer sourceSets;

    private final JavaToolchainSpecInternal toolchainSpec;
    private final ObjectFactory objectFactory;
    private final ModularitySpec modularity;
    private final JavaToolchainSpec toolchain;
    private final ProjectInternal project;

    private final DirectoryProperty docsDir;
    private final DirectoryProperty testResultsDir;

 * limitations under the License.
 */

package org.gradle.api.jvm;

import org.gradle.api.provider.Property;
import org.gradle.api.tasks.Input;

/**
 * Description of the modularity of a classpath.
 * <p>
 * A classpath is a list of JAR files, classes and resources folders passed to one of the JDK's commands like javac, java, or javadoc.

        given:
        publishJavaModule('moda')
        consumingModuleInfo('requires moda')
        buildFile << """
            java.modularity.inferModulePath = false
        """

        when:
        fails ':compileJava'

        then:
        failure.assertHasErrorOutput 'module-info.java:1: error: module not found: moda'
    }

    def "does not run as module if module path inference is turned off"() {
        given:
        buildFile.text = buildFile.text.replace('java-library', 'application')
        buildFile << """
            tasks.run.modularity.inferModulePath = false
            application {
                mainClass.set('consumer.MainModule')
                mainModule.set('consumer')
            }
        """
        publishJavaModule('moda')

    }

    def "runs JUnit4 module test on classpath if module path inference is turned off"() {
        given:
        buildFile << """
            tasks.test.modularity.inferModulePath = false
            dependencies { testImplementation 'junit:junit:4.13' }
        """

        when:
        consumingModuleInfo('exports consumer')
        consumingModuleClass()