sortedEntries.sort(Comparator.comparing(ChildMap.Entry::getPath, PathUtil.getPathComparator(caseSensitivity)));
        return childMapFromSorted(sortedEntries);
    }

    public static <T> ChildMap<T> childMapFromSorted(List<ChildMap.Entry<T>> sortedEntries) {
        int size = sortedEntries.size();
        switch (size) {
            case 0:
                return EmptyChildMap.getInstance();

        newEntries.add(insertPosition, new ChildMap.Entry<>(path, newChild))
        return ChildMapFactory.childMapFromSorted(newEntries)
    }

    ChildMap<CHILD> childrenWithSelectedChildRemoved() {
        def newEntries = childEntries()
        newEntries.remove(indexOfSelectedChild)
        return ChildMapFactory.childMapFromSorted(newEntries)
    }

    CHILD getNodeWithIndexOfSelectedChild(ChildMap<CHILD> newChildren) {

        newChildren.set(childIndex, new Entry<>(newPath, newChild));
        return ChildMapFactory.childMapFromSorted(newChildren);
    }

    protected ChildMap<T> withRemovedChild(int childIndex) {
        List<Entry<T>> newChildren = new ArrayList<>(entries);
        newChildren.remove(childIndex);
        return ChildMapFactory.childMapFromSorted(newChildren);
    }

    @Override
    public boolean equals(Object o) {

import java.io.File;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Collectors;

import static org.gradle.internal.snapshot.ChildMapFactory.childMapFromSorted;
import static org.gradle.internal.snapshot.SnapshotVisitResult.CONTINUE;

/**
 * A snapshot of an existing directory hierarchy.
 *
 * Includes snapshots of any child element and the Merkle tree hash.
 */

        def entry1 = new ChildMap.Entry<FileSystemNode>(path1, child1)
        def entry2 = new ChildMap.Entry<FileSystemNode>(path2, child2)
        return compared < 0 ? ChildMapFactory.childMapFromSorted([entry1, entry2]) : ChildMapFactory.childMapFromSorted([entry2, entry1])
    }

    @Override
    FileSystemNode mockChild() {
        Mock(FileSystemNode)
    }

            @Override
            public ValuedVfsHierarchy<T> handleAsAncestorOfChild(String childPath, ValuedVfsHierarchy<T> child) {
                ChildMap<ValuedVfsHierarchy<T>> singletonChild = ChildMapFactory.childMapFromSorted(ImmutableList.of(
                    new ChildMap.Entry<>(location.pathToChild(childPath), child)
                ));