*
     * @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.

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

        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)

            classpath = classpath.plus(moduleRegistry.getExternalModule("asm").getClasspath());
            classpath = addJavaCompilerModules(classpath);
            return classpath;
        }
        if (name.equals("SCALA-COMPILER")) {
            ClassPath classpath = ClassPath.EMPTY;
            classpath = classpath.plus(moduleRegistry.getModule("gradle-scala").getImplementationClasspath());

 */

package org.gradle.internal.classpath;

import org.gradle.internal.classpath.types.InstrumentationTypeRegistry;
import org.gradle.internal.instrumentation.api.metadata.InstrumentationMetadata;
import org.gradle.internal.lazy.Lazy;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.tree.ClassNode;

import javax.annotation.Nonnull;

public class ClassData implements InstrumentationMetadata {

    }

    private ClassPath gradleExtensionsWithout(String... modulesToExclude) {
        Set<Module> coreModules = allRequiredModulesOf(modulesToExclude);
        ClassPath classpath = ClassPath.EMPTY;
        for (String moduleName : GRADLE_EXTENSION_MODULES) {
            Set<Module> extensionModules = allRequiredModulesOf(moduleName);
            classpath = plusExtensionModules(classpath, extensionModules, coreModules);
        }

        def root = classLoader(classPath("root"))
        cache.get(id1, classPath("c1"), root, null) == cache.get(id1, classPath("c1"), root, null)
        cache.get(id1, classPath("c1"), root, null) != cache.get(id1, classPath("c1", "c2"), root, null)
        cache.get(id1, classPath("c1"), root, null, TestHashCodes.hashCodeFrom(100)) == cache.get(id1, classPath("c1"), root, null, TestHashCodes.hashCodeFrom(100))

        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")