def child = nextNode()
        def edge1 = edge(parent1, false, null, child)
        def edge2 = edge(parent2, false, null, child)
        parent1.collectAncestorsStrictVersions([parent1Edge])
        parent2.collectAncestorsStrictVersions([parent2Edge])
        child.collectAncestorsStrictVersions([edge1, edge2])

        then:

    }

    @ToBeFixedForIsolatedProjects(because = "allprojects")
    def "can use camel-case for all segments of qualified task name"() {
        createDirs("child", "child/child")
        settingsFile << "include 'child', 'child:child'"

        buildFile << """
allprojects { task thing }
"""
        when:
        run "chi:chi:th"

        then:

     */
    void describeTo(Appendable appendable);

    ModelRuleDescriptor append(ModelRuleDescriptor child);

    ModelRuleDescriptor append(String child);

    @FormatMethod
    ModelRuleDescriptor append(@FormatString String child, Object... args);

                        }
                        if (child == null) {
                            throw new IllegalStateException(String.format("Unexpected child dependency id %s. Seen ids: %s", childId, allDependencies.keySet()));
                        }
                        parent.addChild(child);
                        artifacts = artifactResults.getArtifactsWithId(decoder.readSmallInt());

            children.forEach((entry, child) -> {
                if (entry.kind != VARARG) {
                    generateNormalCallChecksAndVisitSubtree(entry, child, paramIndex);
                }
            });
            if (hasParamMatchers) {
                result.endControlFlow();
            }
            children.forEach((entry, child) -> {
                if (entry.kind == VARARG) {

                    boolean matched = false;
                    for (Node child : children) {
                        if (!matched) {
                            int childCommonPrefix = child.sizeOfCommonPrefix(path, startNextSegment);
                            if (childCommonPrefix > 0) {
                                merged.add(child.plusWithCommonPrefixLength(nextSegment, childCommonPrefix));

.exampleblock>.content .qlist>ol>li:last-child> :last-child,
.sidebarblock>.content> :last-child> :last-child,
.sidebarblock>.content .olist>ol>li:last-child> :last-child,
.sidebarblock>.content .ulist>ul>li:last-child> :last-child,
.sidebarblock>.content .qlist>ol>li:last-child> :last-child {
	margin-bottom: 0;
}

.literalblock pre,
.listingblock pre:not(.highlight),
.listingblock pre[class="highlight"],

    )
    def "inherited convention method is preferred over property with closure value"() {
        given:
        createDirs("child")
        settingsFile << "include 'child'"
        buildFile """
class ContactConvention {
    def contacts(String arg) { arg }
}

convention.plugins.contacts = new ContactConvention()

subprojects {

            connection.model(CustomModel).get()
        }

        then:
        model.thing.is(model.thing)
        model.things[0].is(model.thing)
        model.thingsByName.child.is(model.thing)
        model.findThing("child").is(model.thing)
    }

    def "retains underlying object identity in model returned to client via build action"() {
        settingsFile << "include 'a', 'b'"

        when:

    def "codenarc runs successfully for a child project with isolated projects"() {
        given:
        settingsFile << "include 'child:grand'"
        writeBuildFile(file("child/grand/build.gradle"))
        file("child/grand/src/main/groovy/Dummy.groovy") << "Dummy {}"
        withIsolatedProjects()

        expect:
        succeeds(":child:grand:codenarcMain")
        report(file("child/grand"), "main").exists()
    }