* The base class for all scripts executed by Gradle.
 */
public abstract class Script extends groovy.lang.Script {
    private ScriptSource source;
    private ClassLoader contextClassloader;

    public ScriptSource getScriptSource() {
        return source;
    }

    public void setScriptSource(ScriptSource source) {
        this.source = source;
    }

    public void setContextClassloader(ClassLoader contextClassloader) {

    @Override
    public <T extends Script, M> ScriptRunner<T, M> create(CompiledScript<T, M> script, ScriptSource source, ClassLoader contextClassLoader) {
        return new ScriptRunnerImpl<T, M>(script, source, contextClassLoader);
    }

    private class ScriptRunnerImpl<T extends Script, M> implements ScriptRunner<T, M> {
        private final ScriptSource source;
        private final ClassLoader contextClassLoader;
        private T script;

import org.gradle.configuration.ScriptPluginFactory
import org.gradle.groovy.scripts.ScriptSource
import spock.lang.Specification

import java.util.function.Consumer

class BuildScriptProcessorTest extends Specification {
    def project = Mock(ProjectInternal)
    def scriptSource = Mock(ScriptSource)
    def configurerFactory = Mock(ScriptPluginFactory)
    def scriptPlugin = Mock(ScriptPlugin)

import org.gradle.api.initialization.dsl.ScriptHandler;
import org.gradle.api.internal.initialization.ClassLoaderScope;
import org.gradle.groovy.scripts.ScriptSource;

public interface ScriptPluginFactory {
    ScriptPlugin create(ScriptSource scriptSource, ScriptHandler scriptHandler, ClassLoaderScope targetScope, ClassLoaderScope baseScope, boolean topLevelScript);

    }

    @Override
    public ScriptCompiler createCompiler(ScriptSource source) {
        return new ScriptCompilerImpl(source);
    }

    private class ScriptCompilerImpl implements ScriptCompiler {
        private final ScriptSource source;

        public ScriptCompilerImpl(ScriptSource source) {
            this.source = CachingScriptSource.of(source);
        }

        @Override

    }

    @Override
    public CompileOperation<BuildScriptData> getScriptCompileOperation(ScriptSource scriptSource, ScriptTarget scriptTarget) {
        BuildScriptTransformer buildScriptTransformer = new BuildScriptTransformer(scriptSource, scriptTarget);
        String templateId = scriptTarget.getId();

    private final StandardOutputCapture standardOutputCaptureMock = Mock(StandardOutputCapture.class)
    private final ClassLoader classLoaderDummy = Mock(ClassLoader.class)
    private final ScriptSource scriptSourceDummy = Mock(ScriptSource.class)
    private final ScriptExecutionListener scriptExecutionListenerMock = Mock(ScriptExecutionListener.class)
    private final Instantiator instantiatorMock = Mock(Instantiator.class)

    @Override
    public ScriptPlugin create(
        ScriptSource scriptSource, ScriptHandler scriptHandler, ClassLoaderScope targetScope,
        ClassLoaderScope baseScope, boolean topLevelScript
    ) {
        scriptSourceListener.scriptSourceObserved(scriptSource);
        ScriptPlugin scriptPlugin = scriptPluginFactoryFor(scriptSource.getFileName())
            .create(scriptSource, scriptHandler, targetScope, baseScope, topLevelScript);

        target: Any = mock(),
        scriptHandler: ScriptHandlerInternal = mock()
    ) = KotlinScriptHost(target, scriptSource(), scriptHandler, mock(), mock(), mock {
        on { get(ObjectFactory::class.java) } doAnswer { mock<ObjectFactory>() }
    })

    private
    fun scriptSource(): ScriptSource = mock { on { fileName } doReturn "script.gradle.kts" }
}


internal
inline fun mockSettings(

 * limitations under the License.
 */

package org.gradle.groovy.scripts.internal;

import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.internal.hash.HashCode;

public interface ScriptSourceHasher {
    HashCode hash(ScriptSource scriptSource);