*         <th>32-bit names</th>
 *         <th>64-bit names</th>
 *     </tr>
 *     <tr>
 *         <td>Intel x86</td>
 *         <td>"x86", "i386", "ia-32", "i686"</td>
 *         <td>"x86_64", "amd64", "x64", "x86-64"</td>
 *     </tr>
 *     <tr>
 *         <td>Intel Itanium</td>
 *         <td>N/A</td>
 *         <td>"ia-64", "ia64"</td>
 *     </tr>
 *     <tr>
 *         <td>Power PC</td>

    }

    @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
    public boolean isArm32() {

        url="https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOC_VERSION}/protoc-${PROTOC_VERSION}-osx-x86_64.zip"
      elif [[ ${os} == "linux" && ${arch} == "amd64" ]]; then
        url="https://github.com/protocolbuffers/protobuf/releases/download/v${PROTOC_VERSION}/protoc-${PROTOC_VERSION}-linux-x86_64.zip"
      elif [[ ${os} == "linux" && ${arch} == "arm64" ]]; then

			// on ARM64 laptops when there is an x86 parent in the
			// process tree. Look for the RELEASE_ARM64 to avoid being
			// confused into building an x86 toolchain.
			gohostarch = "arm64"
		case strings.Contains(out, "x86_64"), strings.Contains(out, "amd64"):
			gohostarch = "amd64"
		case strings.Contains(out, "86"):

    def platform = Stub(NativePlatformInternal)

    def dummyOs = new DefaultOperatingSystem("currentOS", OperatingSystem.current())
    def dummyArch = Architectures.forInput("x86_64")

    def "is unavailable when platform is not known and is not the default platform"() {
        given:
        platform.displayName >> '<unknown>'

        expect:

	// 7f7d77b36000-7f7d77d36000 ---p 001ba000 fc:01 1180226                    /lib/x86_64-linux-gnu/libc-2.19.so
	// 7f7d77d36000-7f7d77d3a000 r--p 001ba000 fc:01 1180226                    /lib/x86_64-linux-gnu/libc-2.19.so
	// 7f7d77d3a000-7f7d77d3c000 rw-p 001be000 fc:01 1180226                    /lib/x86_64-linux-gnu/libc-2.19.so

    }

    static ArchitectureInternal readArch(Collection<String> lines) {
        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}")

		},
		{
			name: "kernelVersion is 3.18.0, return safeSysctls with no kernelVersion limit and net.ipv4.ip_local_reserved_ports",
			getVersion: func() (*version.Version, error) {
				kernelVersionStr := "3.18.0-957.27.2.el7.x86_64"
				return version.ParseGeneric(kernelVersionStr)
			},
			want: []string{
				"kernel.shm_rmid_forced",
				"net.ipv4.ip_local_port_range",
				"net.ipv4.tcp_syncookies",
				"net.ipv4.ping_group_range",

    }

    private NativeVariantIdentity getIdentity() {
        return Stub(NativeVariantIdentity) {
            getTargetMachine() >> targetMachine(OperatingSystemFamily.WINDOWS, MachineArchitecture.X86_64)
        }
    }

    private TargetMachine targetMachine(String os, String arch) {
        def objectFactory = TestUtil.objectFactory()
        return Stub(TargetMachine) {

    private NativeVariantIdentity getIdentity() {
        return Stub(NativeVariantIdentity) {
            getName() >> "debug"
            getTargetMachine() >> targetMachine(OperatingSystemFamily.WINDOWS, MachineArchitecture.X86_64)
        }
    }

    private TargetMachine targetMachine(String os, String arch) {
        def objectFactory = TestUtil.objectFactory()
        return Stub(TargetMachine) {