return scriptClassPathResolver.prepareDependencyHandler(dependencyHandler);
    }

    @Override
    public void prepareClassPath(Configuration classpathConfiguration, ScriptClassPathResolutionContext resolutionContext) {
        scriptClassPathResolver.prepareClassPath(classpathConfiguration, resolutionContext);
    }

    @Override

        1 * configurationContainer.migratingUnlocked('classpath', ConfigurationRolesForMigration.LEGACY_TO_RESOLVABLE_DEPENDENCY_SCOPE) >> configuration
        1 * buildLogicBuilder.prepareClassPath(configuration, resolutionContext)
        0 * configurationContainer._
        0 * depMgmtServices._
    }

    def "adds classpath configuration when dependencies container is queried"() {
        when:

@ServiceScope(Scope.Build.class)
public interface BuildLogicBuilder {

    ScriptClassPathResolutionContext prepareDependencyHandler(DependencyHandler dependencyHandler);

    void prepareClassPath(Configuration classpathConfiguration, ScriptClassPathResolutionContext resolutionContext);

    ClassPath resolveClassPath(Configuration classpathConfiguration, ScriptClassPathResolutionContext resolutionContext);

        this.superClasses = new HashMap<File, Boolean>();
    }

    protected abstract T createClassVisitor();

    private File getSuperTestClassFile(String superClassName) {
        prepareClasspath();
        if (StringUtils.isEmpty(superClassName)) {
            throw new IllegalArgumentException("superClassName is empty!");
        }

        File superTestClassFile = null;

    /**
     * Prepares the given configuration for script classpath resolution, setting the relevant attributes and other metadata.
     */
    void prepareClassPath(Configuration configuration, ScriptClassPathResolutionContext resolutionContext);

    ClassPath resolveClassPath(Configuration classpath, ScriptClassPathResolutionContext resolutionContext);

                classpathConfiguration = rootProject.getConfigurations().resolvableDependencyScopeUnlocked("buildScriptClasspath");
                resolver.prepareClassPath(classpathConfiguration, resolutionContext);
                classpathConfiguration.getDependencies().add(rootProject.getDependencies().create(rootProject));

        ScriptClassPathResolutionContext resolutionContext = scriptClassPathResolver.prepareDependencyHandler(dependencies);
        scriptClassPathResolver.prepareClassPath(configuration, resolutionContext);
        ClassPath instrumentedClassPath = scriptClassPathResolver.resolveClassPath(configuration, resolutionContext);
        return newPluginRegistryOf(instrumentedClassPath);
    }

            classpathConfiguration = configContainer.migratingUnlocked(CLASSPATH_CONFIGURATION, ConfigurationRolesForMigration.LEGACY_TO_RESOLVABLE_DEPENDENCY_SCOPE);
            buildLogicBuilder.prepareClassPath(classpathConfiguration, resolutionContext);
        }
    }

    @Override
    public void dependencyLocking(Closure configureClosure) {

        // Register instrumentation pipelines
        return instrumentationTransformRegisterer.registerTransforms(dependencyHandler);
    }

    @Override
    public void prepareClassPath(Configuration configuration, ScriptClassPathResolutionContext resolutionContext) {
        // should ideally reuse the `JvmPluginServices` but this code is too low level
        // and this service is therefore not available!

        val resolver = gradle.serviceOf<ScriptClassPathResolver>()
        val resolutionContext = resolver.prepareDependencyHandler(dependencies)
        resolver.prepareClassPath(configuration, resolutionContext)
        return resolver.resolveClassPath(configuration, resolutionContext)
    }

    private
    fun createBuildLogicClassPathConfiguration(