index.assertHasOverallResult("failures")

        index.assertHasFailedTest('classes/org.gradle.failing.SomeIgnoredSomePassedSomeFailed', 'failed')

        index.assertHasIgnoredTest('classes/org.gradle.ignoring.SomeIgnoredSomePassed', 'ignored')
        index.assertHasIgnoredTest('classes/org.gradle.failing.SomeIgnoredSomePassedSomeFailed', 'ignored')

        def apiElements = [attributes(Usage.JAVA_API, LibraryElements.JAR, 8),
                           attributes(Usage.JAVA_API, LibraryElements.CLASSES, 8)]
        def runtimeElements = [attributes(Usage.JAVA_RUNTIME, LibraryElements.JAR, 8),
                               attributes(Usage.JAVA_RUNTIME, LibraryElements.CLASSES, 8)]

        when:
        def candidates = [

		measurements. Compare only with other /cpu/classes metrics.

	/cpu/classes/gc/total:cpu-seconds
		Estimated total CPU time spent performing GC tasks. This metric
		is an overestimate, and not directly comparable to system CPU
		time measurements. Compare only with other /cpu/classes metrics.
		Sum of all metrics in /cpu/classes/gc.

	/cpu/classes/idle:cpu-seconds
		Estimated total available CPU time not spent executing

                    public static void STATIC_IN_B() {}
                    public void foo() {}
                }
            '''
        )

        when:
        def clazzA = api.classes['com.acme.A']
        def clazzB = api.classes['com.acme.B']
        def extractedA = api.extractAndLoadApiClassFrom(clazzA)
        def extractedB = api.extractAndLoadApiClassFrom(clazzB)

        then:

            artifact file('lib1.jar')
            variants {
                classes {
                    attributes.attribute(Attribute.of('format', String), 'classes-dir')
                    artifact file('classes')
                }
                jar {
                    attributes.attribute(Attribute.of('format', String), 'classes-jar')
                    artifact file('lib.jar')
                }

        List<Path> classes = dispatched.get(JavaPathType.CLASSES);
        List<Path> modules = dispatched.get(JavaPathType.MODULES);
        List<Path> unresolved = dispatched.get(PathType.UNRESOLVED);
        assertEquals(3, dispatched.size());
        assertEquals(1, unresolved.size());
        assertEquals(8, classes.size()); // "plexus.pom" and "junit.jar" are excluded.

        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:

     * collects all classes that are inside these sources, but were not detected as a dependency of changed classes.
     * This is important so all .class files that will be re-created are removed before compilation, otherwise
     * it confuse a compiler: for example Groovy compiler could generate incorrect classes for Spock.
     * <p>

        !file("build/classes/$languageName/main/a/").exists()
        !file("build/classes/$languageName/main/c/").exists()

        when:
        b.text = "package b; class B {}"
        run language.compileTaskName

        then:
        outputs.recompiledClasses("A", "C")
    }

        def value = Mock(RegularFile)
        def file = new File("classes-1.zip")

        _ * value.getAsFile() >> file

        when:
        def publishArtifact = publishArtifactNotationParser.parseNotation(value)

        then:
        publishArtifact instanceof DecoratingPublishArtifact
        publishArtifact.file == file
        publishArtifact.name == "classes-1"
        publishArtifact.extension == "zip"