return architecture;
    }

    @Override
    public void architecture(String name) {
        architecture = Architectures.forInput(name);
    }

    @Override
    public OperatingSystemInternal getOperatingSystem() {
        return operatingSystem;
    }

    @Override
    public void operatingSystem(String name) {
        operatingSystem = new DefaultOperatingSystem(name);
    }

 */
class PlatformInOutputNormalizer implements OutputNormalizer {
    def static internalOs = OperatingSystem.current()
    def static os = DefaultBuildPlatform.getOperatingSystem(internalOs)
    def static arch = getArchitectureString()

    private static getArchitectureString() {
        def archProperty = System.getProperty("os.arch")
        if (archProperty == "amd64") {

        buildScript '''
            @Managed
            interface Platform {
                String getDisplayName()
                void setDisplayName(String name)

                OperatingSystem getOperatingSystem()
            }

            @Managed
            interface OperatingSystem {
                Family getFamily()

                String getVersion()
                void setVersion(String name)

        buildScript '''
            @Managed
            interface Platform {
                String getDisplayName()
                void setDisplayName(String name)

                OperatingSystem getOperatingSystem()
                void setOperatingSystem(OperatingSystem operatingSystem)
            }

            @Managed
            interface OperatingSystem {
                String getName()

        when:
        buildScript '''
            @Managed
            interface Platform {
                @Unmanaged
                OperatingSystem getOperatingSystem()
                void setOperatingSystem(OperatingSystem os)
            }

            class OperatingSystem {
                String name
            }

            class RulePlugin extends RuleSource {

                "-o", outputFile.absolutePath,
                testDir.file("one.o").absolutePath].flatten()

        when:
        NativePlatform platform = Mock(NativePlatform)
        platform.getOperatingSystem() >> new DefaultOperatingSystem("osx", OperatingSystem.MAC_OS)

        LinkerSpec spec = Mock(SharedLibraryLinkerSpec)
        spec.getSystemArgs() >> []
        spec.getArgs() >> []

            return builds.stream().map(specification -> results.buildResult(specification.getDisplayName())).collect(Collectors.toList());
        }

        @Override
        public String getOperatingSystem() {
            return results.getOperatingSystem();
        }

        @Override
        public String getHost() {
            return results.getHost();
        }

        @Override
        public String getJvm() {

import org.gradle.api.Incubating;

/**
 * Information about the machine host Gradle is running on.
 *
 * @since 7.6
 */
@Incubating
public interface BuildPlatform {

    OperatingSystem getOperatingSystem();

    Architecture getArchitecture();

            return getKnownVersions().stream().map(version -> result.version(version).getResults()).collect(Collectors.toList());
        }

        @Override
        public String getOperatingSystem() {
            return result.getOperatingSystem();
        }

        @Override
        public String getHost() {
            return result.getHost();
        }

        @Override
        public String getJvm() {

        this.macOSSdkPathLocator = macOSSdkPathLocator;
    }

    public String[] compilerProbeArgs(NativePlatformInternal target) {
        if (!target.getOperatingSystem().isMacOsX()) {
            return new String[0];
        }
        File sdkDir = macOSSdkPathLocator.find();
        return new String[]{"-isysroot", sdkDir.getAbsolutePath()};
    }