1 * artifacts.clear()
        1 * artifacts2.clear()
        1 * outgoing.artifact(artifact1)
        1 * outgoing.artifact(artifact2)
        0 * _
    }

    def "can setup a classes directory secondary variant"() {
        def sourceSet = Mock(SourceSet)
        def apiElements = Mock(ConfigurationInternal)
        def outgoing = Mock(ConfigurationPublications)

        // This is important to get transitive implementation dependencies. PMD may load referenced classes for analysis so it expects the classpath to be "closed" world.
        getJvmPluginServices().configureAsRuntimeClasspath(pmdAuxClasspath);

        // We have to explicitly add compileClasspath here because it may contain classes that aren't part of the compileClasspathConfiguration. In particular, compile

        then:
        fails("compileGroovy")
        checkCompileOutput('unable to resolve class')
        failure.assertHasCause(compilationFailureMessage)

        file('build/classes/stub/Groovy.java').exists()
        groovyClassFile('Groovy.class').exists()
        groovyGeneratedSourceFile('Groovy$$Generated.java').exists()
        groovyClassFile('Groovy$$Generated.class').exists()
    }

        if (file("build/classes/java/test/example/MyTest.class").exists()) {
            // for Gradle 4.0+
            assert file("build/classes/java/test/example/MyTest.class").delete()
        }
        if (file("build/classes/test/example/MyTest.class").exists()) {
            // for Gradle < 4.0
            assert file("build/classes/test/example/MyTest.class").delete()
        }
    }

                }
            }

            def sneakyTask = tasks.register("sneakyTask", SneakyTask) {}

            // Ensure that buildSrc compilation triggers an exec task.
            tasks.named("classes").configure {
                dependsOn(sneakyTask)
            }
        """

        when:
        configurationCacheRun(":help")

        then:
        outputContains("Hello")

            - org.gradle.jvm.version         = 11
            - org.gradle.libraryelements     = classes
            - org.gradle.usage               = java-api
        Artifacts
            - build/classes/java/main (artifactType = java-classes-directory)

--------------------------------------------------
Variant mainSourceElements (i)
--------------------------------------------------

        given:
        def classesDir = tmpDir.createDir("some-module/out/production/classes")
        def staticResourcesDir = tmpDir.createDir("some-module/out/production/resources")
        def ignoredDir = tmpDir.createDir("some-module/ignore-me-out/production/classes")

        testSourceSet.compileClasspath.contains(new File(project.buildDir, 'classes/java/main'))
        testSourceSet.annotationProcessorPath.is(project.configurations.testAnnotationProcessor)
        testSourceSet.java.destinationDirectory.set(new File(project.buildDir, 'classes/java/test'))
        testSourceSet.output.resourcesDir == new File(project.buildDir, 'resources/test')

        def libs = module.component.orderEntry.library
        assert libs.size() == 1
        assert libs.CLASSES.root*.@url*.text().collect { new File(it).name } as Set == [artifact1.name + "!"] as Set
        assert libs.CLASSES.root*.@url*.text().findAll() { it.contains("\$GRADLE_REPO\$") }.size() == 1
        assert libs.CLASSES.root*.@url*.text().collect { it.replace("\$GRADLE_REPO\$", relPath(repoDir)) } as Set == ["jar://${relPath(artifact1)}!/"] as Set

     * compilation. Defaults to {@code null}, in which case a temporary directory will be used.
     */
    @Internal
    // TOOD:LPTR Should be just a relative path
    public File getStubDir() {
        return stubDir;
    }

    /**
     * Sets the directory where Java stubs for Groovy classes will be stored during Java/Groovy joint