Antonio Sanchez <******@****.***> 1694228811 -0700

Austin Clements <******@****.***> 1683224724 -0400

A. Unique TensorFlower <******@****.***> 1605121757 -0800

    def virtualFileSystem = TestFiles.virtualFileSystem()
    def fileSystemAccess = TestFiles.fileSystemAccess(virtualFileSystem)

    def "pre-existing directories are filtered"() {
        def outputDir = temporaryFolder.file("outputDir").createDir()
        def beforeExecution = snapshotOutput(outputDir)
        outputDir.file()

        when:

        def spec1 = Mock(ClassLoaderSpec)
        def spec2 = Mock(ClassLoaderSpec)
        def spec3 = Mock(ClassLoaderSpec)
        def spec4 = Mock(ClassLoaderSpec)
        def settings1 = daemonForkOptionsBuilder()
                .withClassLoaderStructure(new HierarchicalClassLoaderStructure(spec1).withChild(spec2).withChild(spec3))
                .build()
        def settings2 = daemonForkOptionsBuilder()

    def cleanup() {
        factory.stop()
    }

    def createsANonBlockingActorForATargetObject() {
        when:
        def actor = factory.createActor(target)

        then:
        actor != null
    }

    def cachesTheNonBlockingActorForATargetObject() {
        when:
        def actor1 = factory.createActor(target)
        def actor2 = factory.createActor(target)

    def "can set value using absolute file"() {
        given:
        def file = tmpDir.file("thing")
        def prop = propertyWithNoValue()
        prop.set(file)

        expect:
        prop.get().asFile == file
    }

    def "can set value using relative file"() {
        given:
        def file = new File("thing")
        def prop = propertyWithNoValue()
        prop.set(file)

        expect:

    }

    def "can send a dynamic proxy"() {
        def cl = isolated(PayloadInterface)
        def payloadClass = cl.loadClass(PayloadInterface.name)
        def original = Proxy.newProxyInstance(cl, [payloadClass] as Class[], new GroovyInvocationHandler())

        when:
        def received = receiver.deserialize(originator.serialize(original))
        def reply = originator.deserialize(receiver.serialize(received))

    }

    def "map a failure"() {
        def failure = Try.<Integer>failure(new RuntimeException("failed"))
        expect:
        failure.map { it + 1 } == failure
    }

    def "fail during tryMap"() {
        def failure = new RuntimeException("failure")
        expect:
        Try.successful(10).tryMap { throw failure } == Try.failure(failure)
    }

    def "fail during map"() {

    def converter = new LayoutToPropertiesConverter(new BuildLayoutFactory())
    def gradleDistribution = temp.createDir("gradleDistribution")
    def gradleHome = temp.createDir("gradleHome")
    def rootDir = temp.createDir("projectDir")

    def "only extracts properties for known build options"() {
        when:
        def properties = properties()
        def layout = layout(properties)