}

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

        when:
        createFacet().appendNode(rootNode)

        then:
        new Facet(rootNode.installed[0]) == createFacet()
    }

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

        when:
        createFixedFacet().appendNode(rootNode)

        then:

        private final Node rootNode;

        PrefixFileSet(File rootDir) {
            this(toAbsolutePath(rootDir));
        }

        PrefixFileSet(String rootPath) {
            String path = removeTrailingSeparator(rootPath);
            this.rootNode = new Node(path);
        }

        PrefixFileSet(Node rootNode) {
            this.rootNode = rootNode;
        }

        then:
        output == createOutput()
    }

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

        when:
        createOutput().appendNode(rootNode)

        then:
        new Output(rootNode.classpathentry[0]) == createOutput()
    }

    def equality() {
        Output output = createOutput()
        output.path += 'x'

        DependencyGraphComponent component = Mock()
        ComponentIdentifier identifier = Mock()

        when:
        visitor.visitNode(rootNode)

        then:
        2 * rootNode.owner >> component
        1 * rootNode.root >> true
        1 * component.componentId >> identifier
        1 * component.metadataOrNull >> null

        and:
        visitor.allResolvedModules.empty
    }

        then:
        library == createLibrary()
    }

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

        when:
        createLibrary().appendNode(rootNode)

        then:
        new Library(rootNode.classpathentry[0], fileReferenceFactory) == createLibrary()
    }

    def equality() {
        Library library = createLibrary()

        then:
        variable == createVariable()
    }

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

        when:
        createVariable().appendNode(rootNode)

        then:
        new Variable(rootNode.classpathentry[0], fileReferenceFactory) == createVariable()
    }

    def equality() {
        Variable variable = createVariable()

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

class ModelReportNodeBuilder extends BuilderSupport {
    private ReportNode rootNode

    @Override
    protected void setParent(Object parent, Object child) {
        parent.append(child)
    }

    @Override
    protected Object createNode(Object name) {
        def node = new ReportNode(name)
        if (name == 'root') {
            this.rootNode = node
        }
        return node
    }

    @Override

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