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()

    )

    def "directories and missing files are ignored"() {
        def emptyDir = file('root/emptyDir').createDir()
        def missingFile = file('some').createDir().file('does-not-exist')
        def missingRootFile = file('missing-root')

        when:
        def fileCollectionFingerprint = fingerprint(emptyDir.parentFile, missingFile.parentFile, missingRootFile)

        then:
        fileCollectionFingerprint.empty
    }

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

    def "serializes empty state"() {
        def state = new CompilationState()

        expect:
        with (serialized(state)) {
            sourceInputs.empty
            fileStates.isEmpty()
        }
    }

    def "serializes state with source files"() {
        when:
        def fileEmpty = new File("empty")
        def fileStates = [:]

        def componentIdentifier = Mock(ComponentIdentifier)
        def overrideMetaData = Mock(ComponentOverrideMetadata)

        when:
        resolver.resolve(componentIdentifier, overrideMetaData, result)

        then:
        0 * registry.getComponent(_)
        0 * _
    }

    def "adds failure to resolution result if project does not exist"() {

    def "can merge composite set into itself"() {
        def action1 = Mock(Action)
        def action2 = Mock(Action)
        def original = ImmutableActionSet.of(action1, action2)

        expect:
        def set = original.mergeFrom(original)
        set.is(original)
    }

    def "can merge composite sets with common ancestors"() {
        def action1 = Mock(Action)
        def action2 = Mock(Action)

        def file2 = new File("f2")
        def collection = containing(file1, file2, file1, file2)

        expect:
        collection.files as List == [file1, file2]
    }

    def canIterateOverFilesRetainingOrder() {
        def file1 = new File("f1")
        def file2 = new File("f2")
        def collection = containing(file1, file2, file1, file2)
        def iterator = collection.iterator()

        expect:

        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:

    }

    def "includes source, resource, and header files from target binary"() {
        when:
        def sourcefile1 = file("s1")
        def sourcefile2 = file("s2")
        def sourcefile3 = file("s3")
        def resourcefile1 = file("r1")
        def resourcefile2 = file("r2")
        def headerfile1 = file("h1")
        def headerfile2 = file("h2")
        def headerfile3 = file("h3")