}

    @Override
    public ClassPath getClassPath(String name) {
        for (ClassPathProvider provider : providers) {
            ClassPath classpath = provider.findClassPath(name);
            if (classpath != null) {
                return classpath;
            }
        }
        throw new IllegalArgumentException(String.format("unknown classpath '%s' requested.", name));
    }

    private final ClassLoaderScope parent;
    private final ClassPath classPath;
    @Nullable
    private final HashCode classpathImplementationHash;
    private final ClassLoader localClassLoader;

    public ImmutableClassLoaderScope(
        ClassLoaderScopeIdentifier id,
        ClassLoaderScope parent,
        @Nullable ClassLoaderScopeOrigin origin,
        ClassPath classPath,
        @Nullable HashCode classpathImplementationHash,

            "Compile initialization script 'init.gradle' (CLASSPATH)",
            "Compile initialization script 'init.gradle' (BODY)",
            "Compile settings file 'settings.gradle' (CLASSPATH)",
            "Compile settings file 'settings.gradle' (BODY)",
            "Compile build file 'build.gradle' (CLASSPATH)",
            "Compile build file 'build.gradle' (BODY)",

    def "creates a limited implementation classpath"() {
        when:
        def framework = newFramework(false, [], [], [], [])
        def classpath = underTest.create([new File("cls.jar")], [new File("mod.jar")], framework, false)

        then:
        classpath.applicationClasspath == [new File("cls.jar")]
        classpath.applicationModulepath == [new File("mod.jar")]

        ])

        then:
        classpath.files.size() == 13
        classpath.files.contains(project.file("groovy-${groovyVersion}.jar"))
        classpath.files.contains(project.file("groovy-ant-${groovyVersion}.jar"))
        classpath.files.contains(project.file("groovy-astbuilder-${groovyVersion}.jar"))
        classpath.files.contains(project.file("groovy-console-${groovyVersion}.jar"))

            substitute module("junit:junit:4.7") using project(":project1")
        }
    }
}
""")

        def classpath = classpath("project2")
        assert classpath.projects.collect { it.name } == ["project1"]
        assert classpath.libs == []
    }

    @Test
    @ToBeFixedForConfigurationCache
    void "transitive external dependency substituted with project dependency"() {

 */
package org.gradle.api.internal

import org.gradle.api.JavaVersion
import org.gradle.api.internal.classpath.Module
import org.gradle.api.internal.classpath.ModuleRegistry
import org.gradle.api.internal.classpath.PluginModuleRegistry
import org.gradle.internal.classpath.ClassPath
import org.gradle.internal.classpath.DefaultClassPath
import spock.lang.Specification

class DynamicModulesClassPathProviderTest extends Specification {

 * limitations under the License.
 */

package org.gradle.internal.classpath

import org.gradle.internal.classpath.intercept.JvmBytecodeInterceptorFactoryProvider
import org.gradle.internal.classpath.types.ExternalPluginsInstrumentationTypeRegistry
import org.gradle.internal.classpath.types.InstrumentationTypeRegistry

import java.util.function.Predicate

        Set<Configuration> testConfigurations = classpath.getTestConfigurations().getOrElse(Collections.emptySet());

        project.assertHasJavaFacetBuilders()

        // Classpath
        def classpath = classpath
        classpath.assertHasLibs('lib2-impl-2.0.jar', 'lib1-impl-1.0.jar', 'lib1-api-1.0.jar')
        classpath.lib('lib1-api-1.0.jar').assertIsDeployedTo('/lib')
        classpath.lib('lib1-impl-1.0.jar').assertIsDeployedTo('/lib')
        classpath.lib('lib2-impl-2.0.jar').assertIsDeployedTo('/')

        // Facets