if (!mainClass.isPresent()) {
            if (classpath != null && classpath.getFiles().size() == 1) {
                allArgs.add("-jar");
                allArgs.add(classpath.getSingleFile().getAbsolutePath());
            } else {
                throw new IllegalStateException("No main class specified and classpath is not an executable jar.");
            }

    return o as T
}


inline fun withClassLoaderFor(vararg classPath: File, action: ClassLoader.() -> Unit) =
    classLoaderFor(*classPath).use(action)


inline fun withClassLoaderFor(classPath: ClassPath, action: ClassLoader.() -> Unit) =
    classLoaderFor(classPath).use(action)


fun classLoaderFor(classPath: ClassPath): URLClassLoader =
    classLoaderFor(*classPath.asFiles.toTypedArray())

    repositories {
        maven {
            url = '$mavenRepo.uri'
        }
    }
    configurations.classpath {
        resolutionStrategy.activateDependencyLocking()
    }
    dependencies {
        classpath 'org.foo:foo-plugin:[1.0,2.0)'
    }
}
"""
        lockfileFixture.createBuildscriptLockfile('classpath', ['org.foo:foo-plugin:1.0'], unique)

        when:
        succeeds 'buildEnvironment'

        then:

    }

    @Override
    public ClassLoader get(ClassLoaderId id, ClassPath classPath, @Nullable ClassLoader parent, @Nullable FilteringClassLoader.Spec filterSpec) {
        return get(id, classPath, parent, filterSpec, null);
    }

    @Override

 * limitations under the License.
 */

package org.gradle.internal.classpath


import spock.lang.Specification

import static org.gradle.internal.classpath.TransformedClassPath.FileMarker.AGENT_INSTRUMENTATION_MARKER
import static org.gradle.internal.classpath.TransformedClassPath.FileMarker.INSTRUMENTATION_CLASSPATH_MARKER
import static org.gradle.internal.classpath.TransformedClassPath.FileMarker.LEGACY_INSTRUMENTATION_MARKER

    }

    @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")]

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