import org.gradle.internal.component.model.VariantGraphResolveState;

import java.util.List;
import java.util.Set;

class RootNode extends NodeState implements RootGraphNode {
    private final ResolveOptimizations resolveOptimizations;
    private final List<? extends DependencyMetadata> syntheticDependencies;

    private final VersionHierarchy rootNode;

    public static VersionHierarchyRoot empty(long version, CaseSensitivity caseSensitivity) {
        return new VersionHierarchyRoot(VersionHierarchy.empty(version), caseSensitivity);
    }

    private VersionHierarchyRoot(VersionHierarchy rootNode, CaseSensitivity caseSensitivity) {
        this.caseSensitivity = caseSensitivity;
        this.rootNode = rootNode;
    }

    /**

        nodesRelatedTo(root, "**/file") == ([rootNode, directory, file] as Set)
        nodesRelatedTo(root, "directory/**") == ([rootNode, directory] as Set)
        nodesRelatedTo(root, "missing/**") == ([rootNode, missing] as Set)
        nodesRelatedTo(root, "file/**") == ([rootNode, file] as Set)
    }

    def "filters children for a true ancestor of an accessed location"() {

        then:
        wbResource == createWbResource()
    }

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

        when:
        createWbResource().appendNode(rootNode)

        then:
        new WbResource(rootNode.'wb-resource'[0]) == createWbResource()
    }

    def equality() {
        WbResource wbResource = createWbResource()

    final FileSystemNode rootNode;

    public static SnapshotHierarchy from(FileSystemNode rootNode, CaseSensitivity caseSensitivity) {
        return new DefaultSnapshotHierarchy(rootNode, caseSensitivity);
    }

    private DefaultSnapshotHierarchy(FileSystemNode rootNode, CaseSensitivity caseSensitivity) {
        this.caseSensitivity = caseSensitivity;
        this.rootNode = rootNode;
    }

			continue
		}
	}
}

func fetchYaml(sourceYaml []byte) (*yaml.Node, error) {
	rootNode := yaml.Node{}
	err := yaml.Unmarshal(sourceYaml, &rootNode)
	if err != nil {
		return nil, err
	}
	return &rootNode, nil
}

func streamYaml(writer io.Writer, indent *int, in *yaml.Node) error {
	encoder := yaml.NewEncoder(writer)
	encoder.SetIndent(*indent)
	err := encoder.Encode(in)
	if err != nil {
		return err
	}

        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;
        }

    }

    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:

        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
    }