expect:
        project.absoluteProjectPath(':') == ':'
        project.absoluteProjectPath(':other') == ':other'
        child1.absoluteProjectPath(':') == ':'
        child1.absoluteProjectPath(':other') == ':other'
    }

    def convertsRelativePathToAbsolutePath() {
        expect:
        project.absoluteProjectPath('task') == ':task'
        project.absoluteProjectPath('sub:other') == ':sub:other'

        return project;
    }

    @Override
    public ProjectInternal findProject(ProjectInternal referrer, ProjectInternal relativeTo, String path) {
        return projectRegistry.getProject(relativeTo.absoluteProjectPath(path));
    }

    @Override
    public Map<String, Project> getChildProjects(ProjectInternal referrer, ProjectInternal relativeTo) {
        return relativeTo.getChildProjectsUnchecked().entrySet().stream().collect(

            </tr>
            <tr>
                <td>findProject</td>
            </tr>
            <tr>
                <td>project</td>
            </tr>
            <tr>
                <td>absoluteProjectPath</td>
            </tr>
            <tr>
                <td>relativeProjectPath</td>
            </tr>
            <tr>
                <td>getAllTasks</td>
            </tr>
            <tr>

            calculateChildrenProjectsFor(project),
            getSoftwareTypesForProject(project),
            project == project.getRootProject(),
            project.absoluteProjectPath(ProjectInternal.TASKS_TASK),
            project.getRootProject().absoluteProjectPath(ProjectInternal.PROJECTS_TASK),
            calculateIncludedBuildIdentityPaths()
        );
    }

        delegate.extensions

    override fun getProperties(): MutableMap<String, *> =
        delegate.properties

    override fun absoluteProjectPath(path: String): String =
        delegate.absoluteProjectPath(path)

    override fun getProjectDir(): File =
        delegate.projectDir

    override fun files(vararg paths: Any?): ConfigurableFileCollection =

        override fun exec(action: Action<in ExecSpec>): ExecResult {
            onAccess("exec")
            return delegate.exec(action)
        }

        override fun absoluteProjectPath(path: String): String {
            return delegate.absoluteProjectPath(path)
        }

        override fun relativeProjectPath(path: String): String {
            return delegate.relativeProjectPath(path)
        }

        String projectPathOrRoot = Strings.isNullOrEmpty(projectPath) ? Project.PATH_SEPARATOR : projectPath;
        ProjectInternal project = projectRegistry.getProject(this.project.absoluteProjectPath(projectPathOrRoot));
        if (project == null) {
            return null;
        }
        project.getOwner().ensureTasksDiscovered();

    }

    @Override
    public int compareTo(Project otherProject) {
        return ProjectOrderingUtil.compare(this, otherProject);
    }

    @Override
    public String absoluteProjectPath(String path) {
        return getProjectPath().absolutePath(path);
    }

    @Override
    public Path identityPath(String name) {
        return getIdentityPath().child(name);
    }

     * <p>Converts a name to an absolute project path, resolving names relative to this project.</p>
     *
     * @param path The path to convert.
     * @return The absolute path.
     */
    String absoluteProjectPath(String path);

    /**
     * <p>Converts a name to a project path relative to this project.</p>
     *
     * @param path The path to convert.
     * @return The relative path.
     */