}
        }
        return new DefaultArchitecture(input);
    }

    public static ArchitectureInternal of(KnownArchitecture architecture) {
        return new DefaultArchitecture(architecture.canonicalName);
    }

    public static class KnownArchitecture {
        private final String canonicalName;
        private final List<String> aliases;

 */

package org.gradle.platform;

import org.gradle.api.Incubating;

/**
 * Constants for various processor architectures Gradle runs on.
 *
 * @since 7.6
 */
@Incubating
public enum Architecture {
    /**
     * 32-bit complex instruction set computer (CISC) architectures, including "x32", "i386", "x86"..
     */
    X86,

    /**

        Architectures.forInput(architecture).isArm32()
        Architectures.forInput(architecture).isArm()
        where:
        architecture << [ "arm", "armv7" ]
    }

    def "test ARM 64 aliases"() {
        expect:
        Architectures.forInput(architecture).isArm64()
        Architectures.forInput(architecture).isArm()
        where:
        architecture << [ "aarch64", "arm-v8" ]
    }

        ArchitectureInternal x86 = Architectures.forInput(ARCH_X86);
        ArchitectureInternal x64 = Architectures.forInput("x86_64");
        ArchitectureInternal ia64 = Architectures.forInput("ia64");
        ArchitectureInternal armv7 = Architectures.forInput("armv7");
        ArchitectureInternal aarch64 = Architectures.forInput("aarch64");
        ArchitectureInternal sparc = Architectures.forInput("sparc");

    public String getDisplayName() {
        return "architecture '" + name + "'";
    }

    @Override
    public boolean isI386() {
        return Architectures.X86.isAlias(name);
    }

    @Override
    public boolean isAmd64() {
        return Architectures.X86_64.isAlias(name);
    }

    @Override
    public boolean isIa64() {
        return Architectures.IA_64.isAlias(name);
    }

    @Override

            result.error.contains('My Mac doesn’t support any of App’s architectures. You can set App’s Architectures build setting to Standard Architectures to support My Mac')
    }

    protected String configureToolChainSupport(String architecture) {
        return """
            model {
                toolChains {
                    toolChainFor${architecture.capitalize()}Architecture(Gcc) {
                        path "/not/found"

        String header = Iterables.getFirst(lines, "")
        if (header.contains("x86-64")) {
            return Architectures.forInput("x86_64")
        } else if (header.contains("80386")) {
            return Architectures.forInput("x86")
        } else {
            throw new RuntimeException("Cannot determine architecture for ${header}\nfile output:\n${lines}")
        }
    }

            case "x86":
                return Architectures.forInput("x86")
            case "x64":
                return Architectures.forInput("x86_64")
            case "IA64":
                return Architectures.forInput("ia-64")
            case "ARM":
                return Architectures.forInput("arm")
            default:
                throw new RuntimeException("Cannot determine architecture for ${archString}")
        }
    }

        switch (archString) {
            case "I386":
                return Architectures.forInput("x86")
            case "X86_64":
                return Architectures.forInput("x86_64")
            default:
                throw new RuntimeException("Cannot determine architecture for ${archString}")
        }
    }

    List<String> listObjectFiles() {

            assert args[1].architecture == Architectures.forInput(architecture)
            return toolChain
        }
        toolChain.select(NativeLanguage.CPP, _) >> { args ->
            assert args[1].architecture == Architectures.forInput(architecture)
            toolProvider
        }

        where:
        architecture << [
                MachineArchitecture.X86,