import java.io.File;
import java.net.URI;

/**
 * <p>A {@code ScriptHandler} allows you to manage the compilation and execution of a build script. You can declare the
 * classpath used to compile and execute a build script. This classpath is also used to load the plugins which the build
 * script uses.</p>
 *
 * <p>You can obtain a {@code ScriptHandler} instance using {@link org.gradle.api.Project#getBuildscript()} or {@link

        return PluginRequests.of(ImmutableList.copyOf(StreamSupport.stream(autoAppliedPlugins.spliterator(), false)
            .filter(autoAppliedPlugin -> !isAlreadyAppliedOrRequested(PluginCoordinates.from(autoAppliedPlugin), initialRequests, pluginContainer, scriptHandler))

import org.gradle.api.initialization.dsl.ScriptHandler
import org.gradle.api.internal.catalog.ExternalModuleDependencyFactory
import org.gradle.api.plugins.ExtensionAware
import org.gradle.kotlin.dsl.*


internal
class ScriptHandlerScopeInternal(
    private val scriptTarget: ExtensionAware,
    scriptHandler: ScriptHandler,
) : ScriptHandlerScope(scriptHandler) {

    /**

        1 * resolver.resolveUri('script') >> file
        1 * parentCompileScope.createChild("script-$file", null) >> scriptCompileScope
        1 * scriptHandlerFactory.create(_, scriptCompileScope) >> scriptHandler
        1 * scriptPluginFactory.create(_, scriptHandler, scriptCompileScope, parentCompileScope, false) >> configurer

        when:
        action.from('script')

        then:
        action.execute()
    }

import org.gradle.api.initialization.dsl.ScriptHandler
import org.gradle.internal.deprecation.DeprecationLogger
import java.io.File
import java.net.URI


/**
 * Facilitates the implementation of the [ScriptHandler] interface by delegation via subclassing.
 */
@Deprecated("Will be removed in Gradle 9.0")
abstract class ScriptHandlerDelegate : ScriptHandler {

    init {
        @Suppress("DEPRECATION")

    )

    def setup() {
        def configurations = Mock(ConfigurationContainer)
        scriptHandler.configurations >> configurations
        scriptHandler.scriptClassPath >> Mock(ClassPath)
        classPathScriptRunner.data >> PluginRequests.EMPTY
        def configuration = Mock(Configuration)
        configurations.getByName(ScriptHandler.CLASSPATH_CONFIGURATION) >> configuration
        configuration.getFiles() >> Collections.emptySet()

    }

    @Override
    public ScriptPlugin create(ScriptSource scriptSource, ScriptHandler scriptHandler, ClassLoaderScope targetScope, ClassLoaderScope baseScope, boolean topLevelScript) {
        return new ScriptPluginImpl(scriptSource, (ScriptHandlerInternal) scriptHandler, targetScope, baseScope, topLevelScript);
    }

    private class ScriptPluginImpl implements ScriptPlugin {

    private val kotlinScriptEvaluator: KotlinScriptEvaluator
) : ScriptPluginFactory {

    override fun create(
        scriptSource: ScriptSource,
        scriptHandler: ScriptHandler,
        targetScope: ClassLoaderScope,
        baseScope: ClassLoaderScope,
        topLevelScript: Boolean
    ): ScriptPlugin =

        KotlinScriptPlugin(scriptSource) { target ->

        else
            action()
    }

    private
    fun setupEmbeddedKotlinForBuildscript(scriptHandler: ScriptHandler) {
        embeddedKotlinProvider.pinEmbeddedKotlinDependenciesOn(
            scriptHandler.dependencies,
            "classpath"
        )
    }

    private
    val interpreter by lazy {

    def selector = new ScriptPluginFactorySelector(defaultScriptPluginFactory, providerInstantiator, new TestBuildOperationRunner(), new DefaultUserCodeApplicationContext(), remoteScriptListener)

    def scriptHandler = Mock(ScriptHandler)
    def targetScope = Mock(ClassLoaderScope)
    def baseScope = Mock(ClassLoaderScope)

    def defaultScriptPlugin = Mock(ScriptPlugin)

    def setup() {