def index = SnapshotUtil.indexByAbsolutePath(relocated)

        then:
        index.keySet() == [
            targetDir.absolutePath,
            targetDir.file("child").absolutePath,
            targetDir.file("child/child.txt").absolutePath,
            targetDir.file("parent.txt").absolutePath,
        ] as Set

        index.values()*.name as Set == [
            targetDir.name,
            childDir.name,

        assertEquals("http://server.org/child", normalize("http://server.org/parent/../child"));
        assertEquals("http://server.org/child", normalize("http://server.org/grand/parent/../../child"));

        assertEquals("http://server.org//child", normalize("http://server.org/parent/..//child"));
        assertEquals("http://server.org/child", normalize("http://server.org/parent//../child"));
    }

    @Test

    public CopySpecInternal addChild() {
        DefaultCopySpec child = new SingleParentCopySpec(fileCollectionFactory, objectFactory, instantiator, patternSetFactory, buildResolverRelativeToParent(parentResolver));
        addChildSpec(child);
        return child;
    }

    @Override
    protected CopySpecInternal addChildAtPosition(int position) {

    def "produces reasonable error message when nested buildFile evaluation fails"() {
        createDirs("child")
        settingsFile << """
include 'child'
"""
        buildFile << """
    evaluationDependsOn 'child'
    task t
"""
        final childBuildFile = file("child/build.gradle")
        childBuildFile << """
    def broken = { ->
        throw new RuntimeException('failure')
    }

		allErrs = append(allErrs, appsvalidation.IsNotMoreThan100Percent(*spec.MinAvailable, fldPath.Child("minAvailable"))...)
	}

	if spec.MaxUnavailable != nil {
		allErrs = append(allErrs, appsvalidation.ValidatePositiveIntOrPercent(*spec.MaxUnavailable, fldPath.Child("maxUnavailable"))...)

        return child != null;
    }

    private void filterChildren(int position) {
        for (; position > filteredChildren.size() && filteredIndex < children.size(); filteredIndex++) {
            XmlNode child = children.get(filteredIndex);
            if (testNode(child)) {
                filteredChildren.add(child);
            }
        }
    }

    private boolean testNode(XmlNode node) {
        if (test == null) {

        expect:
        initialRoot.store(childAbsolutePath("some/child"), CASE_SENSITIVE, snapshot, changeListener) == initialRoot
        removedSnapshots.empty
        addedSnapshots.empty
    }

    def "invalidate removes the node"() {
        expect:
        initialRoot.invalidate(childAbsolutePath("some/child"), CASE_SENSITIVE, changeListener) == Optional.empty()
        removedSnapshots == [initialRoot]

        given:
        def impl = new Impl()
        def child = new Child()

        when:
        container.add('i', impl)
        container.add('c', child)

        then:
        container.findByType(Capability) == impl
        container.getByType(Impl) == impl
        container.findByType(Parent) == child
        container.getByType(Parent) == child
    }

    def "can create ExtensionAware extensions"() {

    /**
     * Merges values from the specified parent model into the given child model. Implementations are expected to keep
     * parent and child completely decoupled by injecting deep copies of objects into the child rather than the original
     * objects from the parent.
     *
     * @param child The child model into which to merge the values inherited from the parent, must not be
     *            <code>null</code>.

    public ModelRuleDescriptor append(ModelRuleDescriptor child) {
        return new NestedModelRuleDescriptor(this, child);
    }

    @Override
    public ModelRuleDescriptor append(String child) {
        return append(new SimpleModelRuleDescriptor(child));
    }

    @Override
    @FormatMethod
    public ModelRuleDescriptor append(@FormatString String child, Object... args) {
        return append(String.format(child, args));