return internalOs == CURRENT_OS;
    }

    @Override
    public boolean isWindows() {
        return internalOs.isWindows();
    }

    @Override
    public boolean isLinux() {
        return internalOs.isLinux();
    }

    @Override
    public boolean isMacOsX() {
        return internalOs.isMacOsX();
    }

    @Override
    public boolean isSolaris() {

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

    /**
     * The Linux operating system family.
     *
     */
    public static final String LINUX = "linux";

    /**
     * Is this the Linux operating system family?
     *
     */
    public boolean isLinux() {
        return is(LINUX);
    }

    /**
     * The macOS operating system family.
     *
     */
    public static final String MACOS = "macos";

    /**

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

     */
    @Internal
    boolean isWindows();

    /**
     * Is it macOS?
     */
    @Internal
    boolean isMacOsX();

    /**
     * Is it Linux?
     */
    @Internal
    boolean isLinux();

    /**
     * Is it Solaris?
     */
    @Internal
    boolean isSolaris();

    /**
     * Is it FreeBSD?
     */
    @Internal
    boolean isFreeBSD();

    }

    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

            }
        }
        """

        // Starting on Swift 4.1 and above, executable on Linux are linked using `-pie` flag, this means C++ codes need to be compiled using `-fPIC`
        if (OperatingSystem.current().isLinux() && swiftToolChain.version.compareTo(VersionNumber.parse("4.1")) >= 0) {
            initScript << """
                allprojects { p ->
                    p.plugins.withId("cpp-library") {

                    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 =