verify(host).compilationClassPathOf(targetScope)

                verify(host).startCompilerOperation(shortScriptDisplayName.displayName)

                verify(compilerOperation).close()

                verify(host).loadClassInChildScopeOf(
                    targetScope,
                    "kotlin-dsl:$scriptPath:$stage2TemplateId",

    def project = Mock(ProjectInternal)
    def scriptSource = Mock(ScriptSource)
    def configurerFactory = Mock(ScriptPluginFactory)
    def scriptPlugin = Mock(ScriptPlugin)
    def targetScope = Mock(ClassLoaderScope)
    def baseScope = Mock(ClassLoaderScope)
    def projectState = Mock(ProjectState)
    def buildScriptProcessor = new BuildScriptProcessor(configurerFactory)

        Object target,
        ScriptSource source,
        ClassLoaderScope targetScope,
        CompileOperation<M> operation,
        Class<T> scriptBaseClass,
        Action<? super ClassNode> verifier,
        ScriptClassCompiler delegate
    ) {
        ScriptCacheKey key = new ScriptCacheKey(source.getClassName(), targetScope.getExportClassLoader(), operation.getId());

            val targetScope = mock<AbstractClassLoaderScope> {
                on { localClassLoader } doReturn loader
                on { exportClassLoader } doReturn loader.parent
                on { parent }.then { it.mock }
                on { path }.then { "the path" }
            }

            val json = classLoaderHierarchyJsonFor(`class`, targetScope)

            val mapper = jacksonObjectMapper()

        when:
        def compiler = factory.createCompiler(source)
        def result = compiler.compile(Script, target, targetScope, operation, verifier)

        then:
        result == runner

        1 * scriptClassCompiler.compile({ it instanceof CachingScriptSource}, Script, target, targetScope, operation, verifier) >> compiledScript

    private String scriptText
    private String scriptClassName
    private String scriptFileName

    private ClassLoader classLoader = getClass().getClassLoader()
    private ClassLoaderScope targetScope = new RootClassLoaderScope("test", getClass().classLoader, getClass().classLoader, new DummyClassLoaderCache(), Stub(ClassLoaderScopeRegistryListener))

    private Action<ClassNode> verifier = Actions.doNothing()

) {

    fun handle(
        pluginRequests: PluginRequests?,
        scriptHandler: ScriptHandlerInternal,
        target: PluginAwareInternal,
        targetScope: ClassLoaderScope
    ) {
        val initialRequests = pluginRequests ?: PluginRequests.EMPTY
        val autoAppliedPlugins = autoAppliedPluginHandler.getAutoAppliedPlugins(initialRequests, target)

    private val kotlinScriptEvaluator: KotlinScriptEvaluator
) : ScriptPluginFactory {

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

        KotlinScriptPlugin(scriptSource) { target ->

            kotlinScriptEvaluator

import java.io.File
import java.util.Optional


interface KotlinScriptEvaluator {

    fun evaluate(
        target: Any,
        scriptSource: ScriptSource,
        scriptHandler: ScriptHandler,
        targetScope: ClassLoaderScope,
        baseScope: ClassLoaderScope,
        topLevelScript: Boolean,
        options: EvalOptions
    )
}


internal
class StandardKotlinScriptEvaluator(

typealias PathStringFormatter = (String) -> String


internal
fun classLoaderHierarchyJsonFor(
    klass: Class<*>,
    targetScope: ClassLoaderScope,
    pathFormatter: PathStringFormatter = { it }
) =

    classLoaderHierarchyJsonFor(
        hierarchyOf(klass.classLoader),
        hierarchyOf(targetScope),
        pathFormatter
    )


private
typealias ClassLoaderId = String


private