if (isAndroid()) {
      /*
       * The test calls directly into the "ACL-based filesystem" code, which isn't available under
       * old versions of Android. Since Android doesn't use that code path, anyway, there's no need
       * to test it.
       */
      return;
    }

    /*
     * Only under Windows (or hypothetically when running with some other non-POSIX, ACL-based

    Path path = tempDir.resolve("parent/nonexistent.file");
    Path parent = path.getParent();
    assertFalse(Files.exists(parent));
    MoreFiles.createParentDirectories(path);
    assertTrue(Files.exists(parent));
  }

  public void testCreateParentDirectories_multipleParentsNeeded() throws IOException {
    Path path = tempDir.resolve("grandparent/parent/nonexistent.file");
    Path parent = path.getParent();

    Path fileA = newFile("file-a");
    Path fileB = newFile("file-b");
    Path dir1 = newDir("dir-1");
    Path dir2 = newDir("dir-2");

    assertThat(MoreFiles.fileTraverser().breadthFirst(rootDir))
        .containsExactly(rootDir, fileA, fileB, dir1, dir2);
  }

  public void testFileTraverser_multipleDirectoryLayers_breadthFirstStartsWithTopLayer()
      throws Exception {
    Path fileA = newFile("file-a");

import java.net.URLClassLoader;

// TODO(b/65488446): Make this a public API.
/** Utility method to parse the system class path. */
final class ClassPathUtil {
  private ClassPathUtil() {}

  /**
   * Returns the URLs in the class path specified by the {@code java.class.path} {@linkplain
   * System#getProperty system property}.
   */
  // TODO(b/65488446): Make this a public API.
  static URL[] parseJavaClassPath() {

                            path.create(
                                Lists.transform(keys, key -> Maps.immutableEntry(key, key)))))
            .collect(ImmutableList.toImmutableList()),
        n -> n * Math.log(n),
        ImmutableList.of(
            QueryOp.create("BiMap.get", BiMap::get, Math::log),
            QueryOp.create("BiMap.inverse.get", (bm, o) -> bm.inverse().get(o), Math::log)));
  }

  JAVA_CLASS_VERSION("java.class.version"),

  /** Java class path. */
  JAVA_CLASS_PATH("java.class.path"),

  /** List of paths to search when loading libraries. */
  JAVA_LIBRARY_PATH("java.library.path"),

  /** Default temp file path. */
  JAVA_IO_TMPDIR("java.io.tmpdir"),

  /** Name of JIT compiler to use. */
  JAVA_COMPILER("java.compiler"),

  /**
   * Path of extension directory or directories.
   *

     * impossible. We want the test, though, in case that changes in the future,
     * so we use isInstance instead.
     */
    assertFalse(
        "Can't test the main listenInPoolThread path "
            + "if the input is already a ListenableFuture",
        ListenableFuture.class.isInstance(input));
    ListenableFuture<String> listenable = listenInPoolThread(input);
    /*

    if (classpathAttribute != null) {
      for (String path : CLASS_PATH_ATTRIBUTE_SEPARATOR.split(classpathAttribute)) {
        URL url;
        try {
          url = getClassPathEntry(jarFile, path);
        } catch (MalformedURLException e) {
          // Ignore bad entry
          logger.warning("Invalid Class-Path entry: " + path);
          continue;
        }

    }
    String oldPathSeparator = PATH_SEPARATOR.value();
    String oldClassPath = JAVA_CLASS_PATH.value();
    System.setProperty(PATH_SEPARATOR.key(), ":");
    System.setProperty(
        JAVA_CLASS_PATH.key(),
        Joiner.on(":")
            .join(
                "relative/path/to/some.jar",
                "/absolute/path/to/some.jar",

    }
    String oldPathSeparator = PATH_SEPARATOR.value();
    String oldClassPath = JAVA_CLASS_PATH.value();
    System.setProperty(PATH_SEPARATOR.key(), ":");
    System.setProperty(
        JAVA_CLASS_PATH.key(),
        Joiner.on(":")
            .join(
                "relative/path/to/some.jar",
                "/absolute/path/to/some.jar",