});
    }

    private static File findFile(String prefix, ClassPath classpath) {
        for (File f : classpath.getAsFiles()) {
            if (f.getName().startsWith(prefix)) {
                return f;
            }
        }
        throw new IllegalStateException(String.format("Cannot find any files starting with %s in %s", prefix, classpath.getAsFiles()));
    }

    /**
     * If set to {@code true}, the buildscript's {@code classpath} configuration will not be reset after the
     * classpath has been assembled. Defaults to {@code false}.
     */
    public static final String DISABLE_RESET_CONFIGURATION_SYSTEM_PROPERTY = "org.gradle.incubating.reset-buildscript-classpath.disabled";

    private static final Logger LOGGER = Logging.getLogger(DefaultScriptHandler.class);

plugins {
    groovy
}
dependencies {
    implementation(localGroovy())
}

// tag::compile-task-classpath[]
tasks.named<AbstractCompile>("compileGroovy") {
    // Groovy only needs the declared dependencies
    // (and not longer the output of compileJava)
    classpath = sourceSets.main.get().compileClasspath
}
tasks.named<AbstractCompile>("compileJava") {
    // Java also depends on the result of Groovy compilation

import static org.gradle.internal.classpath.GroovyCallInterceptorsProvider.ClassLoaderSourceGroovyCallInterceptorsProvider
import static org.gradle.internal.classpath.InstrumentedClasses.nestedClassesOf
import static org.gradle.internal.classpath.JavaCallerForBasicCallInterceptorTest.doTestNoArg
import static org.gradle.internal.classpath.JavaCallerForBasicCallInterceptorTest.doTestSingleArg

// tag::task-type[]
abstract class SomeTask extends DefaultTask {

    @InputFiles @Classpath
    abstract ConfigurableFileCollection getClasspath() // <1>

    @TaskAction
    void action() {
        def classpathFiles = classpath.files
        // ...
    }
}
// end::task-type[]

tasks.register("someTaskType", SomeTask) {
    classpath.from(sourceSets.main.compileClasspath)
}

// tag::ad-hoc-task[]

    }

    def "Classpath container defined in beforeMerged"() {
        buildFile <<
        """apply plugin: 'java'
           apply plugin: 'eclipse'
           eclipse {
               classpath {
                   file {
                      beforeMerged { classpath ->

                }
                dependencies {
                    classpath "${first[0]}"
                    classpath "${second[0]}"
                }
            }

            Thread.currentThread().getContextClassLoader().getURLs()
                .eachWithIndex { artifact, idx -> println "classpath[\$idx]==\${Paths.get(artifact.toURI()).toFile().name}" }
        """

        when:

 * limitations under the License.
 */

package org.gradle.internal.classloader;

import org.gradle.internal.classpath.ClassPath;
import org.gradle.internal.hash.HashCode;

public interface ClasspathHasher {
    /**
     * Returns a strong hash for a given classpath.
     */
    HashCode hash(ClassPath classpath);

repositories {
    mavenCentral()
}

// tag::define-classpath[]
configurations {
    pmd
}

dependencies {
    pmd group: 'pmd', name: 'pmd', version: '4.2.5'
}
// end::define-classpath[]

// tag::use-classpath[]
tasks.register('check') {
    doLast {
        ant.taskdef(name: 'pmd',
                    classname: 'net.sourceforge.pmd.ant.PMDTask',
                    classpath: configurations.pmd.asPath)

 */

package org.gradle.internal.classpath.transforms;

import org.gradle.internal.classpath.ClasspathBuilder;
import org.gradle.internal.classpath.ClasspathEntryVisitor;
import org.gradle.internal.classpath.ClasspathWalker;
import org.gradle.internal.classpath.types.InstrumentationTypeRegistry;

import java.io.File;
import java.io.IOException;