def scriptCompiler = Mock(ScriptCompiler)
    def scriptSource = Mock(ScriptSource)
    def scriptRunner = Mock(ScriptRunner)
    def script = Mock(BasicScript)
    def targetScope = Mock(ClassLoaderScope)
    def baseScope = Mock(ClassLoaderScope)
    def baseChildClassLoader = Mock(ClassLoader)
    def pluginRequestApplicator = Mock(PluginRequestApplicator)

            sourceHash: HashCode,
            accessorsClassPath: ClassPath
        ) {
            val targetScope = scriptHost.targetScope
            val parentClassLoader = targetScope.exportClassLoader
            val compileClassPath = host.compilationClassPathOf(targetScope.parent)

            val programId = ProgramId(
                scriptTemplateId,
                sourceHash,

            CompiledScript<T, M> compiledScript = scriptClassCompiler.compile(source, scriptType, target, targetScope, extractingTransformer, verifier);
            return scriptRunnerFactory.create(compiledScript, source, targetScope.getExportClassLoader());
        }
    }

            val pluginManager = get(PluginManagerInternal::class.java)
            val pluginApplicator = get(PluginRequestApplicator::class.java)
            pluginApplicator.applyPlugins(PluginRequests.of(pluginRequests), scriptHandler, pluginManager, targetScope)
        }
        targetScope.lock()
    }
}


private

        val scriptHandler = mock<ScriptHandlerInternal>()
        val targetScope = mock<ClassLoaderScope>()

        // when:
        val subject = PluginRequestsHandler(pluginRequestApplicator, autoAppliedPluginHandler)
        subject.handle(initialRequests, scriptHandler, target, targetScope)

        // then:

        return new ScriptPluginImpl(scriptSource, (ScriptHandlerInternal) scriptHandler, targetScope, baseScope, topLevelScript);
    }

    private class ScriptPluginImpl implements ScriptPlugin {
        private final ScriptSource scriptSource;
        private final ClassLoaderScope targetScope;
        private final ClassLoaderScope baseScope;

        scriptSource: ScriptSource,
        scriptHandler: ScriptHandler,
        targetScope: ClassLoaderScope,
        baseScope: ClassLoaderScope,
        topLevelScript: Boolean
    ): ScriptPlugin =
        DeclarativeDslPlugin(scriptSource) { target ->
            when (val result = declarativeKotlinScriptEvaluator.evaluate(target, scriptSource, targetScope)) {
                is EvaluationResult.Evaluated -> Unit

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

    def defaultScriptPlugin = Mock(ScriptPlugin)

    def setup() {
        _ * defaultScriptPluginFactory.create(*_) >> defaultScriptPlugin
    }

    @Override
    public <T extends Script, M> CompiledScript<T, M> compile(ScriptSource source, Class<T> scriptBaseClass, Object target, ClassLoaderScope targetScope, CompileOperation<M> operation, Action<? super ClassNode> verifier) {
        ScriptCacheKey key = new ScriptCacheKey(source.getClassName(), targetScope.getExportClassLoader(), operation.getId());
        CompiledScript<T, M> compiledScript = Cast.uncheckedCast(cachedCompiledScripts.get(key));

    override fun evaluate(
        target: Any,
        scriptSource: ScriptSource,
        targetScope: ClassLoaderScope
    ): EvaluationResult<ConversionStepResult> {
        val scriptContext = scriptContextFor(target, scriptSource, targetScope)
        return when (val built = schemaBuilder.getEvaluationSchemaForScript(scriptContext)) {