dependencies {
                implementation 'org:foo:1.0'
                runtimeOnly 'org:bar:1.0'
                testImplementation 'org:baz:1.0'
            }
        """
        def resolve = resolveClasspath 'runtime'

        when:
        foo.pom.expectGet()
        foo.artifact.expectGet()
        bar.pom.expectGet()
        bar.artifact.expectGet()
        transitive10.pom.expectGet()

    }

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

        this.delegate = delegate;
    }

    @Override
    public WorkResult execute(ScalaJavaJointCompileSpec spec) {
        resolveSourceFiles(spec);
        resolveClasspath(spec);
        resolveNonStringsInCompilerArgs(spec);
        logSourceFiles(spec);
        logCompilerArguments(spec);
        return delegateAndHandleErrors(spec);
    }

    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.