}

    @Override
    public ClassPath resolveClassPath(Configuration classpathConfiguration, ScriptClassPathResolutionContext resolutionContext) {
        return buildQueue.build(
            currentBuild,
            taskIdentifiersForBuildDependenciesOf(classpathConfiguration),
            () -> scriptClassPathResolver.resolveClassPath(classpathConfiguration, resolutionContext)
        );
    }

    void prepareClassPath(Configuration classpathConfiguration, ScriptClassPathResolutionContext resolutionContext);

    ClassPath resolveClassPath(Configuration classpathConfiguration, ScriptClassPathResolutionContext resolutionContext);

     */
    void prepareClassPath(Configuration configuration, ScriptClassPathResolutionContext resolutionContext);

    ClassPath resolveClassPath(Configuration classpath, ScriptClassPathResolutionContext resolutionContext);

        when:
        def classpath = handler.instrumentedScriptClassPath

        then:
        0 * configuration._
        0 * buildLogicBuilder.resolveClassPath(_, _)

        and:
        classpath == ClassPath.EMPTY
    }

    def "resolves classpath configuration when configuration container has been queried"() {
        def classpath = Mock(ClassPath)

            });
        }

        public ClassPath getRuntimeClasspath() {
            return rootProjectState.fromMutableState(project -> resolver.resolveClassPath(classpathConfiguration, resolutionContext));
        }
    }

    public ClassPath getInstrumentedScriptClassPath() {
        if (resolvedClasspath == null) {
            if (classpathConfiguration != null) {
                Factory<ClassPath> classPathFactory = () -> buildLogicBuilder.resolveClassPath(classpathConfiguration, resolutionContext);
                if (getBoolean(DISABLE_RESET_CONFIGURATION_SYSTEM_PROPERTY)) {
                    resolvedClasspath = classPathFactory.create();
                } else {

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

    private PluginRegistry newPluginRegistryOf(ClassPath classPath) {

            version.reject(Log4jBannedVersion.LOG4J2_CORE_VULNERABLE_VERSION_RANGE);
        })));
    }

    @Override
    public ClassPath resolveClassPath(Configuration classpathConfiguration, ScriptClassPathResolutionContext resolutionContext) {
        // We clear resolution scope from service after the resolution is done, so data is not reused between invocations.

        val resolutionContext = resolver.prepareDependencyHandler(dependencies)
        resolver.prepareClassPath(configuration, resolutionContext)
        return resolver.resolveClassPath(configuration, resolutionContext)
    }

    private
    fun createBuildLogicClassPathConfiguration(
        dependencyHandler: DependencyHandler,
        configurations: ConfigurationContainer,