'org.gradle.libraryelements': of('jar', 'classes'),
                'org.gradle.usage': of('java-api', 'java-api'),
                'org.gradle.jvm.environment': of('', 'standard-jvm')
            ])}

---------------------
Unselected Variant(s)
---------------------

${variantOf('apiElements-classes', [
                'org.gradle.category': of('library', 'library'),

        "layout.buildDirectory.dir('classes/main')"                            | "build/classes/main"
        "layout.buildDirectory.dir(providers.provider { 'classes/main' })"     | "build/classes/main"
        "layout.buildDirectory.file('classes/main')"                           | "build/classes/main"
        "layout.buildDirectory.file(providers.provider { 'classes/main' })"    | "build/classes/main"
    }

            "${file("build/generated/sources/annotationProcessor/java/main/ServiceRegistry.java")}]")
        outputContains("Restoring stashed files: [" +
            "${file("build/classes/java/main/A.class")}, " +
            "${file("build/classes/java/main/ServiceRegistry.class")}, " +
            "${file("build/classes/java/main/ServiceRegistryResource.txt")}, " +

        compileJava instanceof JavaCompile

        def classes = project.tasks.classes
        classes.description == "Assembles main classes."
        TaskDependencyMatchers.dependsOn('processResources', 'compileJava').matches(classes)
    }

    def "wires generated resources task into classes task for sourceset"() {
        when:
        project.pluginManager.apply(JavaBasePlugin)

            println "configuring \$project.path"
            classes.doLast { t ->
                println "classes of \$t.path"
            }
        """

        when:
        execute(buildA, ":assemble")

        then:
        outputContains("> Configure project :${buildName}")
        result.groupedOutput.task(":${buildName}:classes").output.contains("classes of :classes")

        where:

                doLast {
                    // Simulate annotation processor output
                    file("build/classes/java/main/org/gradle/internal/instrumentation").mkdirs()
                    def instrumentedClassesFile = file("build/classes/java/main/org/gradle/internal/instrumentation/instrumented-classes.txt")
                    if (!instrumentedClassesFile.exists()) {

        succeeds language.compileTaskName
        a.delete()

        when:
        succeeds language.compileTaskName

        then:
        !file("build/classes/java/main/com/foo").exists()
    }

    def "recompiles types whose names look like inner classes even if they aren't"() {
        given:
        file("src/main/${languageName}/Test.${languageName}") << 'public class Test{}'

     * declared in the given [KaSymbolWithMembers].
     *
     * It is worth noting that, while Java classes may contain declarations of static callables freely, in Kotlin only enum classes define
     * static callables. Hence, for non-enum Kotlin classes, it is not expected that the static declared member scope will contain any

				out.kind = metricKindUint64
				out.scalar = uint64(NumCgoCall())
			},
		},
		"/cpu/classes/gc/mark/assist:cpu-seconds": {
			deps: makeStatDepSet(cpuStatsDep),
			compute: func(in *statAggregate, out *metricValue) {
				out.kind = metricKindFloat64
				out.scalar = float64bits(nsToSec(in.cpuStats.GCAssistTime))
			},
		},
		"/cpu/classes/gc/mark/dedicated:cpu-seconds": {
			deps: makeStatDepSet(cpuStatsDep),

                <property name="test.projects.repository" value="repositories/central" />

                <mkdir dir="${basedir}/target/test-classes/${test.projects.repository}/${test.projects.target.directory}/" />

                <jar destfile="${basedir}/target/test-classes/${test.projects.repository}/${test.projects.target.directory}/${test.projects.archetype}.jar" basedir="${basedir}/src/test/archetypes/${test.projects.source.directory}/" />