1 files changed, 264 insertions, 0 deletions
diff --git a/jimfs/src/test/java/com/google/common/jimfs/PathServiceTest.java b/jimfs/src/test/java/com/google/common/jimfs/PathServiceTest.java
new file mode 100644
index 0000000..65349c7
--- /dev/null
+++ b/jimfs/src/test/java/com/google/common/jimfs/PathServiceTest.java
@@ -0,0 +1,264 @@
+/*
+ * 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.jimfs.PathNormalization.CASE_FOLD_ASCII;
+import static com.google.common.jimfs.PathSubject.paths;
+import static com.google.common.truth.Truth.assertAbout;
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import java.io.IOException;
+import java.net.URI;
+import java.nio.file.FileSystem;
+import java.nio.file.PathMatcher;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link PathService}.
+ *
+ * @author Colin Decker
+ */
+@RunWith(JUnit4.class)
+public class PathServiceTest {
+
+  private static final ImmutableSet<PathNormalization> NO_NORMALIZATIONS = ImmutableSet.of();
+
+  private final PathService service = fakeUnixPathService();
+
+  @Test
+  public void testBasicProperties() {
+    assertThat(service.getSeparator()).isEqualTo("/");
+    assertThat(fakeWindowsPathService().getSeparator()).isEqualTo("\\");
+  }
+
+  @Test
+  public void testPathCreation() {
+    assertAbout(paths())
+        .that(service.emptyPath())
+        .hasRootComponent(null)
+        .and()
+        .hasNameComponents("");
+
+    assertAbout(paths())
+        .that(service.createRoot(service.name("/")))
+        .isAbsolute()
+        .and()
+        .hasRootComponent("/")
+        .and()
+        .hasNoNameComponents();
+
+    assertAbout(paths())
+        .that(service.createFileName(service.name("foo")))
+        .hasRootComponent(null)
+        .and()
+        .hasNameComponents("foo");
+
+    JimfsPath relative = service.createRelativePath(service.names(ImmutableList.of("foo", "bar")));
+    assertAbout(paths())
+        .that(relative)
+        .hasRootComponent(null)
+        .and()
+        .hasNameComponents("foo", "bar");
+
+    JimfsPath absolute =
+        service.createPath(service.name("/"), service.names(ImmutableList.of("foo", "bar")));
+    assertAbout(paths())
+        .that(absolute)
+        .isAbsolute()
+        .and()
+        .hasRootComponent("/")
+        .and()
+        .hasNameComponents("foo", "bar");
+  }
+
+  @Test
+  public void testPathCreation_emptyPath() {
+    // normalized to empty path with single empty string name
+    assertAbout(paths())
+        .that(service.createPath(null, ImmutableList.<Name>of()))
+        .hasRootComponent(null)
+        .and()
+        .hasNameComponents("");
+  }
+
+  @Test
+  public void testPathCreation_parseIgnoresEmptyString() {
+    // if the empty string wasn't ignored, the resulting path would be "/foo" since the empty
+    // string would be joined with foo
+    assertAbout(paths())
+        .that(service.parsePath("", "foo"))
+        .hasRootComponent(null)
+        .and()
+        .hasNameComponents("foo");
+  }
+
+  @Test
+  public void testToString() {
+    // not much to test for this since it just delegates to PathType anyway
+    JimfsPath path =
+        new JimfsPath(service, null, ImmutableList.of(Name.simple("foo"), Name.simple("bar")));
+    assertThat(service.toString(path)).isEqualTo("foo/bar");
+
+    path = new JimfsPath(service, Name.simple("/"), ImmutableList.of(Name.simple("foo")));
+    assertThat(service.toString(path)).isEqualTo("/foo");
+  }
+
+  @Test
+  public void testHash_usingDisplayForm() {
+    PathService pathService = fakePathService(PathType.unix(), false);
+
+    JimfsPath path1 = new JimfsPath(pathService, null, ImmutableList.of(Name.create("FOO", "foo")));
+    JimfsPath path2 = new JimfsPath(pathService, null, ImmutableList.of(Name.create("FOO", "FOO")));
+    JimfsPath path3 =
+        new JimfsPath(
+            pathService, null, ImmutableList.of(Name.create("FOO", "9874238974897189741")));
+
+    assertThat(pathService.hash(path1)).isEqualTo(pathService.hash(path2));
+    assertThat(pathService.hash(path2)).isEqualTo(pathService.hash(path3));
+  }
+
+  @Test
+  public void testHash_usingCanonicalForm() {
+    PathService pathService = fakePathService(PathType.unix(), true);
+
+    JimfsPath path1 = new JimfsPath(pathService, null, ImmutableList.of(Name.create("foo", "foo")));
+    JimfsPath path2 = new JimfsPath(pathService, null, ImmutableList.of(Name.create("FOO", "foo")));
+    JimfsPath path3 =
+        new JimfsPath(
+            pathService, null, ImmutableList.of(Name.create("28937497189478912374897", "foo")));
+
+    assertThat(pathService.hash(path1)).isEqualTo(pathService.hash(path2));
+    assertThat(pathService.hash(path2)).isEqualTo(pathService.hash(path3));
+  }
+
+  @Test
+  public void testCompareTo_usingDisplayForm() {
+    PathService pathService = fakePathService(PathType.unix(), false);
+
+    JimfsPath path1 = new JimfsPath(pathService, null, ImmutableList.of(Name.create("a", "z")));
+    JimfsPath path2 = new JimfsPath(pathService, null, ImmutableList.of(Name.create("b", "y")));
+    JimfsPath path3 = new JimfsPath(pathService, null, ImmutableList.of(Name.create("c", "x")));
+
+    assertThat(pathService.compare(path1, path2)).isEqualTo(-1);
+    assertThat(pathService.compare(path2, path3)).isEqualTo(-1);
+  }
+
+  @Test
+  public void testCompareTo_usingCanonicalForm() {
+    PathService pathService = fakePathService(PathType.unix(), true);
+
+    JimfsPath path1 = new JimfsPath(pathService, null, ImmutableList.of(Name.create("a", "z")));
+    JimfsPath path2 = new JimfsPath(pathService, null, ImmutableList.of(Name.create("b", "y")));
+    JimfsPath path3 = new JimfsPath(pathService, null, ImmutableList.of(Name.create("c", "x")));
+
+    assertThat(pathService.compare(path1, path2)).isEqualTo(1);
+    assertThat(pathService.compare(path2, path3)).isEqualTo(1);
+  }
+
+  @Test
+  public void testPathMatcher() {
+    assertThat(service.createPathMatcher("regex:foo"))
+        .isInstanceOf(PathMatchers.RegexPathMatcher.class);
+    assertThat(service.createPathMatcher("glob:foo"))
+        .isInstanceOf(PathMatchers.RegexPathMatcher.class);
+  }
+
+  @Test
+  public void testPathMatcher_usingCanonicalForm_usesCanonicalNormalizations() {
+    // https://github.com/google/jimfs/issues/91
+    // This matches the behavior of Windows (the only built-in configuration that uses canonical
+    // form for equality). There, PathMatchers should do case-insensitive matching despite Windows
+    // not normalizing case for display.
+    assertCaseInsensitiveMatches(
+        new PathService(
+            PathType.unix(), NO_NORMALIZATIONS, ImmutableSet.of(CASE_FOLD_ASCII), true));
+    assertCaseSensitiveMatches(
+        new PathService(
+            PathType.unix(), ImmutableSet.of(CASE_FOLD_ASCII), NO_NORMALIZATIONS, true));
+  }
+
+  @Test
+  public void testPathMatcher_usingDisplayForm_usesDisplayNormalizations() {
+    assertCaseInsensitiveMatches(
+        new PathService(
+            PathType.unix(), ImmutableSet.of(CASE_FOLD_ASCII), NO_NORMALIZATIONS, false));
+    assertCaseSensitiveMatches(
+        new PathService(
+            PathType.unix(), NO_NORMALIZATIONS, ImmutableSet.of(CASE_FOLD_ASCII), false));
+  }
+
+  private static void assertCaseInsensitiveMatches(PathService service) {
+    ImmutableList<PathMatcher> matchers =
+        ImmutableList.of(
+            service.createPathMatcher("glob:foo"), service.createPathMatcher("glob:FOO"));
+
+    JimfsPath lowerCasePath = singleNamePath(service, "foo");
+    JimfsPath upperCasePath = singleNamePath(service, "FOO");
+    JimfsPath nonMatchingPath = singleNamePath(service, "bar");
+
+    for (PathMatcher matcher : matchers) {
+      assertThat(matcher.matches(lowerCasePath)).isTrue();
+      assertThat(matcher.matches(upperCasePath)).isTrue();
+      assertThat(matcher.matches(nonMatchingPath)).isFalse();
+    }
+  }
+
+  private static void assertCaseSensitiveMatches(PathService service) {
+    PathMatcher matcher = service.createPathMatcher("glob:foo");
+
+    JimfsPath lowerCasePath = singleNamePath(service, "foo");
+    JimfsPath upperCasePath = singleNamePath(service, "FOO");
+
+    assertThat(matcher.matches(lowerCasePath)).isTrue();
+    assertThat(matcher.matches(upperCasePath)).isFalse();
+  }
+
+  public static PathService fakeUnixPathService() {
+    return fakePathService(PathType.unix(), false);
+  }
+
+  public static PathService fakeWindowsPathService() {
+    return fakePathService(PathType.windows(), false);
+  }
+
+  public static PathService fakePathService(PathType type, boolean equalityUsesCanonicalForm) {
+    PathService service =
+        new PathService(type, NO_NORMALIZATIONS, NO_NORMALIZATIONS, equalityUsesCanonicalForm);
+    service.setFileSystem(FILE_SYSTEM);
+    return service;
+  }
+
+  private static JimfsPath singleNamePath(PathService service, String name) {
+    return new JimfsPath(service, null, ImmutableList.of(Name.create(name, name)));
+  }
+
+  private static final FileSystem FILE_SYSTEM;
+
+  static {
+    try {
+      FILE_SYSTEM =
+          JimfsFileSystems.newFileSystem(
+              new JimfsFileSystemProvider(), URI.create("jimfs://foo"), Configuration.unix());
+    } catch (IOException e) {
+      throw new AssertionError(e);
+    }
+  }
+}