</content>
    <orderEntry type="sourceFolder" forTests="false"/>
    <orderEntry type="module-library" scope="RUNTIME">
      <library>
        <CLASSES>
          <root url="jar://@CACHE_DIR@/commons-collections/commons-collections/3.2.2/@SHA1@/commons-collections-3.2.2.jar!/"/>
        </CLASSES>
        <JAVADOC>
          <root url="jar://@CACHE_DIR@/commons-collections/commons-collections/3.2.2/@SHA1@/commons-collections-3.2.2-javadoc.jar!/"/>

     * @param dstDir where the compiler will output the class files
     * @param classes the classes to compile
     * @param classPath the classpath to use for compilation
     */
    public static void compile(File srcDir, File dstDir, List<ClassSource> classes, ClassPath classPath) throws GeneratedClassCompilationException {
        JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

			},
		},
	}

	testCases := []struct {
		name            string
		classes         []*networkingv1.IngressClass
		classField      *string
		classAnnotation *string
		expectedClass   *string
		expectedError   error
	}{
		{
			name:            "no default, no modification of Ingress",
			classes:         []*networkingv1.IngressClass{classWithFalseDefault, classWithNoDefault, classWithEmptyDefault},

        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")]) !=