accessorsClassPath: ClassPath,
        scriptSource: ScriptSource
    ): CompiledScript {

        logClassLoadingOf(scriptTemplateId, scriptSource)

        return host.loadClassInChildScopeOf(
            baseScope,
            childScopeId = classLoaderScopeIdFor(scriptPath, scriptTemplateId),
            origin = ClassLoaderScopeOrigin.Script(scriptSource.fileName, scriptSource.longDisplayName, scriptSource.shortDisplayName),

    private final ScriptSource scriptSource;
    private final Integer lineNumber;

    public ScriptCompilationException(String message, Throwable cause, ScriptSource scriptSource, Integer lineNumber) {
        super(message, cause);
        this.scriptSource = scriptSource;
        this.lineNumber = lineNumber;
    }

    public ScriptSource getScriptSource() {
        return scriptSource;
    }

import spock.lang.Specification

class DefaultScriptPluginFactoryTest extends Specification {

    def scriptCompilerFactory = Mock(ScriptCompilerFactory)
    def scriptCompiler = Mock(ScriptCompiler)
    def scriptSource = Mock(ScriptSource)
    def scriptRunner = Mock(ScriptRunner)
    def script = Mock(BasicScript)
    def targetScope = Mock(ClassLoaderScope)
    def baseScope = Mock(ClassLoaderScope)

        final ScriptSource scriptSource = scriptSource(scriptText)
        def sourceHashCode = hashFor(scriptText)

        when:
        scriptCompilationHandler.compileToDir(scriptSource, classLoader, scriptCacheDir, metadataCacheDir, null, expectedScriptClass, verifier)

        then:
        checkScriptClassesInCache(true)

        when:

        }
    }

    private
    fun runInterpretationSequence(
        scriptSource: ScriptSource,
        sequence: InterpretationSequence,
        target: Any
    ): EvaluationResult<ConversionStepResult> =
        sequence.steps.map { step ->

        given:
        def scriptSource = scriptSourceFor(fileName)
        def target = new Object()

        when:
        def scriptPlugin = selector.create(scriptSource, scriptHandler, targetScope, baseScope, false)

        and:
        scriptPlugin.apply(target)

        then:
        1 * defaultScriptPlugin.source >> scriptSource
        1 * defaultScriptPlugin.apply(target)

        where:

        ScriptSource scriptSource = project.getBuildScriptSource();

        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Evaluating {} using {}.", project, scriptSource.getDisplayName());
        }

        final Timer clock = Time.startTimer();
        try {

    @Test
    public void filesWithSameNameAndDifferentPathHaveDifferentClassName() {
        ScriptSource source1 = forFile(new File(testDir, "build.gradle"));
        ScriptSource source2 = forFile(new File(testDir, "subdir/build.gradle"));
        assertThat(source1.getClassName(), not(equalTo(source2.getClassName())));

        ScriptSource source3 = forFile(new File(testDir, "build.gradle"));

        then:
        2 * scriptSource.getResource() >> scriptSourceResource
        1 * scriptSourceResource.getLocation() >> scriptSourceResourceLocation
        1 * scriptSourceResource.isContentCached() >> true
        1 * scriptSourceResource.getHasEmptyContent() >> false
        3 * decoratedScriptPlugin.getSource() >> scriptSource
        2 * scriptSource.shortDisplayName >> Describables.of("<test.source>")

    @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 final ScriptSource scriptSource;