1 files changed, 366 insertions, 0 deletions
diff --git a/jimfs/src/test/java/com/google/common/jimfs/ConfigurationTest.java b/jimfs/src/test/java/com/google/common/jimfs/ConfigurationTest.java
new file mode 100644
index 0000000..0404f57
--- /dev/null
+++ b/jimfs/src/test/java/com/google/common/jimfs/ConfigurationTest.java
@@ -0,0 +1,366 @@
+/*
+ * 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.PathNormalization.CASE_FOLD_UNICODE;
+import static com.google.common.jimfs.PathNormalization.NFC;
+import static com.google.common.jimfs.PathNormalization.NFD;
+import static com.google.common.jimfs.PathSubject.paths;
+import static com.google.common.jimfs.WatchServiceConfiguration.polling;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assert_;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import java.io.IOException;
+import java.nio.file.FileAlreadyExistsException;
+import java.nio.file.FileSystem;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.WatchService;
+import java.nio.file.attribute.PosixFilePermissions;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link Configuration}, {@link Configuration.Builder} and file systems created from
+ * them.
+ *
+ * @author Colin Decker
+ */
+@RunWith(JUnit4.class)
+public class ConfigurationTest {
+
+  private static PathSubject assertThatPath(Path path) {
+    return assert_().about(paths()).that(path);
+  }
+
+  @Test
+  public void testDefaultUnixConfiguration() {
+    Configuration config = Configuration.unix();
+
+    assertThat(config.pathType).isEqualTo(PathType.unix());
+    assertThat(config.roots).containsExactly("/");
+    assertThat(config.workingDirectory).isEqualTo("/work");
+    assertThat(config.nameCanonicalNormalization).isEmpty();
+    assertThat(config.nameDisplayNormalization).isEmpty();
+    assertThat(config.pathEqualityUsesCanonicalForm).isFalse();
+    assertThat(config.blockSize).isEqualTo(8192);
+    assertThat(config.maxSize).isEqualTo(4L * 1024 * 1024 * 1024);
+    assertThat(config.maxCacheSize).isEqualTo(-1);
+    assertThat(config.attributeViews).containsExactly("basic");
+    assertThat(config.attributeProviders).isEmpty();
+    assertThat(config.defaultAttributeValues).isEmpty();
+  }
+
+  @Test
+  public void testFileSystemForDefaultUnixConfiguration() throws IOException {
+    FileSystem fs = Jimfs.newFileSystem(Configuration.unix());
+
+    assertThat(fs.getRootDirectories())
+        .containsExactlyElementsIn(ImmutableList.of(fs.getPath("/")))
+        .inOrder();
+    assertThatPath(fs.getPath("").toRealPath()).isEqualTo(fs.getPath("/work"));
+    assertThat(Iterables.getOnlyElement(fs.getFileStores()).getTotalSpace())
+        .isEqualTo(4L * 1024 * 1024 * 1024);
+    assertThat(fs.supportedFileAttributeViews()).containsExactly("basic");
+
+    Files.createFile(fs.getPath("/foo"));
+    Files.createFile(fs.getPath("/FOO"));
+  }
+
+  @Test
+  public void testDefaultOsXConfiguration() {
+    Configuration config = Configuration.osX();
+
+    assertThat(config.pathType).isEqualTo(PathType.unix());
+    assertThat(config.roots).containsExactly("/");
+    assertThat(config.workingDirectory).isEqualTo("/work");
+    assertThat(config.nameCanonicalNormalization).containsExactly(NFD, CASE_FOLD_ASCII);
+    assertThat(config.nameDisplayNormalization).containsExactly(NFC);
+    assertThat(config.pathEqualityUsesCanonicalForm).isFalse();
+    assertThat(config.blockSize).isEqualTo(8192);
+    assertThat(config.maxSize).isEqualTo(4L * 1024 * 1024 * 1024);
+    assertThat(config.maxCacheSize).isEqualTo(-1);
+    assertThat(config.attributeViews).containsExactly("basic");
+    assertThat(config.attributeProviders).isEmpty();
+    assertThat(config.defaultAttributeValues).isEmpty();
+  }
+
+  @Test
+  public void testFileSystemForDefaultOsXConfiguration() throws IOException {
+    FileSystem fs = Jimfs.newFileSystem(Configuration.osX());
+
+    assertThat(fs.getRootDirectories())
+        .containsExactlyElementsIn(ImmutableList.of(fs.getPath("/")))
+        .inOrder();
+    assertThatPath(fs.getPath("").toRealPath()).isEqualTo(fs.getPath("/work"));
+    assertThat(Iterables.getOnlyElement(fs.getFileStores()).getTotalSpace())
+        .isEqualTo(4L * 1024 * 1024 * 1024);
+    assertThat(fs.supportedFileAttributeViews()).containsExactly("basic");
+
+    Files.createFile(fs.getPath("/foo"));
+
+    try {
+      Files.createFile(fs.getPath("/FOO"));
+      fail();
+    } catch (FileAlreadyExistsException expected) {
+    }
+  }
+
+  @Test
+  public void testDefaultWindowsConfiguration() {
+    Configuration config = Configuration.windows();
+
+    assertThat(config.pathType).isEqualTo(PathType.windows());
+    assertThat(config.roots).containsExactly("C:\\");
+    assertThat(config.workingDirectory).isEqualTo("C:\\work");
+    assertThat(config.nameCanonicalNormalization).containsExactly(CASE_FOLD_ASCII);
+    assertThat(config.nameDisplayNormalization).isEmpty();
+    assertThat(config.pathEqualityUsesCanonicalForm).isTrue();
+    assertThat(config.blockSize).isEqualTo(8192);
+    assertThat(config.maxSize).isEqualTo(4L * 1024 * 1024 * 1024);
+    assertThat(config.maxCacheSize).isEqualTo(-1);
+    assertThat(config.attributeViews).containsExactly("basic");
+    assertThat(config.attributeProviders).isEmpty();
+    assertThat(config.defaultAttributeValues).isEmpty();
+  }
+
+  @Test
+  public void testFileSystemForDefaultWindowsConfiguration() throws IOException {
+    FileSystem fs = Jimfs.newFileSystem(Configuration.windows());
+
+    assertThat(fs.getRootDirectories())
+        .containsExactlyElementsIn(ImmutableList.of(fs.getPath("C:\\")))
+        .inOrder();
+    assertThatPath(fs.getPath("").toRealPath()).isEqualTo(fs.getPath("C:\\work"));
+    assertThat(Iterables.getOnlyElement(fs.getFileStores()).getTotalSpace())
+        .isEqualTo(4L * 1024 * 1024 * 1024);
+    assertThat(fs.supportedFileAttributeViews()).containsExactly("basic");
+
+    Files.createFile(fs.getPath("C:\\foo"));
+
+    try {
+      Files.createFile(fs.getPath("C:\\FOO"));
+      fail();
+    } catch (FileAlreadyExistsException expected) {
+    }
+  }
+
+  @Test
+  public void testBuilder() {
+    AttributeProvider unixProvider = StandardAttributeProviders.get("unix");
+
+    Configuration config =
+        Configuration.builder(PathType.unix())
+            .setRoots("/")
+            .setWorkingDirectory("/hello/world")
+            .setNameCanonicalNormalization(NFD, CASE_FOLD_UNICODE)
+            .setNameDisplayNormalization(NFC)
+            .setPathEqualityUsesCanonicalForm(true)
+            .setBlockSize(10)
+            .setMaxSize(100)
+            .setMaxCacheSize(50)
+            .setAttributeViews("basic", "posix")
+            .addAttributeProvider(unixProvider)
+            .setDefaultAttributeValue(
+                "posix:permissions", PosixFilePermissions.fromString("---------"))
+            .build();
+
+    assertThat(config.pathType).isEqualTo(PathType.unix());
+    assertThat(config.roots).containsExactly("/");
+    assertThat(config.workingDirectory).isEqualTo("/hello/world");
+    assertThat(config.nameCanonicalNormalization).containsExactly(NFD, CASE_FOLD_UNICODE);
+    assertThat(config.nameDisplayNormalization).containsExactly(NFC);
+    assertThat(config.pathEqualityUsesCanonicalForm).isTrue();
+    assertThat(config.blockSize).isEqualTo(10);
+    assertThat(config.maxSize).isEqualTo(100);
+    assertThat(config.maxCacheSize).isEqualTo(50);
+    assertThat(config.attributeViews).containsExactly("basic", "posix");
+    assertThat(config.attributeProviders).containsExactly(unixProvider);
+    assertThat(config.defaultAttributeValues)
+        .containsEntry("posix:permissions", PosixFilePermissions.fromString("---------"));
+  }
+
+  @Test
+  public void testFileSystemForCustomConfiguration() throws IOException {
+    Configuration config =
+        Configuration.builder(PathType.unix())
+            .setRoots("/")
+            .setWorkingDirectory("/hello/world")
+            .setNameCanonicalNormalization(NFD, CASE_FOLD_UNICODE)
+            .setNameDisplayNormalization(NFC)
+            .setPathEqualityUsesCanonicalForm(true)
+            .setBlockSize(10)
+            .setMaxSize(100)
+            .setMaxCacheSize(50)
+            .setAttributeViews("unix")
+            .setDefaultAttributeValue(
+                "posix:permissions", PosixFilePermissions.fromString("---------"))
+            .build();
+
+    FileSystem fs = Jimfs.newFileSystem(config);
+
+    assertThat(fs.getRootDirectories())
+        .containsExactlyElementsIn(ImmutableList.of(fs.getPath("/")))
+        .inOrder();
+    assertThatPath(fs.getPath("").toRealPath()).isEqualTo(fs.getPath("/hello/world"));
+    assertThat(Iterables.getOnlyElement(fs.getFileStores()).getTotalSpace()).isEqualTo(100);
+    assertThat(fs.supportedFileAttributeViews()).containsExactly("basic", "owner", "posix", "unix");
+
+    Files.createFile(fs.getPath("/foo"));
+    assertThat(Files.getAttribute(fs.getPath("/foo"), "posix:permissions"))
+        .isEqualTo(PosixFilePermissions.fromString("---------"));
+
+    try {
+      Files.createFile(fs.getPath("/FOO"));
+      fail();
+    } catch (FileAlreadyExistsException expected) {
+    }
+  }
+
+  @Test
+  public void testToBuilder() {
+    Configuration config =
+        Configuration.unix().toBuilder()
+            .setWorkingDirectory("/hello/world")
+            .setAttributeViews("basic", "posix")
+            .build();
+
+    assertThat(config.pathType).isEqualTo(PathType.unix());
+    assertThat(config.roots).containsExactly("/");
+    assertThat(config.workingDirectory).isEqualTo("/hello/world");
+    assertThat(config.nameCanonicalNormalization).isEmpty();
+    assertThat(config.nameDisplayNormalization).isEmpty();
+    assertThat(config.pathEqualityUsesCanonicalForm).isFalse();
+    assertThat(config.blockSize).isEqualTo(8192);
+    assertThat(config.maxSize).isEqualTo(4L * 1024 * 1024 * 1024);
+    assertThat(config.maxCacheSize).isEqualTo(-1);
+    assertThat(config.attributeViews).containsExactly("basic", "posix");
+    assertThat(config.attributeProviders).isEmpty();
+    assertThat(config.defaultAttributeValues).isEmpty();
+  }
+
+  @Test
+  public void testSettingRootsUnsupportedByPathType() {
+    assertIllegalRoots(PathType.unix(), "\\");
+    assertIllegalRoots(PathType.unix(), "/", "\\");
+    assertIllegalRoots(PathType.windows(), "/");
+    assertIllegalRoots(PathType.windows(), "C:"); // must have a \ (or a /)
+  }
+
+  private static void assertIllegalRoots(PathType type, String first, String... more) {
+    try {
+      Configuration.builder(type).setRoots(first, more); // wrong root
+      fail();
+    } catch (IllegalArgumentException expected) {
+    }
+  }
+
+  @Test
+  public void testSettingWorkingDirectoryWithRelativePath() {
+    try {
+      Configuration.unix().toBuilder().setWorkingDirectory("foo/bar");
+      fail();
+    } catch (IllegalArgumentException expected) {
+    }
+
+    try {
+      Configuration.windows().toBuilder().setWorkingDirectory("foo\\bar");
+      fail();
+    } catch (IllegalArgumentException expected) {
+    }
+  }
+
+  @Test
+  public void testSettingNormalizationWhenNormalizationAlreadySet() {
+    assertIllegalNormalizations(NFC, NFC);
+    assertIllegalNormalizations(NFC, NFD);
+    assertIllegalNormalizations(CASE_FOLD_ASCII, CASE_FOLD_ASCII);
+    assertIllegalNormalizations(CASE_FOLD_ASCII, CASE_FOLD_UNICODE);
+  }
+
+  private static void assertIllegalNormalizations(
+      PathNormalization first, PathNormalization... more) {
+    try {
+      Configuration.builder(PathType.unix()).setNameCanonicalNormalization(first, more);
+      fail();
+    } catch (IllegalArgumentException expected) {
+    }
+
+    try {
+      Configuration.builder(PathType.unix()).setNameDisplayNormalization(first, more);
+      fail();
+    } catch (IllegalArgumentException expected) {
+    }
+  }
+
+  @Test
+  public void testSetDefaultAttributeValue_illegalAttributeFormat() {
+    try {
+      Configuration.unix().toBuilder().setDefaultAttributeValue("foo", 1);
+      fail();
+    } catch (IllegalArgumentException expected) {
+    }
+  }
+
+  @Test // how's that for a name?
+  public void testCreateFileSystemFromConfigurationWithWorkingDirectoryNotUnderConfiguredRoot() {
+    try {
+      Jimfs.newFileSystem(
+          Configuration.windows().toBuilder()
+              .setRoots("C:\\", "D:\\")
+              .setWorkingDirectory("E:\\foo")
+              .build());
+      fail();
+    } catch (IllegalArgumentException expected) {
+    }
+  }
+
+  @Test
+  public void testFileSystemWithDefaultWatchService() throws IOException {
+    FileSystem fs = Jimfs.newFileSystem(Configuration.unix());
+
+    WatchService watchService = fs.newWatchService();
+    assertThat(watchService).isInstanceOf(PollingWatchService.class);
+
+    PollingWatchService pollingWatchService = (PollingWatchService) watchService;
+    assertThat(pollingWatchService.interval).isEqualTo(5);
+    assertThat(pollingWatchService.timeUnit).isEqualTo(SECONDS);
+  }
+
+  @Test
+  public void testFileSystemWithCustomWatchServicePollingInterval() throws IOException {
+    FileSystem fs =
+        Jimfs.newFileSystem(
+            Configuration.unix().toBuilder()
+                .setWatchServiceConfiguration(polling(10, MILLISECONDS))
+                .build());
+
+    WatchService watchService = fs.newWatchService();
+    assertThat(watchService).isInstanceOf(PollingWatchService.class);
+
+    PollingWatchService pollingWatchService = (PollingWatchService) watchService;
+    assertThat(pollingWatchService.interval).isEqualTo(10);
+    assertThat(pollingWatchService.timeUnit).isEqualTo(MILLISECONDS);
+  }
+}