1 files changed, 491 insertions, 0 deletions
diff --git a/jimfs/src/test/java/com/google/common/jimfs/JimfsWindowsLikeFileSystemTest.java b/jimfs/src/test/java/com/google/common/jimfs/JimfsWindowsLikeFileSystemTest.java
new file mode 100644
index 0000000..a3b7ad2
--- /dev/null
+++ b/jimfs/src/test/java/com/google/common/jimfs/JimfsWindowsLikeFileSystemTest.java
@@ -0,0 +1,491 @@
+/*
+ * 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.truth.Truth.assertThat;
+import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Ordering;
+import java.io.IOException;
+import java.net.URI;
+import java.nio.file.FileSystem;
+import java.nio.file.FileSystemException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.regex.PatternSyntaxException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests a Windows-like file system through the public methods in {@link Files}.
+ *
+ * @author Colin Decker
+ */
+@RunWith(JUnit4.class)
+public class JimfsWindowsLikeFileSystemTest extends AbstractJimfsIntegrationTest {
+
+  @Override
+  protected FileSystem createFileSystem() {
+    return Jimfs.newFileSystem(
+        "win",
+        Configuration.windows().toBuilder()
+            .setRoots("C:\\", "E:\\")
+            .setAttributeViews("basic", "owner", "dos", "acl", "user")
+            .build());
+  }
+
+  @Test
+  public void testFileSystem() {
+    assertThat(fs.getSeparator()).isEqualTo("\\");
+    assertThat(fs.getRootDirectories())
+        .containsExactlyElementsIn(ImmutableSet.of(path("C:\\"), path("E:\\")))
+        .inOrder();
+    assertThat(fs.isOpen()).isTrue();
+    assertThat(fs.isReadOnly()).isFalse();
+    assertThat(fs.supportedFileAttributeViews())
+        .containsExactly("basic", "owner", "dos", "acl", "user");
+    assertThat(fs.provider()).isInstanceOf(JimfsFileSystemProvider.class);
+  }
+
+  @Test
+  public void testPaths() {
+    assertThatPath("C:\\").isAbsolute().and().hasRootComponent("C:\\").and().hasNoNameComponents();
+    assertThatPath("foo").isRelative().and().hasNameComponents("foo");
+    assertThatPath("foo\\bar").isRelative().and().hasNameComponents("foo", "bar");
+    assertThatPath("C:\\foo\\bar\\baz")
+        .isAbsolute()
+        .and()
+        .hasRootComponent("C:\\")
+        .and()
+        .hasNameComponents("foo", "bar", "baz");
+  }
+
+  @Test
+  public void testPaths_equalityIsCaseInsensitive() {
+    assertThatPath("C:\\").isEqualTo(path("c:\\"));
+    assertThatPath("foo").isEqualTo(path("FOO"));
+  }
+
+  @Test
+  public void testPaths_areSortedCaseInsensitive() {
+    Path p1 = path("a");
+    Path p2 = path("B");
+    Path p3 = path("c");
+    Path p4 = path("D");
+
+    assertThat(Ordering.natural().immutableSortedCopy(Arrays.asList(p3, p4, p1, p2)))
+        .isEqualTo(ImmutableList.of(p1, p2, p3, p4));
+
+    // would be p2, p4, p1, p3 if sorting were case sensitive
+  }
+
+  @Test
+  public void testPaths_withSlash() {
+    assertThatPath("foo/bar")
+        .isRelative()
+        .and()
+        .hasNameComponents("foo", "bar")
+        .and()
+        .isEqualTo(path("foo\\bar"));
+    assertThatPath("C:/foo/bar/baz")
+        .isAbsolute()
+        .and()
+        .hasRootComponent("C:\\")
+        .and()
+        .hasNameComponents("foo", "bar", "baz")
+        .and()
+        .isEqualTo(path("C:\\foo\\bar\\baz"));
+    assertThatPath("C:/foo\\bar/baz")
+        .isAbsolute()
+        .and()
+        .hasRootComponent("C:\\")
+        .and()
+        .hasNameComponents("foo", "bar", "baz")
+        .and()
+        .isEqualTo(path("C:\\foo\\bar\\baz"));
+  }
+
+  @Test
+  public void testPaths_resolve() {
+    assertThatPath(path("C:\\").resolve("foo\\bar"))
+        .isAbsolute()
+        .and()
+        .hasRootComponent("C:\\")
+        .and()
+        .hasNameComponents("foo", "bar");
+    assertThatPath(path("foo\\bar").resolveSibling("baz"))
+        .isRelative()
+        .and()
+        .hasNameComponents("foo", "baz");
+    assertThatPath(path("foo\\bar").resolve("C:\\one\\two"))
+        .isAbsolute()
+        .and()
+        .hasRootComponent("C:\\")
+        .and()
+        .hasNameComponents("one", "two");
+  }
+
+  @Test
+  public void testPaths_normalize() {
+    assertThatPath(path("foo\\bar\\..").normalize()).isRelative().and().hasNameComponents("foo");
+    assertThatPath(path("foo\\.\\bar\\..\\baz\\test\\.\\..\\stuff").normalize())
+        .isRelative()
+        .and()
+        .hasNameComponents("foo", "baz", "stuff");
+    assertThatPath(path("..\\..\\foo\\.\\bar").normalize())
+        .isRelative()
+        .and()
+        .hasNameComponents("..", "..", "foo", "bar");
+    assertThatPath(path("foo\\..\\..\\bar").normalize())
+        .isRelative()
+        .and()
+        .hasNameComponents("..", "bar");
+    assertThatPath(path("..\\.\\..").normalize()).isRelative().and().hasNameComponents("..", "..");
+  }
+
+  @Test
+  public void testPaths_relativize() {
+    assertThatPath(path("C:\\foo\\bar").relativize(path("C:\\foo\\bar\\baz")))
+        .isRelative()
+        .and()
+        .hasNameComponents("baz");
+    assertThatPath(path("C:\\foo\\bar\\baz").relativize(path("C:\\foo\\bar")))
+        .isRelative()
+        .and()
+        .hasNameComponents("..");
+    assertThatPath(path("C:\\foo\\bar\\baz").relativize(path("C:\\foo\\baz\\bar")))
+        .isRelative()
+        .and()
+        .hasNameComponents("..", "..", "baz", "bar");
+    assertThatPath(path("foo\\bar").relativize(path("foo")))
+        .isRelative()
+        .and()
+        .hasNameComponents("..");
+    assertThatPath(path("foo").relativize(path("foo\\bar")))
+        .isRelative()
+        .and()
+        .hasNameComponents("bar");
+
+    try {
+      Path unused = path("C:\\foo\\bar").relativize(path("bar"));
+      fail();
+    } catch (IllegalArgumentException expected) {
+    }
+
+    try {
+      Path unused = path("bar").relativize(path("C:\\foo\\bar"));
+      fail();
+    } catch (IllegalArgumentException expected) {
+    }
+  }
+
+  @Test
+  public void testPaths_startsWith_endsWith() {
+    assertThat(path("C:\\foo\\bar").startsWith("C:\\")).isTrue();
+    assertThat(path("C:\\foo\\bar").startsWith("C:\\foo")).isTrue();
+    assertThat(path("C:\\foo\\bar").startsWith("C:\\foo\\bar")).isTrue();
+    assertThat(path("C:\\foo\\bar").endsWith("bar")).isTrue();
+    assertThat(path("C:\\foo\\bar").endsWith("foo\\bar")).isTrue();
+    assertThat(path("C:\\foo\\bar").endsWith("C:\\foo\\bar")).isTrue();
+    assertThat(path("C:\\foo\\bar").endsWith("C:\\foo")).isFalse();
+    assertThat(path("C:\\foo\\bar").startsWith("foo\\bar")).isFalse();
+  }
+
+  @Test
+  public void testPaths_toAbsolutePath() {
+    assertThatPath(path("C:\\foo\\bar").toAbsolutePath())
+        .isAbsolute()
+        .and()
+        .hasRootComponent("C:\\")
+        .and()
+        .hasNameComponents("foo", "bar")
+        .and()
+        .isEqualTo(path("C:\\foo\\bar"));
+
+    assertThatPath(path("foo\\bar").toAbsolutePath())
+        .isAbsolute()
+        .and()
+        .hasRootComponent("C:\\")
+        .and()
+        .hasNameComponents("work", "foo", "bar")
+        .and()
+        .isEqualTo(path("C:\\work\\foo\\bar"));
+  }
+
+  @Test
+  public void testPaths_toRealPath() throws IOException {
+    Files.createDirectories(path("C:\\foo\\bar"));
+    Files.createSymbolicLink(path("C:\\link"), path("C:\\"));
+
+    assertThatPath(path("C:\\link\\foo\\bar").toRealPath()).isEqualTo(path("C:\\foo\\bar"));
+
+    assertThatPath(path("").toRealPath()).isEqualTo(path("C:\\work"));
+    assertThatPath(path(".").toRealPath()).isEqualTo(path("C:\\work"));
+    assertThatPath(path("..").toRealPath()).isEqualTo(path("C:\\"));
+    assertThatPath(path("..\\..").toRealPath()).isEqualTo(path("C:\\"));
+    assertThatPath(path(".\\..\\.\\..").toRealPath()).isEqualTo(path("C:\\"));
+    assertThatPath(path(".\\..\\.\\..\\.").toRealPath()).isEqualTo(path("C:\\"));
+  }
+
+  @Test
+  public void testPaths_toUri() {
+    assertThat(fs.getPath("C:\\").toUri()).isEqualTo(URI.create("jimfs://win/C:/"));
+    assertThat(fs.getPath("C:\\foo").toUri()).isEqualTo(URI.create("jimfs://win/C:/foo"));
+    assertThat(fs.getPath("C:\\foo\\bar").toUri()).isEqualTo(URI.create("jimfs://win/C:/foo/bar"));
+    assertThat(fs.getPath("foo").toUri()).isEqualTo(URI.create("jimfs://win/C:/work/foo"));
+    assertThat(fs.getPath("foo\\bar").toUri()).isEqualTo(URI.create("jimfs://win/C:/work/foo/bar"));
+    assertThat(fs.getPath("").toUri()).isEqualTo(URI.create("jimfs://win/C:/work/"));
+    assertThat(fs.getPath(".\\..\\.").toUri()).isEqualTo(URI.create("jimfs://win/C:/work/./.././"));
+  }
+
+  @Test
+  public void testPaths_toUri_unc() {
+    assertThat(fs.getPath("\\\\host\\share\\").toUri())
+        .isEqualTo(URI.create("jimfs://win//host/share/"));
+    assertThat(fs.getPath("\\\\host\\share\\foo").toUri())
+        .isEqualTo(URI.create("jimfs://win//host/share/foo"));
+    assertThat(fs.getPath("\\\\host\\share\\foo\\bar").toUri())
+        .isEqualTo(URI.create("jimfs://win//host/share/foo/bar"));
+  }
+
+  @Test
+  public void testPaths_getFromUri() {
+    assertThatPath(Paths.get(URI.create("jimfs://win/C:/"))).isEqualTo(fs.getPath("C:\\"));
+    assertThatPath(Paths.get(URI.create("jimfs://win/C:/foo"))).isEqualTo(fs.getPath("C:\\foo"));
+    assertThatPath(Paths.get(URI.create("jimfs://win/C:/foo%20bar")))
+        .isEqualTo(fs.getPath("C:\\foo bar"));
+    assertThatPath(Paths.get(URI.create("jimfs://win/C:/foo/./bar")))
+        .isEqualTo(fs.getPath("C:\\foo\\.\\bar"));
+    assertThatPath(Paths.get(URI.create("jimfs://win/C:/foo/bar/")))
+        .isEqualTo(fs.getPath("C:\\foo\\bar"));
+  }
+
+  @Test
+  public void testPaths_getFromUri_unc() {
+    assertThatPath(Paths.get(URI.create("jimfs://win//host/share/")))
+        .isEqualTo(fs.getPath("\\\\host\\share\\"));
+    assertThatPath(Paths.get(URI.create("jimfs://win//host/share/foo")))
+        .isEqualTo(fs.getPath("\\\\host\\share\\foo"));
+    assertThatPath(Paths.get(URI.create("jimfs://win//host/share/foo%20bar")))
+        .isEqualTo(fs.getPath("\\\\host\\share\\foo bar"));
+    assertThatPath(Paths.get(URI.create("jimfs://win//host/share/foo/./bar")))
+        .isEqualTo(fs.getPath("\\\\host\\share\\foo\\.\\bar"));
+    assertThatPath(Paths.get(URI.create("jimfs://win//host/share/foo/bar/")))
+        .isEqualTo(fs.getPath("\\\\host\\share\\foo\\bar"));
+  }
+
+  @Test
+  public void testPathMatchers_glob() {
+    assertThatPath("bar").matches("glob:bar");
+    assertThatPath("bar").matches("glob:*");
+    assertThatPath("C:\\foo").doesNotMatch("glob:*");
+    assertThatPath("C:\\foo\\bar").doesNotMatch("glob:*");
+    assertThatPath("C:\\foo\\bar").matches("glob:**");
+    assertThatPath("C:\\foo\\bar").matches("glob:C:\\\\**");
+    assertThatPath("foo\\bar").doesNotMatch("glob:C:\\\\**");
+    assertThatPath("C:\\foo\\bar\\baz\\stuff").matches("glob:C:\\\\foo\\\\**");
+    assertThatPath("C:\\foo\\bar\\baz\\stuff").matches("glob:C:\\\\**\\\\stuff");
+    assertThatPath("C:\\foo").matches("glob:C:\\\\[a-z]*");
+    assertThatPath("C:\\Foo").matches("glob:C:\\\\[a-z]*");
+    assertThatPath("C:\\foo").matches("glob:C:\\\\[A-Z]*");
+    assertThatPath("C:\\Foo").matches("glob:C:\\\\[A-Z]*");
+    assertThatPath("C:\\foo\\bar\\baz\\Stuff.java").matches("glob:**\\\\*.java");
+    assertThatPath("C:\\foo\\bar\\baz\\Stuff.java").matches("glob:**\\\\*.{java,class}");
+    assertThatPath("C:\\foo\\bar\\baz\\Stuff.class").matches("glob:**\\\\*.{java,class}");
+    assertThatPath("C:\\foo\\bar\\baz\\Stuff.java").matches("glob:**\\\\*.*");
+
+    try {
+      fs.getPathMatcher("glob:**\\*.{java,class");
+      fail();
+    } catch (PatternSyntaxException expected) {
+    }
+  }
+
+  @Test
+  public void testPathMatchers_glob_alternateSeparators() {
+    // only need to test / in the glob pattern; tests above check that / in a path is changed to
+    // \ automatically
+    assertThatPath("C:\\foo").doesNotMatch("glob:*");
+    assertThatPath("C:\\foo\\bar").doesNotMatch("glob:*");
+    assertThatPath("C:\\foo\\bar").matches("glob:**");
+    assertThatPath("C:\\foo\\bar").matches("glob:C:/**");
+    assertThatPath("foo\\bar").doesNotMatch("glob:C:/**");
+    assertThatPath("C:\\foo\\bar\\baz\\stuff").matches("glob:C:/foo/**");
+    assertThatPath("C:\\foo\\bar\\baz\\stuff").matches("glob:C:/**/stuff");
+    assertThatPath("C:\\foo").matches("glob:C:/[a-z]*");
+    assertThatPath("C:\\Foo").matches("glob:C:/[a-z]*");
+    assertThatPath("C:\\foo").matches("glob:C:/[A-Z]*");
+    assertThatPath("C:\\Foo").matches("glob:C:/[A-Z]*");
+    assertThatPath("C:\\foo\\bar\\baz\\Stuff.java").matches("glob:**/*.java");
+    assertThatPath("C:\\foo\\bar\\baz\\Stuff.java").matches("glob:**/*.{java,class}");
+    assertThatPath("C:\\foo\\bar\\baz\\Stuff.class").matches("glob:**/*.{java,class}");
+    assertThatPath("C:\\foo\\bar\\baz\\Stuff.java").matches("glob:**/*.*");
+
+    try {
+      fs.getPathMatcher("glob:**/*.{java,class");
+      fail();
+    } catch (PatternSyntaxException expected) {
+    }
+  }
+
+  @Test
+  public void testCreateFileOrDirectory_forNonExistentRootPath_fails() throws IOException {
+    try {
+      Files.createDirectory(path("Z:\\"));
+      fail();
+    } catch (IOException expected) {
+    }
+
+    try {
+      Files.createFile(path("Z:\\"));
+      fail();
+    } catch (IOException expected) {
+    }
+
+    try {
+      Files.createSymbolicLink(path("Z:\\"), path("foo"));
+      fail();
+    } catch (IOException expected) {
+    }
+  }
+
+  @Test
+  public void testCopyFile_toNonExistentRootPath_fails() throws IOException {
+    Files.createFile(path("foo"));
+    Files.createDirectory(path("bar"));
+
+    try {
+      Files.copy(path("foo"), path("Z:\\"));
+      fail();
+    } catch (IOException expected) {
+    }
+
+    try {
+      Files.copy(path("bar"), path("Z:\\"));
+      fail();
+    } catch (IOException expected) {
+    }
+  }
+
+  @Test
+  public void testMoveFile_toNonExistentRootPath_fails() throws IOException {
+    Files.createFile(path("foo"));
+    Files.createDirectory(path("bar"));
+
+    try {
+      Files.move(path("foo"), path("Z:\\"));
+      fail();
+    } catch (IOException expected) {
+    }
+
+    try {
+      Files.move(path("bar"), path("Z:\\"));
+      fail();
+    } catch (IOException expected) {
+    }
+  }
+
+  @Test
+  public void testDelete_directory_cantDeleteRoot() throws IOException {
+    // test with E:\ because it is empty
+    try {
+      Files.delete(path("E:\\"));
+      fail();
+    } catch (FileSystemException expected) {
+      assertThat(expected.getFile()).isEqualTo("E:\\");
+      assertThat(expected.getMessage()).contains("root");
+    }
+  }
+
+  @Test
+  public void testCreateFileOrDirectory_forExistingRootPath_fails() throws IOException {
+    try {
+      Files.createDirectory(path("E:\\"));
+      fail();
+    } catch (IOException expected) {
+    }
+
+    try {
+      Files.createFile(path("E:\\"));
+      fail();
+    } catch (IOException expected) {
+    }
+
+    try {
+      Files.createSymbolicLink(path("E:\\"), path("foo"));
+      fail();
+    } catch (IOException expected) {
+    }
+  }
+
+  @Test
+  public void testCopyFile_toExistingRootPath_fails() throws IOException {
+    Files.createFile(path("foo"));
+    Files.createDirectory(path("bar"));
+
+    try {
+      Files.copy(path("foo"), path("E:\\"), REPLACE_EXISTING);
+      fail();
+    } catch (IOException expected) {
+    }
+
+    try {
+      Files.copy(path("bar"), path("E:\\"), REPLACE_EXISTING);
+      fail();
+    } catch (IOException expected) {
+    }
+  }
+
+  @Test
+  public void testMoveFile_toExistingRootPath_fails() throws IOException {
+    Files.createFile(path("foo"));
+    Files.createDirectory(path("bar"));
+
+    try {
+      Files.move(path("foo"), path("E:\\"), REPLACE_EXISTING);
+      fail();
+    } catch (IOException expected) {
+    }
+
+    try {
+      Files.move(path("bar"), path("E:\\"), REPLACE_EXISTING);
+      fail();
+    } catch (IOException expected) {
+    }
+  }
+
+  @Test
+  public void testMove_rootDirectory_fails() throws IOException {
+    try {
+      Files.move(path("E:\\"), path("Z:\\"));
+      fail();
+    } catch (FileSystemException expected) {
+    }
+
+    try {
+      Files.move(path("E:\\"), path("C:\\bar"));
+      fail();
+    } catch (FileSystemException expected) {
+    }
+  }
+}