import org.gradle.internal.hash.HashCode;

import java.io.File;

public interface ScriptCompilationHandler {

    void compileToDir(ScriptSource source, ClassLoader classLoader, File classesDir, File metadataDir, CompileOperation<?> transformer,
                      Class<? extends Script> scriptBaseClass, Action<? super ClassNode> verifier);

        def classesDir = tmpDir.createDir("classes/$className")
        def compilationUnit = new CompilationUnit(new GroovyClassLoader(getClass().classLoader))
        compilationUnit.addSource(className, classText)

        def configuration = new CompilerConfiguration()
        configuration.setTargetDirectory(classesDir)

        compilationUnit.setConfiguration(configuration)

        <title>Properties</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>classesDir</td>
            </tr>
            <tr>
                <td>resourceDirs</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>

    final TestFile srcDir = temporaryFolder.createDir('src')
    final TestFile outDir = temporaryFolder.createDir('out')
    final TestFile classesDir = temporaryFolder.createDir('classes')

    def "code generation is deterministic regardless of type processing order"() {
        given:
        withAnnotatedType 'Foo'
        withAnnotatedType 'Bar'

        const val UPGRADED_PROPERTIES_FILE = "upgraded-properties.json"
    }

    @get:Inject
    abstract val inputChanges: InputChanges

    @get:Classpath
    @get:InputArtifact
    abstract val classesDir: Provider<FileSystemLocation>

    override fun transform(outputs: TransformOutputs) {
        val oldSuperTypes = Properties()
        val outputDir = outputs.dir("instrumentation")

        def classesDir1 = file("actions/1")
        copyClassTo(Action1, classesDir1)
        copyClassTo(SharedActionStaticState, classesDir1)
        def classesDir2 = file("actions/2")
        copyClassTo(Action2, classesDir2)
        def cl = actionClassLoader(classesDir1, classesDir2)
        def action1 = cl.loadClass(Action1.name)
        assert action1 != Action1

        super(taskDependencyFactory);
        this.fileResolver = fileResolver;

        this.classesDirs = fileCollectionFactory.configurableFiles(sourceSetDisplayName + " classesDirs");

        this.outputDirectories = fileCollectionFactory.configurableFiles(sourceSetDisplayName + " classes");
        outputDirectories.from(classesDirs, (Callable<File>) this::getResourcesDir);

// tag::test-task[]
val integrationTestTask = tasks.register<Test>("integrationTest") {
    description = "Runs the integration tests."
    group = "verification"
    testClassesDirs = integrationTest.output.classesDirs
    classpath = integrationTest.runtimeClasspath
    mustRunAfter(tasks.test)
}
tasks.check {
    dependsOn(integrationTestTask)
}
// end::test-task[]

val functionalTest by sourceSets.creating

// tag::test-task[]
def integrationTestTask = tasks.register("integrationTest", Test) {
    description = 'Runs the integration tests.'
    group = "verification"
    testClassesDirs = integrationTest.output.classesDirs
    classpath = integrationTest.runtimeClasspath
    mustRunAfter(tasks.named('test'))
}
tasks.named('check') {
    dependsOn(integrationTestTask)
}
// end::test-task[]

        variant.artifactsProvider(() ->  {
            FileCollection classesDirs = sourceSet.getOutput().getClassesDirs();
            return classesDirs.getFiles().stream()
                .map(file -> new LazyJavaDirectoryArtifact(project.getTaskDependencyFactory(), ArtifactTypeDefinition.JVM_CLASS_DIRECTORY, classesDirs, providerFactory.provider(() -> file)))
                .collect(Collectors.toList());
        });