}

    override fun onProjectReference(referrer: ProjectState, target: ProjectState) {
        if (referrer.identityPath == target.identityPath)
            return

        if (host.cacheIntermediateModels) {
            val dependency = ProjectSpecificFingerprint.CoupledProjects(referrer.identityPath, target.identityPath)
            if (projectDependencies.add(dependency)) {
                projectScopedWriter.write(dependency)

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

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

        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:

) : ProjectEvaluator {
    override fun evaluate(project: ProjectInternal, state: ProjectStateInternal) {
        controller.runCollectingFingerprintForProject(project.identityPath) {
            delegate.evaluate(project, state)
        }
    }

 * limitations under the License.
 */

package org.gradle.internal.cc.impl.cacheentry

import org.gradle.internal.hash.HashCode
import org.gradle.util.Path


internal
data class ModelKey(
    val identityPath: Path?,
    val modelName: String,
    val parameterHash: HashCode?

        _ * rootProject.identityPath >> Path.path(":${name}")
        _ * rootProject.owner >> build

        return new IncludedBuildFixture(build, rootProject)
    }

    private ProjectState addProject(RootBuildFixture build, String name) {
        def projectState = Mock(ProjectState)
        projectState.projectPath >> Path.path(":$name")
        projectState.identityPath >> Path.path(":$name")

    override fun computeIfAbsent(project: ProjectState, factory: Function<ProjectState, LocalComponentGraphResolveState>): LocalComponentGraphResolveState {
        return cache.loadOrCreateProjectMetadata(project.identityPath) {
            factory.apply(project)
        }
    }

    private static class ConfigurationDescription implements Describable {
        private final Path identityPath;

        ConfigurationDescription(Path identityPath) {
            this.identityPath = identityPath;
        }

        @Override
        public String getDisplayName() {
            return "configuration '" + identityPath + "'";
        }
    }

        }
    }

    private
    fun reportProjectIsolationProblemOnApiUsage() {
        val problem = problemFactory.problem {
            text("Project ")
            reference(referrer.identityPath.toString())
            text(" cannot access task dependencies directly")
        }
            .exception()
            .build()
        problems.onProblem(problem)
    }