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

        rootBuild.includedBuilds() >> [includedBuild1]

     *
     * @param identityPath The project for which the model should be created, or null for a build scoped model.
     */
    fun <T> loadOrCreateIntermediateModel(identityPath: Path?, modelName: String, parameter: ToolingModelParameterCarrier?, creator: () -> T?): T?

    /**

        }
        reportCrossProjectTaskAccess(otherProjects)
    }

    private
    val Project.isReferrerProject: Boolean
        get() = this is ProjectInternal && identityPath == referrerProject.identityPath

    private
    fun reportCrossProjectTaskAccess(coupledProjects: Iterable<ProjectInternal>, requestPath: String? = null) {
        reportCoupledProjects(coupledProjects)

        for (entry in entryDetails) {
            val identityPath = projectPathForKey(entry.key)
            if (identityPath == null || !checkedFingerprint.invalidProjects.contains(identityPath)) {
                // Can reuse the value
                previousValues[entry.key] = entry.value
            }
        }
    }

        String taskName
    ) {
        for (ProjectDependency projectDependency : projectDependencies) {
            Path identityPath = ((ProjectDependencyInternal) projectDependency).getIdentityPath();
            ProjectState projectState = projectStateRegistry.stateFor(identityPath);
            projectState.ensureTasksDiscovered();

            Task nextTask = projectState.getMutableModel().getTasks().findByName(taskName);

        } else {
            PropertyTrace.Task(GeneratedSubclasses.unpackType(task), task.identityPath.path)
        }

    private
    fun problemsListenerFor(task: TaskInternal): ProblemsListener = when {
        task.isCompatibleWithConfigurationCache -> problems
        else -> problems.forIncompatibleTask(task.identityPath.path)
    }

def prefix = "init $gradle.identityPath"

println "$prefix QUIET out"
logging.captureStandardOutput LogLevel.INFO
println "$prefix INFO out"

System.err.println "$prefix ERROR err"
logging.captureStandardError LogLevel.INFO
System.err.println "$prefix INFO err"

logger.lifecycle("$prefix lifecycle log")

                text("Project ")
                reference(referrerProject.identityPath.toString())
                text(" cannot dynamically look up a ")
                text(memberKind.name.lowercase(Locale.ENGLISH))
                text(" in the parent project ")
                reference(ownerProject.identityPath.toString())
            }
                .mapLocation { location ->

        //       via the resolution result.
        Path identityPath = ((ProjectDependencyInternal) dependency).getIdentityPath();
        ModuleVersionIdentifier identifier = projectDependencyResolver.resolveComponent(ModuleVersionIdentifier.class, identityPath);
        return ResolvedCoordinates.create(identifier);
    }

    @Nullable
    @Override

        Mock(ResolutionStrategyFactory)
    )

    def setup() {
        metadataBuilder.withConfigurationsProvider(_) >> metadataBuilder
    }

    def "adds and gets"() {
        1 * domainObjectContext.identityPath("compile") >> Path.path(":build:compile")
        1 * domainObjectContext.projectPath("compile") >> Path.path(":compile")
        1 * domainObjectContext.model >> RootScriptDomainObjectContext.INSTANCE

        when: