}
            resolvedDependencies += unresolvedDependencies
        }
    }

    if (!containsBuiltinKotlinModules(resolvedDependencies)) {
        sourcePath += kotlinLibSourcesFor(scriptHandlers)
    }

    return sourcePath
}


private
fun containsBuiltinKotlinModules(resolvedDependencies: Collection<ComponentIdentifier>): Boolean {

        List<Object> key = asList(requested, from, selected, resolvedVariant, constraint);
        if (!resolvedDependencies.containsKey(key)) {
            resolvedDependencies.put(key, new DefaultResolvedDependencyResult(requested, constraint, selected, resolvedVariant, from));
        }
        return resolvedDependencies.get(key);
    }

        def allDependencies = project.classpath
        def resolvedDependencies = project.classpath.findAll { it.resolved }
        def unresolvedDependencies = project.classpath.findAll { !it.resolved }

        then:
        allDependencies.size() == 2

        and:
        resolvedDependencies.size() == 1
        resolvedDependencies[0].resolved
        resolvedDependencies[0].attemptedSelector == null

        and:

                    Collections.shuffle(possibleDependencies, new Random(projectNumber as long))
                    resolvedDependencies = possibleDependencies.take(maxProjectDependencies).sort()
                }
                info.dependencies.put(projectNumber, resolvedDependencies as Collection<Integer>)
            }
        }
        info
    }

    class DependencyInfo {

        return dependencies;
    }

    public List<Dependency> getResolvedDependencies() {
        return resolvedDependencies;
    }

    public void addResolvedDependency(Dependency dependency) {
        dependencies.add(dependency);
        resolvedDependencies.add(dependency);
    }

    public List<Dependency> getUnresolvedDependencies() {
        return unresolvedDependencies;
    }

        IdeaModuleInternal ideaModuleExt = (IdeaModuleInternal) ideaModelExt.getModule();

        ideaModuleExt.setOffline(offlineDependencyResolution);
        Set<Dependency> resolvedDependencies = ideaModuleExt.resolveDependencies();

        IsolatedIdeaModuleInternal model = new IsolatedIdeaModuleInternal();

        model.setName(ideaModuleExt.getName());
        model.setJdkName(ideaModuleExt.getJdkName());

        InputFingerprinter inputFingerprinter = context != null ? context.getService(InputFingerprinter.class) : globalInputFingerprinter;

        Try<TransformDependencies> resolvedDependencies = upstreamDependencies.computeArtifacts();
        return resolvedDependencies
            .map(dependencies -> {
                ImmutableList<File> inputArtifacts = subjectToTransform.getFiles();
                if (inputArtifacts.isEmpty()) {

            .setTestOutputDir(ideaModule.getTestOutputDir());
    }

    public static List<DefaultIdeaDependency> buildDependencies(Set<Dependency> resolvedDependencies) {
        List<DefaultIdeaDependency> dependencies = new LinkedList<>();
        for (Dependency dependency : resolvedDependencies) {
            if (dependency instanceof SingleEntryModuleLibrary) {
                SingleEntryModuleLibrary d = (SingleEntryModuleLibrary) dependency;

internal
data class ReceivedModelResponse internal constructor(
    val correlationId: String,
    val scriptFile: File?,
    val response: KotlinBuildScriptModel
) : ResolverEvent()


internal
data class ResolvedDependencies internal constructor(
    val correlationId: String,
    val scriptFile: File?,
    val dependencies: KotlinScriptExternalDependencies
) : ResolverEvent()


internal

     */
    @Override
    public Map<MavenDependencyKey, PomDependencyData> getDependencies() {
        if (resolvedDependencies == null) {
            resolvedDependencies = resolveDependencies();
        }
        return resolvedDependencies;
    }

    private Map<MavenDependencyKey, PomDependencyData> resolveDependencies() {
        Map<MavenDependencyKey, PomDependencyData> dependencies = new LinkedHashMap<>();