import spock.lang.Specification

class PluginRequestCollectorTest extends Specification {

    final scriptSource = new TextResourceScriptSource(new StringTextResource("d", "c"))
    static final int LINE_NUMBER = 10

    List<Map> plugins(@DelegatesTo(PluginDependenciesSpec) Closure<?> closure) {
        new PluginRequestCollector(scriptSource).with {
            createSpec(LINE_NUMBER).with(closure)
            listPluginRequests()

import org.gradle.api.internal.initialization.ClassLoaderScope;
import org.gradle.cache.internal.CrossBuildInMemoryCache;
import org.gradle.cache.internal.CrossBuildInMemoryCacheFactory;
import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.internal.Cast;
import org.gradle.internal.hash.HashCode;

public class CrossBuildInMemoryCachingScriptClassCache {

import org.gradle.api.internal.initialization.ClassLoaderScope;
import org.gradle.api.internal.initialization.ScriptHandlerFactory;
import org.gradle.api.internal.properties.GradleProperties;
import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.internal.extensibility.ExtensibleDynamicObject;
import org.gradle.internal.metaobject.DynamicObject;
import org.gradle.internal.reflect.Instantiator;
import org.gradle.internal.service.ServiceRegistry;

import org.gradle.api.initialization.ProjectDescriptor;
import org.gradle.api.internal.GradleInternal;
import org.gradle.api.internal.initialization.ClassLoaderScope;
import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.groovy.scripts.TextResourceScriptSource;
import org.gradle.initialization.DefaultProjectDescriptor;
import org.gradle.initialization.DependenciesAccessors;

 * limitations under the License.
 */
package org.gradle.internal.exceptions;

import org.apache.commons.lang.StringUtils;
import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.internal.scan.UsedByScanPlugin;

import javax.annotation.Nullable;

/**
 * A {@code LocationAwareException} is an exception which can be annotated with a location in a script.
 */

import static org.apache.commons.lang.StringUtils.substringBeforeLast;
import static org.gradle.internal.hash.Hashing.hashString;

/**
 * A {@link ScriptSource} which loads the script from a URI.
 */
public class TextResourceScriptSource implements ScriptSource {
    private final TextResource resource;
    private String className;

    public TextResourceScriptSource(TextResource resource) {

    override fun runInterpretationSequenceStep(
        scriptIdentifier: String,
        scriptSource: String,
        step: InterpretationSequenceStep,
        stepContext: ConversionStepContext
    ): EvaluationResult<ConversionStepResult> = when (val analysisResult = analysisStepRunner.runInterpretationSequenceStep(scriptIdentifier, scriptSource, step, stepContext.analysisStepContext)) {
        is EvaluationResult.NotEvaluated ->

            else -> when (data.moduleKind) {
                TestModuleKind.Source -> {
                    true
                }

                TestModuleKind.ScriptSource,
                TestModuleKind.LibraryBinary,
                TestModuleKind.LibraryBinaryDecompiled,
                TestModuleKind.LibrarySource,
                TestModuleKind.CodeFragment,

    val scriptSource = textResourceScriptSource(resourceDescription, scriptFile, project.serviceOf())
    val scriptScope = baseScope.createChild("model-${scriptFile.toURI()}", null)
    val scriptHandler = scriptHandlerFactory.create(scriptSource, scriptScope)

    kotlinScriptFactoryOf(project).evaluate(
        target = target,
        scriptSource = scriptSource,
        scriptHandler = scriptHandler,

                TestModuleKind.LibraryBinaryDecompiled,
                TestModuleKind.CodeFragment -> {
                    true
                }

                TestModuleKind.ScriptSource,
                TestModuleKind.LibrarySource,
                TestModuleKind.NotUnderContentRoot -> {
                    false
                }
            }
        }
    }