override fun addIncludedBuild(buildDefinition: BuildDefinition, settingsFile: File?, buildPath: Path): ConfigurationCacheBuild {
            return DefaultConfigurationCacheBuild(buildStateRegistry.addIncludedBuild(buildDefinition, buildPath), fileResolver, buildStateRegistry, settingsFile)
        }

        override fun getBuildSrcOf(ownerId: BuildIdentifier): ConfigurationCacheBuild {

        return service == null
            ? NullRemoteBuildCacheServiceHandle.INSTANCE

     *
     * This is used when loaded from the Configuration Cache when the path of the build is already known.
     */
    IncludedBuildState addIncludedBuild(BuildDefinition buildDefinition, Path buildPath);

    /**
     * Creates an implicit included build. An implicit build is-a nested build that is managed by Gradle and whose outputs are used by dependency resolution.
     */

        private final String buildPath;
        private final String projectPath;
        private final String name;

        public DefaultConfigurationIdentity(String buildPath, @Nullable String projectPath, String name) {
            this.buildPath = buildPath;
            this.projectPath = projectPath;
            this.name = name;
        }

        return confFactory(projectPath, buildPath).create(confName, configurationsProvider, Factories.constant(resolutionStrategy), rootComponentMetadataBuilder, role)
    }

    private DefaultConfigurationFactory confFactory(String projectPath, String buildPath) {
        def domainObjectContext = Stub(DomainObjectContext)

                ? project.getMutableModel()
                : null;
        }

        @Nullable
        private BuildState findBuild(Path buildPath) {
            return getBuildStateRegistry().findBuild(new DefaultBuildIdentifier(buildPath));
        }

        private BuildStateRegistry getBuildStateRegistry() {
            return gradle.getServices().get(BuildStateRegistry.class);
        }
    }

        def opsPerCache = configCache ? 2 : 1
        finalizeOps.size() == expectedCacheDirs.size() * opsPerCache
        def pathToCacheDirMap = finalizeOps.collectEntries {
            [
                it.details.buildPath,
                new File(it.result.local.config.location as String)
            ]
        } as Map<String, File>

        pathToCacheDirMap == expectedCacheDirs

        when:

            val settingsFile = read() as File?
            val definition = readIncludedBuildDefinition(rootBuild)
            val buildPath = read() as Path
            rootBuild.addIncludedBuild(definition, settingsFile, buildPath)
        }
        return readNestedBuildState(build)
    }

    private
    fun GradleInternal.loadGradleProperties() {

    }

    protected String formatComponent(ResolvedComponentResult result) {
        String type
        if (result.id instanceof ProjectComponentIdentifier) {
            type = "project:${Path.path(result.id.build.buildPath).append(Path.path(result.id.projectPath))}"
        } else if (result.id instanceof ModuleComponentIdentifier) {

                transformActionClass == 'MakeGreen'
                secondaryInputValueHashBytes != null
            }
        }
        with(projectTransformIdentification.componentId) {
            buildPath == ':'
            projectPath == ':producer'
        }
        with(externalTransformIdentification.componentId) {
            group == 'com.test'
            module == 'test'
            version == '4.2'