def includedBuild2 = Mock(IncludedBuildInternal)

        rootProject.childProjects >> [].toSet()
        rootProject.identityPath >> Path.path(":some:identity:path")

        includedProject1.childProjects >> [].toSet()
        includedProject1.identityPath >> Path.path(":some:identity:path")
        includedProject2.childProjects >> [].toSet()
        includedProject2.identityPath >> Path.path(":some:identity:path")

        List<Project> childProjects = CollectionUtils.sort(ProjectHierarchyUtils.getChildProjectsForInternalUse(project));
        List<ProjectReportModel> children = new ArrayList<>(childProjects.size());
        for (Project childProject : childProjects) {
            children.add(calculateReportModelFor(childProject));
        }
        return children;
    }

            </tr>
            <tr>
                <td>buildFile</td>
            </tr>
            <tr>
                <td>buildscript</td>
            </tr>
            <tr>
                <td>childProjects</td>
            </tr>
            <tr>
                <td>configurations</td>
            </tr>
            <tr>
                <td>convention</td>
            </tr>
            <tr>

        p2.parent.is(root)
        p2.componentIdentifier.projectPath == ":p2"
        p2.componentIdentifier.buildTreePath == ":p2"
        p2.childProjects.empty

        root.childProjects.toList() == [p1, p2]

        registry.stateFor(root.componentIdentifier).is(root)
        registry.stateFor(p1.componentIdentifier).is(p1)
        registry.stateFor(p2.componentIdentifier).is(p2)

        defaultProjectState.projectPath >> Path.path(":proj")
        defaultProjectState.identityPath >> Path.path(":proj")
        defaultProjectState.owner >> build
        defaultProjectState.childProjects >> [defaultProjectState].toSet()

        buildRegistry.rootBuild >> build

        def rootChildProjects = [].toSet()
        rootChildProjects.add(defaultProjectState)

        build.projects >> projects

        project: CachedProjectState,
        rootProjectName: String,
        children: Map<Path?, List<CachedProjectState>>
    ): BuildStructureOperationProject {
        val childProjects = children.getOrDefault(project.path, emptyList()).map { convertProject(converted, it, rootProjectName, children) }.toSet()
        return converted.computeIfAbsent(project.path) {

        delegate.javaexec(action)

    @AllowUsingApiForExternalUse
    override fun getChildProjects(): MutableMap<String, Project> =
        delegate.childProjects

    override fun getLogging(): LoggingManager =
        delegate.logging

    override fun getTasks(): TaskContainer =
        delegate.tasks

    override fun getName(): String =

        where:
        block                               | message
        "allprojects"                       | "subprojects via 'allprojects'"
        "subprojects"                       | "subprojects"
        "configure(childProjects.values())" | "child projects"
    }

    def "reports problem when build script uses #property property to apply plugins to another project"() {
        createDirs("a", "b")
        settingsFile << """

    }

    @Override
    public Map<String, Project> getChildProjectsUnchecked() {
        Map<String, Project> childProjects = new TreeMap<>();
        for (ProjectState project : owner.getChildProjects()) {
            childProjects.put(project.getName(), project.getMutableModel());
        }
        return childProjects;
    }

    @Override
    public Map<String, Project> getChildProjects() {

        child2State.mutableModel >> child2
        child2State.name >> "child2"
        projectState.childProjects >> ([child1State, child2State] as Set)
        [project, child1, childchild, child2].each {
            projectRegistry.addProject(it)
        }
    }