1 files changed, 187 insertions, 0 deletions
diff --git a/jimfs/src/test/java/com/google/common/jimfs/PathTester.java b/jimfs/src/test/java/com/google/common/jimfs/PathTester.java
new file mode 100644
index 0000000..b96d77e
--- /dev/null
+++ b/jimfs/src/test/java/com/google/common/jimfs/PathTester.java
@@ -0,0 +1,187 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.common.jimfs;
+
+import static com.google.common.base.Functions.toStringFunction;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.base.Joiner;
+import com.google.common.base.Splitter;
+import com.google.common.collect.FluentIterable;
+import com.google.common.collect.ImmutableList;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.List;
+
+/** @author Colin Decker */
+public final class PathTester {
+
+  private final PathService pathService;
+  private final String string;
+  private String root;
+  private ImmutableList<String> names = ImmutableList.of();
+
+  public PathTester(PathService pathService, String string) {
+    this.pathService = pathService;
+    this.string = string;
+  }
+
+  public PathTester root(String root) {
+    this.root = root;
+    return this;
+  }
+
+  public PathTester names(Iterable<String> names) {
+    this.names = ImmutableList.copyOf(names);
+    return this;
+  }
+
+  public PathTester names(String... names) {
+    return names(Arrays.asList(names));
+  }
+
+  public void test(String first, String... more) {
+    Path path = pathService.parsePath(first, more);
+    test(path);
+  }
+
+  public void test(Path path) {
+    assertEquals(string, path.toString());
+
+    testRoot(path);
+    testNames(path);
+    testParents(path);
+    testStartsWith(path);
+    testEndsWith(path);
+    testSubpaths(path);
+  }
+
+  private void testRoot(Path path) {
+    if (root != null) {
+      assertTrue(path + ".isAbsolute() should be true", path.isAbsolute());
+      assertNotNull(path + ".getRoot() should not be null", path.getRoot());
+      assertEquals(root, path.getRoot().toString());
+    } else {
+      assertFalse(path + ".isAbsolute() should be false", path.isAbsolute());
+      assertNull(path + ".getRoot() should be null", path.getRoot());
+    }
+  }
+
+  private void testNames(Path path) {
+    assertEquals(names.size(), path.getNameCount());
+    assertEquals(names, names(path));
+    for (int i = 0; i < names.size(); i++) {
+      assertEquals(names.get(i), path.getName(i).toString());
+      // don't test individual names if this is an individual name
+      if (names.size() > 1) {
+        new PathTester(pathService, names.get(i)).names(names.get(i)).test(path.getName(i));
+      }
+    }
+    if (names.size() > 0) {
+      String fileName = names.get(names.size() - 1);
+      assertEquals(fileName, path.getFileName().toString());
+      // don't test individual names if this is an individual name
+      if (names.size() > 1) {
+        new PathTester(pathService, fileName).names(fileName).test(path.getFileName());
+      }
+    }
+  }
+
+  private void testParents(Path path) {
+    Path parent = path.getParent();
+
+    if (root != null && names.size() >= 1 || names.size() > 1) {
+      assertNotNull(parent);
+    }
+
+    if (parent != null) {
+      String parentName = names.size() == 1 ? root : string.substring(0, string.lastIndexOf('/'));
+      new PathTester(pathService, parentName)
+          .root(root)
+          .names(names.subList(0, names.size() - 1))
+          .test(parent);
+    }
+  }
+
+  private void testSubpaths(Path path) {
+    if (path.getRoot() == null) {
+      assertEquals(path, path.subpath(0, path.getNameCount()));
+    }
+
+    if (path.getNameCount() > 1) {
+      String stringWithoutRoot = root == null ? string : string.substring(root.length());
+
+      // test start + 1 to end and start to end - 1 subpaths... this recursively tests all subpaths
+      // actually tests most possible subpaths multiple times but... eh
+      Path startSubpath = path.subpath(1, path.getNameCount());
+      List<String> startNames =
+          ImmutableList.copyOf(Splitter.on('/').split(stringWithoutRoot))
+              .subList(1, path.getNameCount());
+
+      new PathTester(pathService, Joiner.on('/').join(startNames))
+          .names(startNames)
+          .test(startSubpath);
+
+      Path endSubpath = path.subpath(0, path.getNameCount() - 1);
+      List<String> endNames =
+          ImmutableList.copyOf(Splitter.on('/').split(stringWithoutRoot))
+              .subList(0, path.getNameCount() - 1);
+
+      new PathTester(pathService, Joiner.on('/').join(endNames)).names(endNames).test(endSubpath);
+    }
+  }
+
+  private void testStartsWith(Path path) {
+    // empty path doesn't start with any path
+    if (root != null || !names.isEmpty()) {
+      Path other = path;
+      while (other != null) {
+        assertTrue(path + ".startsWith(" + other + ") should be true", path.startsWith(other));
+        assertTrue(
+            path + ".startsWith(" + other + ") should be true", path.startsWith(other.toString()));
+        other = other.getParent();
+      }
+    }
+  }
+
+  private void testEndsWith(Path path) {
+    // empty path doesn't start with any path
+    if (root != null || !names.isEmpty()) {
+      Path other = path;
+      while (other != null) {
+        assertTrue(path + ".endsWith(" + other + ") should be true", path.endsWith(other));
+        assertTrue(
+            path + ".endsWith(" + other + ") should be true", path.endsWith(other.toString()));
+        if (other.getRoot() != null && other.getNameCount() > 0) {
+          other = other.subpath(0, other.getNameCount());
+        } else if (other.getNameCount() > 1) {
+          other = other.subpath(1, other.getNameCount());
+        } else {
+          other = null;
+        }
+      }
+    }
+  }
+
+  private static List<String> names(Path path) {
+    return FluentIterable.from(path).transform(toStringFunction()).toList();
+  }
+}