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:

            gradle.buildFinished { result ->
                println '# gradle.buildFinished failure=' + Util.unpack(result.failure) + ' [' + gradle.identityPath + ']'
            }
            gradle.taskGraph.whenReady {
                println '# gradle.taskGraphReady [' + gradle.identityPath + ']'
            }
            gradle.addBuildListener(new LoggingBuildListener())
            class LoggingBuildListener extends BuildAdapter {

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

        root.identityPath == Path.ROOT
        root.projectPath == Path.ROOT
        root.componentIdentifier.projectPath == ":"
        root.componentIdentifier.buildTreePath == ":"
        root.parent == null

        def p1 = registry.stateFor(projectId("p1"))
        p1.name == "p1"
        p1.displayName.displayName == "project ':p1'"
        p1.identityPath == Path.path(":p1")

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

            BuildIdentifier buildIdentifier = buildIdentifierSerializer.read(decoder);
            Path identityPath = Path.path(decoder.readString());
            String projectName = decoder.readString();
            return new DefaultProjectComponentSelector(buildIdentifier, identityPath, Path.ROOT, projectName, readAttributes(decoder), readCapabilities(decoder));

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