buildDir.file('classes/java/main').assertHasDescendants(
            'org/gradle/JavaClass.class',
            'org/gradle/JavaClass2.class'
        )
        buildDir.file('classes/groovy/main').assertHasDescendants(
            'org/gradle/GroovyClass.class',
            'org/gradle/GroovyClass2.class',
        )
        buildDir.file('classes/scala/main').assertHasDescendants(

type ClassController struct {
	queue   controllers.Queue
	classes kclient.Client[*gateway.GatewayClass]
}

func NewClassController(kc kube.Client) *ClassController {
	gc := &ClassController{}
	gc.queue = controllers.NewQueue("gateway class",
		controllers.WithReconciler(gc.Reconcile),
		controllers.WithMaxAttempts(25))

	gc.classes = kclient.New[*gateway.GatewayClass](kc)

        outputContains "Hello World!"
        executedAndNotSkipped ":compileJava", ":classes", ":run"

        when:
        mainSourceFile.text = sourceFileWithGreeting("Hello VFS!")
        waitForChangesToBePickedUp()
        runWithWatchingEnabled "run"
        then:
        outputContains "Hello VFS!"
        executedAndNotSkipped ":compileJava", ":classes", ":run"
    }

    def "buildSrc changes are recognized"() {

            classes.doLast { t ->
                println "classes of \$t.path"
            }
        """
        file("buildSrc/settings.gradle") << settings << "\n"

        when:
        run()

        then:
        outputContains("> Configure project :buildSrc")
        result.groupedOutput.task(":buildSrc:classes").output.contains("classes of :classes")

        where:

        """
        buildFile << """
            apply plugin: MyPlugin
            apply plugin: MyPluginSub
            // nuke buildSrc classes so we can't use them
            project.delete(file("buildSrc/build/classes"))
            project.delete(file("buildSrc/subproject/build/classes"))
        """
        when:
        succeeds("myTaskMyPlugin", "myTaskMyPluginSub")
        then:
        outputContains("From MyPlugin")

    /**
     * Creates a ClassLoader implementation which has only the classes from the specified URIs and the Java API visible.
     */
    ClassLoader createIsolatedClassLoader(String name, ClassPath classPath);

    /**
     * Creates a ClassLoader implementation which has, by default, only the classes from the Java API visible, but which can allow access to selected classes from the given parent ClassLoader.
     *

         * first value encountered in iteration order, which may be random.
         */
        if (classes | modules) {
            if (classes & modules) {
                selected = getPathType(path);
            } else if (classes) {
                selected = JavaPathType.CLASSES;
            } else {
                selected = JavaPathType.MODULES;
            }

// tag::inner-link-task-properties[]
val archivesDirPath = layout.buildDirectory.dir("archives")
// end::inner-link-task-properties[]

tasks.register<Zip>("packageClasses") {
    archiveAppendix = "classes"
    destinationDirectory = archivesDirPath

    from(tasks.compileJava)
}
// end::link-task-properties[]

// tag::nested-specs[]
tasks.register<Copy>("nestedSpecs") {

// tag::inner-link-task-properties[]
def archivesDirPath = layout.buildDirectory.dir('archives')
// end::inner-link-task-properties[]

tasks.register('packageClasses', Zip) {
    archiveAppendix = "classes"
    destinationDirectory = archivesDirPath

    from compileJava
}
// end::link-task-properties[]

// tag::nested-specs[]
tasks.register('nestedSpecs', Copy) {

 * limitations under the License.
 */

package org.gradle.performance.generator

import groovy.transform.CompileStatic

/**
 * Generates a tree of dependencies between classes and sub-projects. It can be configured with
 * the number of projects and classes in each project by multiple calls to calculateClassDependencies().
 *
 * Reflects project dependencies in class dependencies and respects 'api' dependencies.