else
    # TODO: migrate the kube::util::host_platform function out of hack/lib and
    # use it here.
    local machine
    machine="$(uname -m)"
    case "${machine}" in
      x86_64*|i?86_64*|amd64*)
        CLIENT_ARCH="amd64"
        ;;
      aarch64*|arm64*)
        CLIENT_ARCH="arm64"
        ;;
      arm*)
        CLIENT_ARCH="arm"
        ;;
      i?86*)

        "//tensorflow:ios_x86_64": "x86_64-apple-ios",
        "//tensorflow:linux_ppc64le": "ppc64le-ibm-linux-gnu",
        "//tensorflow:linux_aarch64": "aarch64-none-linux-gnu",
        "//tensorflow:macos_x86_64": "x86_64-none-darwin",
        "//tensorflow:macos_arm64": "aarch64-none-darwin",
        "//tensorflow:windows": "x86_64-none-windows",
        "//tensorflow:linux_s390x": "systemz-none-linux-gnu",

RUN dotnet tool install --global wix

# Install msys2, packages and add to path.
RUN [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; \
    Invoke-WebRequest "https://repo.msys2.org/distrib/x86_64/msys2-base-x86_64-20220319.sfx.exe" \
        -OutFile msys2_install.exe -UseBasicParsing; \
    .\msys2_install.exe -y -oC:\; \
    Remove-Item msys2_install.exe; \
    function msys() { C:\msys64\usr\bin\bash.exe @('-lc') + @Args; } \

    }

    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) {

        }

        @Override
        public TargetMachine getX86_64() {
            return new TargetMachineImpl(getOperatingSystemFamily(), objectFactory.named(MachineArchitecture.class, MachineArchitecture.X86_64));
        }

        @Override
        public TargetMachine architecture(String architecture) {

    exit 2
esac

machine=$(uname -m)
case "${machine}" in
  x86_64*|i?86_64*|amd64*)
    ;;
  aarch64*|arm64*)
    ;;
  ppc64le*)
    ;;
  arm*)
    ;;
  i?86*)
    ;;
  *)
    echo "Unknown, unsupported architecture (${machine})." >&2
    echo "Supported architectures x86_64, i686, arm, arm64, ppc64le." >&2
    echo "Bailing out." >&2
    exit 3
    ;;
esac

	"os/exec"
	"path/filepath"
	"strings"
)

// Information about a specific installation of gccgo.
type GccgoInstallation struct {
	// Version of gcc (e.g. 4.8.0).
	GccVersion string

	// Target triple (e.g. x86_64-unknown-linux-gnu).
	TargetTriple string

	// Built-in library paths used by this installation.
	LibPaths []string
}

// Ask the driver at the given path for information for this GccgoInstallation.

 * limitations under the License.
 */

package common

enum class Arch(val suffix: String, val nameOnLinuxWindows: String, val nameOnMac: String) {
    AMD64("64bit", "amd64", "x86_64"),
    AARCH64("aarch64", "aarch64", "aarch64");

    fun asName() = name.lowercase().toCapitalized()
}

enum class Os(
    val agentRequirement: String,
    val androidHome: String,

        switch (architecture) {
            case i386:
                return Architecture.X86;
            case amd64:
                return Architecture.X86_64;
            case aarch64:
                return Architecture.AARCH64;
        }
        throw new GradleException("Unhandled system architecture: " + architecture);
    }

        return Stub(NativeVariantIdentity) {
            getName() >> "debug"
            isDebuggable() >> true
            getTargetMachine() >> targetMachine(OperatingSystemFamily.MACOS, MachineArchitecture.X86_64)
        }
    }

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