expect:
        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");

        switch (archString) {
            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:

        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}")
        }
    }

        def archString = lines.last().split()[1]

        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}")
        }
    }

        } catch (NativeIntegrationUnavailableException e) {
            architectureName = System.getProperty("os.arch");
        }
        return Architectures.forInput(architectureName);
    }

    public static DefaultNativePlatform host() {
        return new HostPlatform();
    }

    @Override
    public String getName() {
        return name;
    }

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

        where:
        architecture << [

// versionedParams may be nil.
type Filter interface {
	// ForInput converts compiled CEL-typed values into evaluated CEL-typed value.
	// runtimeCELCostBudget was added for testing purpose only. Callers should always use const RuntimeCELCostBudget from k8s.io/apiserver/pkg/apis/cel/config.go as input.
	// If cost budget is calculated, the filter should return the remaining budget.

	// Decide which fields are exposed
	ns := cel.CreateNamespaceObject(namespace)
	evalResults, remainingBudget, err := v.validationFilter.ForInput(ctx, versionedAttr, admissionRequest, optionalVars, ns, runtimeCELCostBudget)
	if err != nil {
		return ValidateResult{
			Decisions: []PolicyDecision{
				{
					Action:     policyDecisionActionForError(f),

        switch (archString) {
            case "Intel 80386":
                return Architectures.forInput("x86")
            case "Advanced Micro Devices X86-64":
                return Architectures.forInput("x86_64")
            default:
                throw new RuntimeException("Cannot determine architecture for ${archString}\nreadelf output:\n${lines}")
        }
    }