/**
     * OS Family
     */
    public static final String OS_FAMILY;

    /**
     * Boolean indicating if the running OS is a Windows system.
     */
    public static final boolean IS_WINDOWS;

    /**
     * OS family that can be tested for. {@value}
     */
    private static final String FAMILY_WINDOWS = "windows";

    /**
     * OS family that can be tested for. {@value}
     */

IOS_FILES = [
    'tensorflow/lite/objc/TensorFlowLiteObjC.podspec',
    'tensorflow/lite/swift/TensorFlowLiteSwift.podspec',
]


class UserInputError(Exception):
  pass


def is_windows():
  return platform.system() == 'Windows'


def is_linux():
  return platform.system() == 'Linux'


def is_macos():
  return platform.system() == 'Darwin'


def is_ppc64le():

     */
    public static void addEnvVars(Properties props) {
        if (props != null) {
            if (envVars == null) {
                Properties tmp = new Properties();
                boolean caseSensitive = !Os.IS_WINDOWS;
                for (Map.Entry<String, String> entry : System.getenv().entrySet()) {
                    String key = "env."

        return null;
    }

    private static Path findTool(String toolName, Path installDir) {
        Path bin = installDir.resolve("bin"); // NOI18N
        if (Files.isDirectory(bin)) {
            if (Os.IS_WINDOWS) {
                Path tool = bin.resolve(toolName + ".exe");
                if (Files.exists(tool)) {
                    return tool;
                }
            }
            Path tool = bin.resolve(toolName);

    checkPath.convert = makePosix

    // 'C:\\foo'     <- 'C:\\foo' has been converted to 'C:/'
    // 'd:\\foo'
    const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i
    checkPath.isNotRelative = path =>
        REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path)
        || isNotRelative(path)

                                null);
                        result.getProblems().add(problem);
                        continue;
                    }

                    if (Os.IS_WINDOWS) {
                        // we don't canonicalize on unix to avoid interfering with symlinks
                        try {
                            moduleFile = moduleFile.getCanonicalFile();

    } finally {
      jarFile.delete();
    }
  }

  @AndroidIncompatible // Path (for symlink creation)

  public void testScanDirectory_symlinkCycle() throws IOException {
    if (isWindows()) {
      return; // TODO: b/136041958 - Can we detect cycles under Windows?
    }
    ClassLoader loader = ClassPathTest.class.getClassLoader();
    // directory with a cycle,
    // /root
    //    /left

    } finally {
      notJar.delete();
    }
  }

  public void testGetClassPathEntry() throws MalformedURLException, URISyntaxException {
    if (isWindows()) {
      return; // TODO: b/136041958 - We need to account for drive letters in the path.
    }
    assertEquals(
        new File("/usr/test/dep.jar").toURI(),

        CODEQL_ENVIRONMENT_VARIABLES.any { it in System.getenv() }
    }
    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"

      file = out.getFile();
      assertEquals(dataSize, file.length());
      assertTrue(file.exists());
      assertThat(file.getName()).contains("FileBackedOutputStream");
      if (!isAndroid() && !isWindows()) {
        PosixFileAttributes attributes =
            java.nio.file.Files.getFileAttributeView(file.toPath(), PosixFileAttributeView.class)
                .readAttributes();