this.targetPlatform = targetPlatform;
    }

    @Override
    public BuildType getBuildType() {
        return buildType;
    }

    @Override
    public void setBuildType(BuildType buildType) {
        this.buildType = buildType;
    }

    @Override
    public Tool getLinker() {
        return linker;
    }

    @Override

                        attributes { attribute(buildType, BuildType.debug); attribute(flavor, objects.named(Flavor, "ONE")) }
                    }
                    foo2 {
                        attributes { attribute(buildType, BuildType.debug); attribute(flavor, objects.named(Flavor, "TWO")) }
                    }
                    bar {

    private final boolean autoApplied;

    public DefaultGradleEnterprisePluginConfig(StartParameter startParameter, BuildType buildType, GradleEnterprisePluginAutoAppliedStatus autoAppliedStatus) {
        this.buildScanRequest = buildScanRequest(startParameter);
        this.taskExecutingBuild = buildType == BuildType.TASKS;
        this.autoApplied = autoAppliedStatus.isAutoApplied();
    }

    @Override

Laura Kassovic <******@****.***> 1701107622 -0800

    private File staticLibraryFile;

    public DefaultPrebuiltStaticLibraryBinary(String name, PrebuiltLibrary library, BuildType buildType, NativePlatform targetPlatform, Flavor flavor, FileCollectionFactory fileCollectionFactory) {
        super(name, library, buildType, targetPlatform, flavor, fileCollectionFactory);
    }

    @Override
    public String getDisplayName() {

    // Grab all build types and product flavors
    val buildTypes = android.buildTypes.map { type ->
        type.name
    }
    // When no product flavors defined, use empty
    val productFlavors = android.productFlavors.map { flavor -> flavor.name }
        .takeIf { it.isNotEmpty() }
        ?: listOf("")
    productFlavors.forEach { productFlavorName ->
        buildTypes.forEach { buildTypeName ->

                toolChains.addDefaultToolChains();
            }
        }

        @Finalize
        public void createDefaultBuildTypes(BuildTypeContainer buildTypes) {
            if (buildTypes.isEmpty()) {
                buildTypes.create("debug");
            }
        }

        @Finalize
        public void createDefaultFlavor(FlavorContainer flavors) {
            if (flavors.isEmpty()) {

import org.gradle.nativeplatform.BuildType;
import org.gradle.nativeplatform.BuildTypeContainer;

public class DefaultBuildTypeContainer extends AbstractNamedDomainObjectContainer<BuildType> implements BuildTypeContainer {

    public DefaultBuildTypeContainer(Instantiator instantiator, CollectionCallbackActionDecorator collectionCallbackActionDecorator) {
        super(BuildType.class, instantiator, collectionCallbackActionDecorator);

            }
            if (isGhActions) {
                tag("GH_ACTION")
            }
            whenEnvIsSet("BUILD_TYPE_ID") { buildType ->
                value(tcBuildTypeName, buildType)
                link("Build Type Scans", customValueSearchUrl(mapOf(tcBuildTypeName to buildType)))
            }
        }
    }
    if (isCodeQl) {
        buildScan {
            tag("CODEQL")
        }
    }

        main(NativeExecutableSpec)
    }
}
task installDeveloperImage {
    description = "Install all debug executables"
    binaries.withType(NativeExecutableBinary) {
        if (it.buildable && buildType == buildTypes.debug) {
            dependsOn it.tasks.install
        }
    }
}
'''
        and:
        helloWorldApp.writeSources(file("src/main"))

        expect:
        succeeds "tasks"