This sample shows how to create a multi-project containing https://www.oracle.com/corporate/features/understanding-java-9-modules.html[Java Modules].
Java Modules are a feature of Java itself, available since Java 9, that allows for better encapsulation.

In Gradle, each _source set_ containing Java sources can be turned into a module by adding a `module-info.java` file.

     *
     * @deprecated A value of {@code true} does not mean that the dependency should
     * be placed on the classpath. See {@code JavaPathType} instead for better analysis.
     */
    @Deprecated
    boolean isAddedToClasspath();

    def setup() {
        // Generate Kotlin DSL sources once so they are included as :kotlin-dsl:compileKotlin inputs.
        // TODO:configuration-cache handle generated sources better (see gradlebuild.kotlin-dsl-dependencies-embedded.gradle.kts:39)
        run([':kotlin-dsl:generateKotlinDependencyExtensions'])
    }

    TestExecutionResult assertTestClassExecutedIn(String subProjectDir, String testClass) {

    protected void defaultSpec(GradleBuildExperimentSpec.GradleBuilder builder) {
    }

    protected void finalizeSpec(GradleBuildExperimentSpec.GradleBuilder builder) {
    }

    static {
        // TODO - find a better way to cleanup
        System.addShutdownHook {
            ((Closeable) RESULTS_STORE).close()
        }
    }

            // whereas console failure logging based on the _thrown exception_ happens up outside session scope. It would be better to refactor so that a result can be returned from here
            notifyEnterprisePluginManager(Result.failed(t));
            throw UncheckedException.throwAsUncheckedException(t);
        }

                    result.getMissingArtifacts(),
                    request.getRemoteRepositories());
        }

        // this should never happen since we checked all possible error sources before but better be sure
        if (result.hasExceptions()) {
            throw new ArtifactResolutionException(
                    "Unknown error during artifact resolution, " + request + ", " + result.getExceptions(),

    @Test
    @ToBeFixedForConfigurationCache
    void triggersBeforeAndWhenConfigurationHooks() {

        //this test is a bit peculiar as it has assertions inside the gradle script
        //couldn't find a better way of asserting on before/when configured hooks
        runIdeaTask '''
apply plugin: 'java'
apply plugin: 'idea'

def beforeConfiguredObjects = 0
def whenConfiguredObjects = 0

idea {
    project {

        // When there may be no more than one configuration, don't cache the resolution state for reuse. Currently, this only applies to detached configurations, however
        // it might be better to skip caching when it's likely there is only one configuration defined, for example, for script class paths, as the meta-data is unlikely to be reused.

            }
        }

        buildFile << """
            configurations.conf.resolutionStrategy.dependencySubstitution {
                substitute module("org:old") because "better foo than old" using module("org:foo:2.0")
            }
            dependencies {
                conf('org:foo') {
                   version { strictly '1.0' }
                }

     *
     * This is only well supported for PMD 5.2.1 or better.
     *
     * @since 2.8
     */
    public void setClasspath(@Nullable FileCollection classpath) {
        this.classpath = classpath;
    }

    /**
     * Controls whether to use incremental analysis or not.
     *