final TestNameTestDirectoryProvider temporaryFolder = TestNameTestDirectoryProvider.newInstance(getClass())

    def virtualFileSystem = TestFiles.virtualFileSystem()
    def fileSystemAccess = TestFiles.fileSystemAccess(virtualFileSystem)
    def snapshotter = new DefaultFileCollectionSnapshotter(fileSystemAccess, TestFiles.fileSystem())

    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)

    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)

    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:

        """
        settingsFile << "include 'sub'"
    }

    def "can run tasks upon Eclipse synchronization"() {
        setup:
        buildFile << "eclipse { synchronizationTasks 'foo' }"

        def projectsLoadedHandler = new IntermediateResultHandlerCollector<Void>()
        def buildFinishedHandler = new IntermediateResultHandlerCollector<EclipseModel>()
        def out = new ByteArrayOutputStream()

        when:

        def parent1Edge = edge(root, false)
        def parent2Edge = edge(root, false)
        def parent1 = parent1Edge.targetComponent.nodes[0]
        def parent2 = parent2Edge.targetComponent.nodes[0]
        collectOwnStrictVersions(root, ['a']) //root, on all paths
        collectOwnStrictVersions(parent1, ['b', 'c'])
        collectOwnStrictVersions(parent2, ['b', 'd'])

        def child = nextNode()

class BaseSerializerFactoryTest extends SerializerSpec {
    def factory = new BaseSerializerFactory()

    def "uses efficient serialization for Strings"() {
        expect:
        def serializer = factory.getSerializerFor(String)
        usesEfficientSerialization("hi", serializer, 3) == "hi"
    }

    def "uses efficient serialization for Files"() {
        expect:
        def serializer = factory.getSerializerFor(File)

class DefaultDaemonConnectorTest extends Specification {

    def javaHome = new File("tmp")
    def connectTimeoutSecs = 1
    def daemonCounter = 0

    class OutgoingConnectorStub implements OutgoingConnector {
        ConnectCompletion connect(Address address) throws ConnectException {
            def connection = [:] as RemoteConnection

        actual.contains("Cause 2: java.lang.RuntimeException: two")
    }

    def "notifies the listener"() {
        def e = new RuntimeException("BOOM")
        def firstFrame = e.stackTrace[0]

        def listener = Mock(FailurePrinterListener)

        def f = toFailure(e)

        when:
        def output = new StringBuilder()
        FailurePrinter.print(output, f, listener)

        then: