map.put("pluginClass", getPluginClass().getName());
            map.put("targetType", getTargetType());
            map.put("targetPath", getTargetPath());
            map.put("buildPath", getBuildPath());
            map.put("applicationId", getApplicationId());
            return map;
        }
    }

            this.identity = identity;
            this.replacement = replacement;
            this.eager = eager;
        }

        @Override
        public String getBuildPath() {
            return identity.buildPath.toString();
        }

        @Override
        public String getTaskPath() {
            return identity.projectPath.toString();
        }

        @Override
        public long getTaskId() {

        _ * dependencies.getDependencies(_) >> [dependsOn].toSet()
        _ * task.taskDependencies >> dependencies
        _ * task.project >> project
        _ * task.identityPath >> Path.path(services.identifier.buildPath).child("task")
        _ * task.taskIdentity >> TestTaskIdentities.create("task", DefaultTask, project)
        _ * task.destroyables >> Stub(TaskDestroyablesInternal)
        _ * task.localState >> Stub(TaskLocalStateInternal)

        and:
        with(buildOperationRunner.operations[0]) {
            name == 'Notify task graph whenReady listeners'
            displayName == 'Notify task graph whenReady listeners'
            details.buildPath == ':'
        }

        when:
        def finalizedPlan2 = Stub(FinalizedExecutionPlan)
        taskGraph.populate(finalizedPlan2)
        taskGraph.execute(finalizedPlan2)

        then:

        when:
        run()

        then:
        def projectsLoaded = operations.only(NotifyProjectsLoadedBuildOperationType, { it.details.buildPath == ':' })
        verifyExpectedNumberOfExecuteListenerChildren(projectsLoaded, expectedGradleOps.size() * 3)
        verifyHasChildren(projectsLoaded, initScriptAppId, 'init', expectedGradleOps)

            with(plannedTransformStepIdentity) {
                nodeType == "TRANSFORM_STEP"
                consumerBuildPath == ":"
                consumerProjectPath == ":app"
                componentId == [buildPath: ":", projectPath: ":lib"]
                sourceAttributes == [artifactType: "jar", usage: "api"]
                targetAttributes == [artifactType: "size", usage: "api"]

  "components": {
    "schemas": {
      "io.k8s.apimachinery.pkg.version.Info": {
        "description": "Info contains versioning information. how we'll want to distribute that information.",
        "properties": {
          "buildDate": {
            "default": "",
            "type": "string"
          },
          "compiler": {
            "default": "",
            "type": "string"
          },
          "gitCommit": {

	Major        string `json:"major"`
	Minor        string `json:"minor"`
	GitVersion   string `json:"gitVersion"`
	GitCommit    string `json:"gitCommit"`
	GitTreeState string `json:"gitTreeState"`
	BuildDate    string `json:"buildDate"`
	GoVersion    string `json:"goVersion"`
	Compiler     string `json:"compiler"`
	Platform     string `json:"platform"`
}

// String returns info as a human-friendly version string.

            }
        """

        then:
        succeeds "t"
        def buildPaths = scopeIds.lastBuildPaths()
        buildPaths.size() == 2
        def ids = scopeIds.idsOfBuildTree(0)
        ids[":"].user != ids[buildPaths[1]].user
    }

    def "gradle-build with same root and user dir inherits all"() {
        when:

	kubeletconfig "k8s.io/kubernetes/pkg/kubelet/apis/config"
	"k8s.io/kubernetes/pkg/kubelet/server"
)

// BuildAuth creates an authenticator, an authorizer, and a matching authorizer attributes getter compatible with the kubelet's needs
// It returns AuthInterface, a run method to start internal controllers (like cert reloading) and error.