import java.io.Serializable;

public class FixedBuildIdentifierProvider implements Serializable {
    private final DefaultBuildIdentifier buildIdentifier;
    private final DefaultProjectIdentifier projectIdentifier;

    public FixedBuildIdentifierProvider(DefaultProjectIdentifier projectIdentifier) {
        this.buildIdentifier = projectIdentifier.getBuildIdentifier();
        this.projectIdentifier = projectIdentifier;
    }

import org.gradle.api.artifacts.component.BuildIdentifier
import org.gradle.api.artifacts.component.ProjectComponentIdentifier
import org.gradle.api.file.ConfigurableFileCollection
import org.gradle.api.file.FileCollection
import org.gradle.api.file.RegularFileProperty


abstract class InstrumentationMetadataExtension(
    private val buildIdentifier: BuildIdentifier,
    private val configurations: ConfigurationContainer,
) {

        def included = model.includedBuilds[0]
        included.buildIdentifier.rootDir == file("child")
        included.includedBuilds.size() == 1
        included.editableBuilds.empty

        model.editableBuilds.size() == 5

        def buildSrc = model.editableBuilds[0]
        buildSrc.buildIdentifier.rootDir == file("buildSrc")
        buildSrc.includedBuilds.empty
        buildSrc.editableBuilds.empty

    private final BuildIdentifier buildIdentifier;
    private final Path identityPath;
    private final BuildDefinition buildDefinition;
    private final boolean isImplicit;
    private final IncludedBuildImpl model;

    public DefaultIncludedBuild(
        BuildIdentifier buildIdentifier,
        BuildDefinition buildDefinition,
        boolean isImplicit,

    def gradle = Mock(GradleInternal)
    def action = Mock(Function)
    def services = new DefaultServiceRegistry()
    def buildDefinition = Mock(BuildDefinition)
    def buildIdentifier = Mock(BuildIdentifier)
    def exceptionAnalyzer = Mock(ExceptionAnalyser)
    def buildTreeController = Mock(BuildTreeLifecycleController)
    def buildTreeControllerFactory = Mock(BuildTreeLifecycleControllerFactory)

    private final DefaultBuildIdentifier buildIdentifier;

    public GradleProjectIdentifierMixin(DefaultBuildIdentifier buildIdentifier) {
        this.buildIdentifier = buildIdentifier;
    }

    public DefaultProjectIdentifier getProjectIdentifier(GradleProject gradleProject) {
        return new DefaultProjectIdentifier(buildIdentifier, gradleProject.getPath());
    }

package org.gradle.api.internal.artifacts;

import com.google.common.base.Objects;
import org.gradle.api.artifacts.component.BuildIdentifier;
import org.gradle.internal.deprecation.DeprecationLogger;
import org.gradle.util.Path;

public class DefaultBuildIdentifier implements BuildIdentifier {
    public static final BuildIdentifier ROOT = new DefaultBuildIdentifier(Path.ROOT);
    private final Path buildPath;

    BuildState build(BuildIdentifier id, BuildWorkGraphController workGraph = null) {
        def build = Mock(IncludedBuildState)
        _ * build.buildIdentifier >> id
        _ * build.workGraph >> (workGraph ?: Stub(BuildWorkGraphController))
        _ * buildStateRegistry.getBuild(id) >> build
        return build
    }

    static TaskIdentifier taskIdentifier(BuildIdentifier id, String taskPath) {

    private final File javaHome;
    private final List<String> jvmArguments;
    private DefaultBuildIdentifier buildIdentifier;

    public DefaultBuildEnvironment(DefaultBuildIdentifier buildIdentifier, File gradleUserHome, String gradleVersion, File javaHome, List<String> jvmArguments) {
        this.buildIdentifier = buildIdentifier;
        this.gradleUserHome = gradleUserHome;
        this.gradleVersion = gradleVersion;

import java.io.IOException;

/**
 * A thread-safe and reusable serializer for {@link BuildIdentifier}.
 */
public class BuildIdentifierSerializer extends AbstractSerializer<BuildIdentifier> {
    private static final byte ROOT = 0;
    private static final byte LOCAL = 1;
    private static final byte FOREIGN = 2;

    @Override
    public BuildIdentifier read(Decoder decoder) throws IOException {
        byte type = decoder.readByte();