false
    )

    def "result can be read multiple times"() {
        def rootNode = rootNode(1, "org", "root", "1.0")
        builder.start(rootNode)
        builder.visitNode(rootNode)
        builder.finish(rootNode)

        when:
        def result = builder.getResolutionResult([] as Set)

        then:
        with(result.rootSource.get()) {

        then:
        projectDependency == createProjectDependency()
    }

    def canWriteToXml() {
        Node rootNode = new Node(null, 'root')

        when:
        createProjectDependency().appendNode(rootNode)

        then:
        new ProjectDependency(rootNode.classpathentry[0]) == createProjectDependency()
    }

    def equality() {

        then:
        wbDependentModule == createWbDependentModule()
    }

    def canWriteToXml() {
        Node rootNode = new Node(null, 'root')

        when:
        createWbDependentModule().appendNode(rootNode)

        then:
        new WbDependentModule(rootNode.'dependent-module'[0]) == createWbDependentModule()
    }

    def equality() {

        then:
        wbProperty == createWbProperty()
    }

    def canWriteToXml() {
        Node rootNode = new Node(null, 'root')

        when:
        createWbProperty().appendNode(rootNode)

        then:
        new WbProperty(rootNode.property[0]) == createWbProperty()
    }

    def equality() {
        WbProperty wbProperty = createWbProperty()
        wbProperty.name += 'x'

        then:
        container == createContainer()
    }

    def canWriteToXml() {
        Node rootNode = new Node(null, 'root')

        when:
        createContainer().appendNode(rootNode)

        then:
        new Container(rootNode.classpathentry[0]) == createContainer()
    }

    def equality() {
        Container container = createContainer()

        def rootNode = Mock(FileSystemNode)
        def hierarchy = DefaultSnapshotHierarchy.from(rootNode, CASE_SENSITIVE)

        when:
        def hasDescendants = hierarchy.hasDescendantsUnder("/")
        then:
        hasDescendants
        1 * rootNode.hasDescendants() >> true
        0 * _
    }

    def 'rootSnapshotsUnder can stream the root'() {
        def rootNode = Mock(FileSystemNode)

        new SourceFolder(new XmlParser().parseText(XML_TEXT)) == createSourceFolder()
    }

    def canWriteToXml() {
        Node rootNode = new Node(null, 'root')

        when:
        createSourceFolder().appendNode(rootNode)

        then:
        new SourceFolder(rootNode.classpathentry[0]) == createSourceFolder()
    }

    def equality() {
        SourceFolder sourceFolder = createSourceFolder()

    def fileDependencyResults = Stub(VisitedFileDependencyResults)

    def "should resolve first level dependencies in tree"() {
        given:

        def rootNode = new TestResolvedDependency()
        def child = new TestResolvedDependency()
        rootNode.children.add(child)
        def expectedResults = [child] as Set

        def lenientConfiguration = newConfiguration()

        when:

        entryPointsConsumer.accept(new EntryPoints(
            toClassNode(libraries, rootNode(AccessorKind.library)),
            toClassNode(versions, rootNode(AccessorKind.version, "versions")).parent,
            toClassNode(bundles, rootNode(AccessorKind.bundle, "bundles")).parent,
            toClassNode(plugins, rootNode(AccessorKind.plugin, "plugins")).parent
        ));
    }

    private final Map<ModuleIdentifier, ModuleResolveState> modules;
    private final Map<NodeIdentifier, NodeState> nodes;
    private final Map<SelectorCacheKey, SelectorState> selectors;
    private final RootNode root;
    private final ComponentIdGenerator idGenerator;
    private final DependencyToComponentIdResolver idResolver;
    private final ComponentMetaDataResolver metaDataResolver;
    private final Deque<NodeState> queue;