1 files changed, 157 insertions, 0 deletions
diff --git a/jimfs/src/test/java/com/google/common/jimfs/PathTypeTest.java b/jimfs/src/test/java/com/google/common/jimfs/PathTypeTest.java
new file mode 100644
index 0000000..59fc114
--- /dev/null
+++ b/jimfs/src/test/java/com/google/common/jimfs/PathTypeTest.java
@@ -0,0 +1,157 @@
+/*
+ * 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.Preconditions.checkArgument;
+import static com.google.common.jimfs.PathType.ParseResult;
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import java.net.URI;
+import org.checkerframework.checker.nullness.compatqual.NullableDecl;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link PathType}.
+ *
+ * @author Colin Decker
+ */
+@RunWith(JUnit4.class)
+public class PathTypeTest {
+
+  private static final FakePathType type = new FakePathType();
+  static final URI fileSystemUri = URI.create("jimfs://foo");
+
+  @Test
+  public void testBasicProperties() {
+    assertThat(type.getSeparator()).isEqualTo("/");
+    assertThat(type.getOtherSeparators()).isEqualTo("\\");
+  }
+
+  @Test
+  public void testParsePath() {
+    ParseResult path = type.parsePath("foo/bar/baz/one\\two");
+    assertParseResult(path, null, "foo", "bar", "baz", "one", "two");
+
+    ParseResult path2 = type.parsePath("$one//\\two");
+    assertParseResult(path2, "$", "one", "two");
+  }
+
+  @Test
+  public void testToString() {
+    ParseResult path = type.parsePath("foo/bar\\baz");
+    assertThat(type.toString(path.root(), path.names())).isEqualTo("foo/bar/baz");
+
+    ParseResult path2 = type.parsePath("$/foo/bar");
+    assertThat(type.toString(path2.root(), path2.names())).isEqualTo("$foo/bar");
+  }
+
+  @Test
+  public void testToUri() {
+    URI fileUri = type.toUri(fileSystemUri, "$", ImmutableList.of("foo", "bar"), false);
+    assertThat(fileUri.toString()).isEqualTo("jimfs://foo/$/foo/bar");
+    assertThat(fileUri.getPath()).isEqualTo("/$/foo/bar");
+
+    URI directoryUri = type.toUri(fileSystemUri, "$", ImmutableList.of("foo", "bar"), true);
+    assertThat(directoryUri.toString()).isEqualTo("jimfs://foo/$/foo/bar/");
+    assertThat(directoryUri.getPath()).isEqualTo("/$/foo/bar/");
+
+    URI rootUri = type.toUri(fileSystemUri, "$", ImmutableList.<String>of(), true);
+    assertThat(rootUri.toString()).isEqualTo("jimfs://foo/$/");
+    assertThat(rootUri.getPath()).isEqualTo("/$/");
+  }
+
+  @Test
+  public void testToUri_escaping() {
+    URI fileUri = type.toUri(fileSystemUri, "$", ImmutableList.of("foo", "bar baz"), false);
+    assertThat(fileUri.toString()).isEqualTo("jimfs://foo/$/foo/bar%20baz");
+    assertThat(fileUri.getRawPath()).isEqualTo("/$/foo/bar%20baz");
+    assertThat(fileUri.getPath()).isEqualTo("/$/foo/bar baz");
+  }
+
+  @Test
+  public void testUriRoundTrips() {
+    assertUriRoundTripsCorrectly(type, "$");
+    assertUriRoundTripsCorrectly(type, "$foo");
+    assertUriRoundTripsCorrectly(type, "$foo/bar/baz");
+    assertUriRoundTripsCorrectly(type, "$foo bar");
+    assertUriRoundTripsCorrectly(type, "$foo/bar baz");
+  }
+
+  static void assertParseResult(ParseResult result, @NullableDecl String root, String... names) {
+    assertThat(result.root()).isEqualTo(root);
+    assertThat(result.names()).containsExactly((Object[]) names).inOrder();
+  }
+
+  static void assertUriRoundTripsCorrectly(PathType type, String path) {
+    ParseResult result = type.parsePath(path);
+    URI uri = type.toUri(fileSystemUri, result.root(), result.names(), false);
+    ParseResult parsedUri = type.fromUri(uri);
+    assertThat(parsedUri.root()).isEqualTo(result.root());
+    assertThat(parsedUri.names()).containsExactlyElementsIn(result.names()).inOrder();
+  }
+
+  /** Arbitrary path type with $ as the root, / as the separator and \ as an alternate separator. */
+  private static final class FakePathType extends PathType {
+
+    protected FakePathType() {
+      super(false, '/', '\\');
+    }
+
+    @Override
+    public ParseResult parsePath(String path) {
+      String root = null;
+      if (path.startsWith("$")) {
+        root = "$";
+        path = path.substring(1);
+      }
+
+      return new ParseResult(root, splitter().split(path));
+    }
+
+    @Override
+    public String toString(@NullableDecl String root, Iterable<String> names) {
+      StringBuilder builder = new StringBuilder();
+      if (root != null) {
+        builder.append(root);
+      }
+      joiner().appendTo(builder, names);
+      return builder.toString();
+    }
+
+    @Override
+    public String toUriPath(String root, Iterable<String> names, boolean directory) {
+      StringBuilder builder = new StringBuilder();
+      builder.append('/').append(root);
+      for (String name : names) {
+        builder.append('/').append(name);
+      }
+      if (directory) {
+        builder.append('/');
+      }
+      return builder.toString();
+    }
+
+    @Override
+    public ParseResult parseUriPath(String uriPath) {
+      checkArgument(uriPath.startsWith("/$"), "uriPath (%s) must start with /$", uriPath);
+      return parsePath(uriPath.substring(1));
+    }
+  }
+}