}

    def "can create a child project"() {

        when:
        def root = ProjectBuilder.builder().build()
        def child = ProjectBuilder.builder().withParent(root).build()

        then:
        child.name == 'test'
        child.path == ':test'
        child.projectDir == root.file("test")
        child.buildFile == child.file("build.gradle")
    }

	pattern *pattern
	handler Handler

	// An interior node maps parts of the incoming request to child nodes.
	// special children keys:
	//     "/"	trailing slash (resulting from {$})
	//	   ""   single wildcard
	children   mapping[string, *routingNode]
	multiChild *routingNode // child with multi wildcard
	emptyChild *routingNode // optimization: child with key ""
}

// addPattern adds a pattern and its associated Handler to the tree

    }

    @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:

            for (DefaultImmutableAttributes child : nodeChildren) {
                if (child.attribute.equals(key) && child.value.equals(value)) {
                    return child;
                }
            }
            DefaultImmutableAttributes child = new DefaultImmutableAttributes((DefaultImmutableAttributes) node, key, value);
            nodeChildren.add(child);
            return child;
        }
    }

    /**
     * Creates a child {@code ListenerManager}.
     * <p>
     * All events broadcast in the child will be received by the listeners registered in the parent.
     * However, the reverse is not true:
     * events broadcast in the parent are not received by the listeners in the children.
     * The child inherits the loggers of its parent, though these can be replaced.
     *

     */
    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) {

        if (separator == 0) {
            return decoder.readString();
        } else {
            String parent = readName(decoder);
            String child = readName(decoder);
            return parent + (char) (separator & 0xFF) + child;
        }
    }

    private void writeName(String name, Encoder encoder) throws IOException {
        Integer id = namesById.inverse().get(name);
        if (id == null) {

    )
    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 {