!class2.exists()
    }

    def "zinc handles removal of stale output files after loading from cache"() {
        createJavaClass("Class1")
        def source2 = createJavaClass("Class2")
        def source3 = createJavaClass("Class3", "proto")
        def class1 = scalaClassFile('Class1.class')
        def class2 = scalaClassFile('Class2.class')
        def class3 = scalaClassFile('proto/Class3.class')

        }
        def class2 = Stub(TestClassResult) {
            getClassName() >> 'class-2'
        }

        when:
        provider.visitClasses(action)

        then:
        1 * provider1.visitClasses(_) >> { Action a -> a.execute(class1) }
        1 * provider2.visitClasses(_) >> { Action a -> a.execute(class2) }
        // TODO(radimk): should not assume order
        1 * action.execute(_) >> { TestClassResult r ->

import spock.lang.Specification

class TestResultTest extends Specification {
    def canOrderResultsByClassNameAndTestName() {
        ClassTestResults class1 = Mock()
        _ * class1.name >> 'name'
        ClassTestResults class2 = Mock()
        _ * class2.name >> 'a'
        ClassTestResults class3 = Mock()
        _ * class3.name >> 'z'

        TestResult result = new TestResult('name', 0, class1)

trait CodeNarcTestFixture {
    def goodCode() {
        file("src/main/groovy/org/gradle/class1.java") << "package org.gradle; class class1 { }"
        file("src/test/groovy/org/gradle/testclass1.java") << "package org.gradle; public class testclass1 { @org.junit.Test public void test1() { } }"
        file("src/main/groovy/org/gradle/Class2.groovy") << "package org.gradle; class Class2 { }"

import spock.lang.Specification

class FilteringClassLoaderSpecSerializerTest extends Specification {
    def serializer = new FilteringClassLoaderSpecSerializer()
    def outputStream = new ByteArrayOutputStream()
    def encoder = new KryoBackedEncoder(outputStream)

    def "can serialize and deserialize a spec"() {
        def classNames = [ 'allowed.Class1', 'allowed.Class2' ]

        given:
        processor = new RunPreviousFailedFirstTestClassProcessor(['Class3'] as Set, delegate)

        when:
        processor.startProcessing(testResultProcessor)
        ['Class1', 'Class2', 'Class3'].each { processor.processTestClass(new DefaultTestClassRunInfo(it)) }
        processor.stop()

        then:
        1 * delegate.startProcessing(testResultProcessor)

        when:
        scanner.run()

        then:
        1 * detector.startDetection(processor)
        then:
        1 * files.visit(_) >> { args ->
            FileVisitor visitor = args[0]
            assert visitor
            visitor.visitFile(class1)
            visitor.visitFile(class2)
        }
        then:

        class1.add(method1)
        class1.add(method2)
        def class2 = new TestClassResult(2, 'Class2', 5678)
        def results = [class1, class2]

        when:
        def read = serialize(results)

        then:
        read.size() == 2
        def readClass1 = read[0]
        readClass1.className == 'Class1'
        readClass1.startTime == 1234

        decodedSpec.internalServicesRequired
    }

    def filteringClassloaderSpec() {
        def classNames = [ 'allowed.Class1', 'allowed.Class2' ]
        def disallowedClassNames = [ 'disallowed.Class1', 'disallowed.Class2' ]
        def packagePrefixes = [ 'allowed.pkgprefix1.', 'allowed.pkgprefix2' ]
        def disallowedPackagePrefixes = [ 'disallowed.pkgprefix1.', 'disallowed.pkgprefix2.' ]

        TestDomainObject value2 = new TestDomainObject('a')
        repository.put('class1', value1)
        repository.put('class2', value2)
        Closure cl = Mock()

        when:
        repository.each(cl)

        then:
        1 * cl.call(['class1', value1] as Object[])
        1 * cl.call(['class2', value2] as Object[])
        0 * cl._
    }

    def canIterateOverClassesUsingAction() {