def listenerManager = new DefaultListenerManager(Scope.Build)
    def fileSystemAccess = Mock(FileSystemAccess)
    def cachesDir = tmpDir.file("caches")
    def cacheScopeMapping = new DefaultCacheScopeMapping(cachesDir, GradleVersion.current())
    def cacheRepository = new DefaultUnscopedCacheBuilderFactory(new TestInMemoryCacheFactory())

    def nodeExecutor = Mock(NodeExecutor)
    def buildOperationRunner = new TestBuildOperationRunner()
    def listenerBuildOperationDecorator = new TestListenerBuildOperationDecorator()
    def workerLimits = new DefaultWorkerLimits(1)
    def workerLeases = new DefaultWorkerLeaseService(coordinator, workerLimits)
    def executorFactory = Mock(ExecutorFactory)

class TestReportDataCollectorSpec extends Specification {
    def Map<String, TestClassResult> results = [:]
    def TestOutputStore.Writer writer = Mock()
    def collector = new TestReportDataCollector(results, writer)

    def "keeps track of test results"() {
        def root = new DefaultTestSuiteDescriptor("1", "Suite")
        def clazz = new DecoratingTestDescriptor(new DefaultTestClassDescriptor("1.1", "FooTest"), root)

    def buildCacheController = Mock(BuildCacheController)

    def beforeExecutionState = Stub(BeforeExecutionState)

    def cacheKeyHashCode = "30a042b90a"
    def cacheKey = Stub(BuildCacheKey) {
        hashCode >> cacheKeyHashCode
    }
    def loadMetadata = Mock(BuildCacheLoadResult)
    def deleter = Mock(Deleter)
    def fileSystemAccess = Mock(FileSystemAccess)

        when:
        def immutable2 = joined.asImmutable()

        then:
        immutable2.getAttribute(one) == "new fallback"
        immutable2.getAttribute(two) == "new primary"
    }

    def "keySet contains attributes from both fallback and primary"() {
        given:
        def fallback = mutable()
        def primary = mutable()

        }
    }

    def "fetches model for target object with parameter"() {
        def model = new Object()
        def targetElement = new Object()
        def modelElement = Stub(Element)
        def modelView = Stub(GradleBuild)
        def parameterType = ValidParameter
        def parameterInitializer = new Action<ValidParameter>() {
            @Override

        assert file.exists() && file.file

        expect:
        normalize(file) == file
    }

    def "normalizes relative path"() {
        def ancestor = new File(tmpDir.testDirectory, "test")
        def baseDir = new File(ancestor, "base")
        def sibling = new File(ancestor, "sub")
        def child = createFile(new File(baseDir, "a/b/file.txt"))

        expect:
        normalize("a/b/file.txt", baseDir) == child

        thrown(UnsupportedOperationException)
    }

    def "creates defensive copy of passed in argument lists"() {
        given:
        def originalArguments = ['arg1', 'arg2']
        def originalJvmArguments = ['arg3', 'arg4']
        def originalClasspath = [new File('/Users/foo/bar/test.jar').absoluteFile]

        when:
        def runner = createRunner()
            .withArguments(originalArguments)

    }

    def "is equal when all attributes and module version are the same"() {
        def moduleVersion = DefaultModuleVersionIdentifier.newId("group", "module", "version")
        def componentId = DefaultModuleComponentIdentifier.newId(moduleVersion)

        def withClassifier = localArtifactIdentifier(componentId, "name", "type", "ext", 'classifier')

    def "decode fails when boolean cannot be fully read"() {
        given:
        def bytes = truncate { Encoder encoder ->
            encoder.writeBoolean(true)
        }

        when:
        decode(bytes) { Decoder decoder ->
            decoder.readBoolean()
        }

        then:
        thrown(EOFException)
    }

    def "can encode and decode a string"() {
        expect: