buildFile << '''

        configurations {
            compile
            _classpath
        }

        artifacts {
            _classpath file("someDir")
        }

        dependencies {
            compile project(path: ':', configuration: '_classpath')
        }

        def files = configurations.compile

        task check {
            doLast {

     *
     * @param classPath the classpath to append
     * @return the new classpath
     */
    ClassPath plus(ClassPath classPath);

    /**
     * Returns a new classpath without entries matching the {@code filter}.
     *
     * @param filter the predicate to match entries to remove
     * @return the new classpath
     */

            return false;
        }
        Classpath classpath = (Classpath) o;
        return Objects.equal(entries, classpath.entries);
    }

    @Override
    public int hashCode() {
        return Objects.hashCode(entries);
    }

    @Override
    public String toString() {
        return "Classpath{entries=" + entries + "}";
    }

 *     This normalization applies to not only files directly on the classpath, but also
 *     to any jar files found inside directories or nested inside other jar files.
 *     If a directory is a classpath entry, then the root directory itself is ignored.
 *     The files in the directory are sorted and the relative path to the root directory is used as normalized path.

        def aClassPath = canonicalClasspathOf(model, spec.scripts.a)
        assertContainsBuildSrc(aClassPath)
        assertIncludes(aClassPath, spec.jars.root, spec.jars.a)
        assertExcludes(aClassPath, spec.jars.b)

        def bClassPath = canonicalClasspathOf(model, spec.scripts.b)
        assertContainsBuildSrc(bClassPath)
        assertIncludes(bClassPath, spec.jars.root, spec.jars.b)

        def projectModules = parseComponentFile(project: "web")
        assert getHandleFilenames(projectModules) == ["java1", "java2", "groovy"] as Set
        def classpath1 = classpath("web")
        classpath1.libs.size() == 2
        classpath1.lib("myartifact-1.0.jar")
        classpath1.lib("myartifactdep-1.0.jar")

        generateEclipseFilesForWebProject("1.2.3")
        def projectModules2 = parseComponentFile(project: "web")

Laura Kassovic <******@****.***> 1701107622 -0800

        def cp2 = ClassPath.EMPTY

        expect:
        (cp1 + cp2).is(cp1)
    }

    def "add returns rhs when lhs is empty"() {
        def cp1 = ClassPath.EMPTY
        def cp2 = DefaultClassPath.of(new File("a.jar"))

        expect:
        (cp1 + cp2).is(cp2)
    }

    def "can add collection of files to classpath"() {
        def file1 = new File("a.jar")

            // If we are pretending that we don't have a sourcepath, the compiler will
            // look on the classpath for sources. Since we don't want to bring in any
            // sources implicitly from the classpath, we have to ignore source files
            // found on the classpath.
            if (location.equals(StandardLocation.CLASS_PATH)) {
                kinds.remove(JavaFileObject.Kind.SOURCE);
            }
        }

 * are specified by {@link WorkerProcessBuilder#sharedPackages}, but should likely be tracked in this class as well.</p>
 *
 * <p>This classpath is intended to be consumed by the {@link ForkingTestClassProcessor}.</p>
 */
public class ForkedTestClasspath {
    private final ImmutableList<File> applicationClasspath;