for (AnnotationExpr child : node.getAnnotations()) {
            if (child instanceof SingleMemberAnnotationExpr && child.getNameAsString().endsWith("ReplacedBy")) {
                currentElement.setReplacement(((SingleMemberAnnotationExpr) child).getMemberValue().asLiteralStringValueExpr().getValue());
            }
            currentElement.addAnnotationTypeName(child.getNameAsString());
        }
    }

        'non-matching group'     | [group: 'other']  | []
        'child name of sibling'  | [module: 'e']     | []
        'child group of sibling' | [group: 'e']      | []
        'all child modules'      | [module: '*']     | ['d']
        'all child groups'       | [group: '*']      | ['d']
        'name child module'      | [module: 'd']     | ['d']
        'name child group'       | [group: 'd']      | ['d']
    }

    /**

	Bs       []bool
	BPtrs    []*bool
	Bytes    []byte
	BytesPtr *[]byte
	S        string
	SPtr     *string
	Ss       []string
	SPtrs    []*string
	MyI      MyInt
	Child    Child
	Children []Child
	ChildPtr *Child
	ChildToEmbed
}

const (
	emptyXML = `
<Parent>
    <I></I>
    <IPtr></IPtr>
    <Is></Is>
    <IPtrs></IPtrs>
    <F></F>
    <FPtr></FPtr>

        def services = new TreeServices(workers)
        def childBuild = build(services, new DefaultBuildIdentifier(Path.path(":child")))
        def build = build(services, DefaultBuildIdentifier.ROOT)
        def childNode = new TestNode("child build node")
        def node = new TestNode("main build node")

        when:
        def result = scheduleAndRun(services) { builder ->

.appendix h1 {
    margin-bottom: 1.0em;
}

.footnote sup {
    vertical-align: baseline;
    font-size: 100%;
}

.note p:first-child, .tip p:first-child {
    margin-top: 0;
}

.note > :last-child, .tip > :last-child, .examplelocation > :last-child {
    margin-bottom: 0;
}

.note, .tip, .exampleLocation {
    border-left: 1px solid #ddddd8;
    color: rgba(0,0,0,0.6);

  }

  public void testLocationEquals() {
    ClassLoader child = getClass().getClassLoader();
    ClassLoader parent = child.getParent();
    new EqualsTester()
        .addEqualityGroup(
            new ClassPath.LocationInfo(new File("foo.jar"), child),
            new ClassPath.LocationInfo(new File("foo.jar"), child))
        .addEqualityGroup(new ClassPath.LocationInfo(new File("foo.jar"), parent))

                }
            }

            // Then visit all child components' variants
            if (component instanceof ComponentWithVariants) {
                ComponentWithVariants parent = (ComponentWithVariants) component;
                for (SoftwareComponent child : parent.getVariants()) {
                    walkComponent(child, componentCoordinates, componentsSeen, coordinatesSeen, visitor);
                }

     *   <li> Iterate through the recessive children, and:
     *     <ol type="i">
     *     <li> if mergeChildren == true and there is a corresponding dominant child (matched by element name),
     *          merge the two.</li>
     *     <li> otherwise, add the recessive child as a new child on the dominant root node.</li>
     *     </ol></li>
     *   </ol></li>
     * </ol>
     */
    @SuppressWarnings("checkstyle:MethodLength")

        }

        void hasChild(String name, Closure<?> spec) {
            def child = actual.children.find { it.name == name }
            assert child != null: "Unable to find child named $name. Known children to ${actual.name} = ${actual.children.name}"
            checkedChildren << child
            verify(child, spec)
        }

        void noMoreChildren() {

                org.w3c.dom.Node child = children.item(i);
                if (child.getNodeType() == org.w3c.dom.Node.TEXT_NODE && child.getNodeValue().trim().length() == 0) {
                    node.removeChild(child);
                    i--;
                } else {
                    removeEmptyTextNodes(child);
                }
            }
        }