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,

    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()

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(

            this.isEmpty = isEmpty;
            this.hasMethods = hasMethods;
            this.scriptBaseClass = scriptBaseClass;
            this.scriptClassPath = scriptClassPath;
            this.targetScope = targetScope;
            this.source = source;

    }

    @Override
    public <T extends Script, M> CompiledScript<T, M> compile(
        final ScriptSource source, final Class<T> scriptBaseClass, final Object target,
        final ClassLoaderScope targetScope,
        final CompileOperation<M> operation,
        final Action<? super ClassNode> verifier
    ) {
        assert source.getResource().isContentCached();
        if (source.getResource().getHasEmptyContent()) {

    kotlinScriptFactoryOf(project).evaluate(
        target = target,
        scriptSource = scriptSource,
        scriptHandler = scriptHandler,
        targetScope = scriptScope,
        baseScope = baseScope,
        topLevelScript = false,
        options = EnumSet.of(EvalOption.IgnoreErrors, EvalOption.SkipBody)
    )