*
     * @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 + "}";
    }

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

exception to the GPLv2, based on the GNU Project exception for its
Classpath libraries, known as the GNU Classpath Exception, but only
where Oracle has expressly included in the particular source file's
header the words "Oracle designates this particular file as subject to
the "Classpath" exception as provided by Oracle in the LICENSE file
that accompanied this code."

    }
}
"""

        // then
        def classpathA = classpath('a')
        def classpathB = classpath('b')
        assert classpathA.libs.size() == 1
        classpathA.assertHasLibs('compileOnly-1.0.jar')
        assert classpathB.libs.size() == 1
        assert classpathB.projects.collect { it.name } == ['a']
        classpathB.assertHasLibs('compile-1.0.jar')
    }

    @Test

        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 {

        // the entire set of framework implementation dependencies from the distribution in order to ensure that all implementation
        // dependencies on the classpath share a version. This can _still_ lead to duplicates on the classpath, but it is at least
        // avoidable if the user adds junit-platform-launcher to their test runtime classpath, which they should be doing, since

    }

    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);
        }