child2.children = [child21]

        expect:
        root.findByPath(':') == root
        root.findByPath('') == null
        root.findByPath('blah blah') == null

        root.findByPath(':child1:child12') == child12
        root.findByPath(':child2') == child2

        child1.findByPath(':') == null
        child1.findByPath(':child1:child11') == child11
    }

        return this;
    }

    public DefaultGradleProject findByPath(String path) {
        if (path.equals(this.getPath())) {
            return this;
        }
        for (DefaultGradleProject child : children) {
            DefaultGradleProject found = child.findByPath(path);
            if (found != null) {
                return found;
            }
        }

            connection.getModel(GradleProject)
        }
        GradleTask taskT1 = model.tasks.find { it.name == 't1' }
        GradleTask taskBT2 = model.findByPath(':b').tasks.find { it.name == 't2' }
        GradleTask taskBCT1 = model.findByPath(':b:c').tasks.find { it.name == 't1' }
        def result = withBuild { BuildLauncher it ->
            it.forLaunchables(taskT1, taskBT2, taskBCT1)
        }

        then:

                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>getByPath</td>
            </tr>
            <tr>
                <td>findByPath</td>
            </tr>
            <tr>
                <td>replace</td>
            </tr>
            <tr>
                <td>register</td>
            </tr>
            <tr>

        """

        when:
        GradleProject project = withConnection { it.getModel(GradleProject.class) }

        then:
        project.tasks*.name.containsAll rootProjectImplicitTasks
        project.findByPath(":subproject").tasks*.name.containsAll implicitTasks
    }

        delegate.maybeCreate(name, type)

    override fun maybeCreate(name: String): Task =
        delegate.maybeCreate(name)

    override fun findByPath(path: String): Task? =
        delegate.findByPath(path)

    override fun <S : Task> withType(type: Class<S>): TaskCollection<S> =
        delegate.withType(type)

     * Searches all descendants (children, grand-children, etc.), including self, by given path.
     *
     * @return Gradle project with matching path or {@code null} if not found.
     */
    @Nullable
    GradleProject findByPath(String path);

    /**
     * Returns the build script for this project.
     *
     * @return The build script.
     * @since 1.8

        def taskSelectionResult = Mock(TaskSelectionResult)
        _ * projectInternal.getTasks() >> tasksContainerInternal
        _ * testTask.getFilter() >> testFilter
        _ * tasksContainerInternal.findByPath(TEST_TASK_NAME) >> testTask
        TaskCollection<Test> testTaskCollection = Mock()
        _ * testTaskCollection.iterator() >> [testTask].iterator()

        then:
        container.findByPath("unknown") == null
        container.findByPath("task") == task
        container.findByName("task") == task
    }

    void "finds task by relative path"() {
        when:
        Task task = task("task")
        expectTaskLookupInOtherProject("sub", "task", task)

        then:
        container.findByPath("sub:task") == task
    }

        DefaultIdeaModule defaultIdeaModule = new DefaultIdeaModule()
            .setName(ideaModule.getName())
            .setParent(ideaProject)
            .setGradleProject(rootGradleProject.findByPath(ideaModule.getProject().getPath()))
            .setContentRoots(Collections.singletonList(contentRoot))
            .setJdkName(ideaModule.getJdkName())