* limitations under the License.
 */

package org.gradle.api.internal;

import org.gradle.internal.classpath.ClassPath;

import javax.annotation.Nullable;

public interface ClassPathProvider {
    /**
     * Returns the files for the given classpath, if known. Returns null for unknown classpath.
     */
    @Nullable
    ClassPath findClassPath(String name);

package org.gradle.api.internal

import spock.lang.Specification
import org.gradle.internal.classpath.ClassPath

class DefaultClassPathRegistryTest extends Specification {
    final ClassPathProvider provider1 = Mock()
    final ClassPathProvider provider2 = Mock()
    final DefaultClassPathRegistry registry = new DefaultClassPathRegistry(provider1, provider2)

    def "fails for unknown classpath"() {
        given:

    private final List<ClassPathProvider> providers = new ArrayList<ClassPathProvider>();

    public DefaultClassPathRegistry(ClassPathProvider... providers) {
        this.providers.addAll(Arrays.asList(providers));
    }

    @Override
    public ClassPath getClassPath(String name) {
        for (ClassPathProvider provider : providers) {

    @Provides
    fun createClassPathModeExceptionCollector() =
        ClassPathModeExceptionCollector()

    @Provides
    fun createKotlinScriptEvaluator(
        classPathProvider: KotlinScriptClassPathProvider,
        classloadingCache: KotlinScriptClassloadingCache,
        pluginRequestsHandler: PluginRequestsHandler,
        pluginRequestApplicator: PluginRequestApplicator,

 */

package org.gradle.process.internal.worker.child;

import org.gradle.api.Action;
import org.gradle.api.GradleException;
import org.gradle.api.JavaVersion;
import org.gradle.api.internal.ClassPathProvider;
import org.gradle.api.internal.classpath.ModuleRegistry;
import org.gradle.api.internal.jvm.JavaVersionParser;
import org.gradle.api.specs.Spec;
import org.gradle.cache.FileLockManager;

import static org.gradle.api.internal.artifacts.dsl.dependencies.DependencyFactoryInternal.ClassPathNotation.LOCAL_GROOVY;

public class DependencyClassPathProvider implements ClassPathProvider {
    private static final List<String> MODULES = Arrays.asList(
        "gradle-worker-main",
        "gradle-launcher",
        "gradle-workers",
        "gradle-dependency-management",
        "gradle-plugin-use",

        baseScope: ClassLoaderScope,
        topLevelScript: Boolean,
        options: EvalOptions
    )
}


internal
class StandardKotlinScriptEvaluator(
    private val classPathProvider: KotlinScriptClassPathProvider,
    private val classloadingCache: KotlinScriptClassloadingCache,
    private val pluginRequestApplicator: PluginRequestApplicator,
    private val pluginRequestsHandler: PluginRequestsHandler,

 */
package org.gradle.api.internal;

import org.gradle.api.internal.classpath.ModuleRegistry;
import org.gradle.internal.classpath.ClassPath;

public class DefaultClassPathProvider implements ClassPathProvider {
    private final ModuleRegistry moduleRegistry;

    public DefaultClassPathProvider(ModuleRegistry moduleRegistry) {
        this.moduleRegistry = moduleRegistry;
    }

    @Override

import java.io.File;
import java.util.HashSet;
import java.util.Set;

import static java.util.Collections.emptySet;

public class DynamicModulesClassPathProvider implements ClassPathProvider {
    private final ModuleRegistry moduleRegistry;
    private final PluginModuleRegistry pluginModuleRegistry;
    private final JavaVersion javaVersion;