}
    val jvm = org.gradle.internal.jvm.Jvm.current()
    val javaVersion = JavaVersion.current()
    val isWindows = OperatingSystem.current().isWindows
    val isLinux = OperatingSystem.current().isLinux
    val isMacOsX = OperatingSystem.current().isMacOsX
    val isIntel: Boolean = architecture == "x86_64" || architecture == "x86"
    val isSlowInternetConnection

    public DefaultOsMemoryInfo() {
        OperatingSystem operatingSystem = OperatingSystem.current();
        if (operatingSystem.isMacOsX()) {
            delegate = new NativeOsMemoryInfo();
        } else if (operatingSystem.isLinux()) {
            delegate = getLinuxDelegate();
        } else if (operatingSystem.isWindows()) {
            delegate = new WindowsOsMemoryInfo();
        } else {

        this.os = os;
    }

    @Override
    public String getSourceName() {
        return "Common Linux Locations";
    }

    @Override
    public Set<InstallationLocation> get() {
        if (os.isLinux()) {
            return Arrays.stream(roots)
                .map(root -> FileBasedInstallationFactory.fromDirectory(root, getSourceName(), InstallationLocation::autoDetected))
                .flatMap(Set::stream)

        return false;
    }

    public boolean isUnix() {
        return false;
    }

    public boolean isMacOsX() {
        return false;
    }

    public boolean isLinux() {
        return false;
    }

    public abstract String getNativePrefix();

    public abstract String getScriptName(String scriptPath);

    }

    void assertRegistryNotWorldReadable() {
        def registryFile = new DaemonDir(context.daemonRegistryDir).registry
        if (OperatingSystem.current().isLinux() || OperatingSystem.current().isMacOsX()) {
            def stat = NativeServicesTestFixture.instance.get(Stat)
            assert stat.getUnixMode(registryFile) == 0600 // user read-write

                    BuildEnvironment.isMacOsX && BuildEnvironment.isIntel -> "mac.zip"
                    BuildEnvironment.isMacOsX && !BuildEnvironment.isIntel -> "mac_arm.zip"
                    BuildEnvironment.isLinux -> "linux.tar.gz"
                    else -> throw IllegalStateException("Unsupported OS: ${OperatingSystem.current()}")
                }
                val androidStudioDependencyProvider =

            definition += "windows";
        } else if (host.getOperatingSystem().isMacOsX()) {
            definition += "macOS";
        } else if (host.getOperatingSystem().isLinux()) {
            definition += "linux";
        } else {
            definition += "os(\"" + host.getOperatingSystem().toFamilyName() + "\")";
        }

        definition += ".";

    private void dumpThreadsUponTimeout(String stacktrace) {
        if (stacktrace.contains("due to a timeout waiting for other requests") && OperatingSystem.current().isLinux()) {
            new JavaProcessStackTracesMonitor(new File(".")).printAllStackTracesByJstack();
        }
    }

        // 1.0-milestone-5 was broken where jna was not available
        //noinspection SimplifiableIfStatement
        if (isVersion("1.0-milestone-5")) {
            return os.isWindows() || os.isMacOsX() || os.isLinux();
        } else {
            return true;
        }
    }

    /**
     * Returns true if the given java version is less than the given highest version bound.  Always returns

                maxLocalExecutors = project.maxTestDistributionLocalExecutors

                if (BuildEnvironment.isCiServer) {
                    when {
                        OperatingSystem.current().isLinux -> requirements = listOf("os=linux", "gbt-dogfooding")
                        OperatingSystem.current().isWindows -> requirements = listOf("os=windows", "gbt-dogfooding")