set.variants >> variants
        variant1.attributes >> typeAttributes("classes")
        variant1.artifacts >> variant1Artifacts
        variant2.attributes >> typeAttributes("jar")

        consumerSchema.withProducer(producerSchema) >> attributeMatcher
        attributeMatcher.matches(_ as Collection, typeAttributes("classes"), _ as AttributeMatchingExplanationBuilder) >> [variant1]

        expect:

        MixInLegacyTypesClassLoader.Spec workerExtensionSpec = classLoaderRegistry.getGradleWorkerExtensionSpec();
        FilteringClassLoader.Spec gradleApiFilter = classLoaderRegistry.getGradleApiFilterSpec();
        VisitableURLClassLoader.Spec userSpec = getUserSpec("worker-loader", additionalClasspath, classes);

    <property name="classes.dir" value="${build.dir}/classes"/>

    <target name="cleanAll">
        <delete dir="${build.dir}"/>
    </target>

    <target name="prepare">
        <tstamp>
            <format property="now" pattern="yyyy-MM-dd hh:mm:ss"/>
        </tstamp>
    </target>

    <target name="build" depends="prepare">
        <mkdir dir="${classes.dir}"/>

    protected
    fun jarClassPathWith(vararg classes: KClass<*>): ClassPath =
        jarClassPathWith("cp.jar", *classes)

    protected
    fun jarClassPathWith(path: String, vararg classes: KClass<*>): ClassPath = classPathOf(
        file(path).also { jar ->
            zipTo(jar, classEntriesFor(classes))
        }
    )

    protected
    fun classPathWith(vararg classes: KClass<*>): ClassPath = classPathOf(

    }

    public DefaultTestSpec(String taskPath, List<String> classes, Map<String, List<String>> methods, List<String> packages, List<String> patterns) {
        super(taskPath);
        this.packages = packages;
        this.classes = classes;
        this.methods = methods;
        this.patterns = patterns;
    }

    @Override

    /**
     * Makes the provided classes visible to this scope, but not to children. The classes are loaded in their own ClassLoader whose parent is the export
     * ClassLoader of the parent scope.
     *
     * <p>Can not be called after being locked.
     *
     * @return this
     */
    ClassLoaderScope local(ClassPath classPath);

    /**

) : FirCallableFilteringScope(delegate) {
    init {
        // The `isDeclared` check is based on class IDs. Local classes don't have proper class IDs, but because this scope is used to
        // represent Java classes viewed from Kotlin code, we shouldn't be able to encounter any local Java classes.
        require(!owner.isLocal) {
            "Unexpected local Java class in ${FirJavaDeclaredMembersOnlyScope::class.simpleName}."

        new ProjectLibrary(name: "lib1", classes:  [new File("class/one"), new File("class/two")]) ==
                new ProjectLibrary(name: "lib1", classes: [new File("class/two"), new File("class/one")])

        new ProjectLibrary(name: "lib1") != new ProjectLibrary(name: "OTHER")
        new ProjectLibrary(name: "lib1", classes:  [new File("class/one"), new File("class/two")]) !=

     * @return this
     */
    TestSpec includeClass(String cls);

    /**
     * Adds the target test classes to the test execution.
     *
     * @see #includeClass(String)
     * @param classes The fully-qualified name of the target classes.
     * @return this
     */
    TestSpec includeClasses(Collection<String>  classes);

    /**
     * Adds the target test method to the test execution.
     * <p>

 *
 * The following depicts the general pattern of implementation where function-specific tests extend from this class,
 * while framework/engine-specific classes extend from the function-specific classes.  The framework/engine-specific
 * classes should provide the {@link BuildScriptConfiguration} and {@link TestSourceConfiguration} required by this
 * class via a reusable trait.
 *