1 files changed, 233 insertions, 0 deletions
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/ZipFileSystemTest.java b/src/test/java/com/google/devtools/build/lib/vfs/ZipFileSystemTest.java
new file mode 100644
index 0000000000..9dc12764ae
--- /dev/null
+++ b/src/test/java/com/google/devtools/build/lib/vfs/ZipFileSystemTest.java
@@ -0,0 +1,233 @@
+// Copyright 2014 Google Inc. All rights reserved.
+//
+// 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.devtools.build.lib.vfs;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.Lists;
+import com.google.common.io.CharStreams;
+import com.google.devtools.build.lib.testutil.BlazeTestUtils;
+import com.google.devtools.build.lib.testutil.TestConstants;
+import com.google.devtools.build.lib.vfs.util.FileSystems;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+@RunWith(JUnit4.class)
+public class ZipFileSystemTest {
+
+  /**
+   * Expected listing of sample zip files, in alpha sorted order
+   */
+  private static final String[] LISTING = {
+    "/dir1",
+    "/dir1/file1a",
+    "/dir1/file1b",
+    "/dir2",
+    "/dir2/dir3",
+    "/dir2/dir3/dir4",
+    "/dir2/dir3/dir4/file4",
+    "/dir2/file2",
+    "/file0",
+  };
+
+  private FileSystem zipFS1;
+  private FileSystem zipFS2;
+
+  @Before
+  public void setUp() throws Exception {
+    FileSystem unixFs = FileSystems.initDefaultAsNative();
+    Path testdataDir = unixFs.getPath(BlazeTestUtils.runfilesDir()).getRelative(
+        TestConstants.JAVATESTS_ROOT + "/com/google/devtools/build/lib/vfs");
+    Path zPath1 = testdataDir.getChild("sample_with_dirs.zip");
+    Path zPath2 = testdataDir.getChild("sample_without_dirs.zip");
+    zipFS1 = new ZipFileSystem(zPath1);
+    zipFS2 = new ZipFileSystem(zPath2);
+  }
+
+  private void checkExists(FileSystem fs) {
+    assertTrue(fs.getPath("/dir2/dir3/dir4").exists());
+    assertTrue(fs.getPath("/dir2/dir3/dir4/file4").exists());
+    assertFalse(fs.getPath("/dir2/dir3/dir4/bogus").exists());
+  }
+
+  @Test
+  public void testExists() {
+    checkExists(zipFS1);
+    checkExists(zipFS2);
+  }
+
+  private void checkIsFile(FileSystem fs) {
+    assertFalse(fs.getPath("/dir2/dir3/dir4").isFile());
+    assertTrue(fs.getPath("/dir2/dir3/dir4/file4").isFile());
+    assertFalse(fs.getPath("/dir2/dir3/dir4/bogus").isFile());
+  }
+
+  @Test
+  public void testIsFile() {
+    checkIsFile(zipFS1);
+    checkIsFile(zipFS2);
+  }
+
+  private void checkIsDir(FileSystem fs) {
+    assertTrue(fs.getPath("/dir2/dir3/dir4").isDirectory());
+    assertFalse(fs.getPath("/dir2/dir3/dir4/file4").isDirectory());
+    assertFalse(fs.getPath("/bogus/mobogus").isDirectory());
+    assertFalse(fs.getPath("/bogus").isDirectory());
+  }
+
+  @Test
+  public void testIsDir() {
+    checkIsDir(zipFS1);
+    checkIsDir(zipFS2);
+  }
+
+  /**
+   * Recursively add the contents of a given path, rendered as strings, into a
+   * given list.
+   */
+  private static void listChildren(Path p, List<String> list)
+      throws IOException {
+    for (Path c : p.getDirectoryEntries()) {
+      list.add(c.getPathString());
+      if (c.isDirectory()) {
+        listChildren(c, list);
+      }
+    }
+  }
+
+  private void checkListing(FileSystem fs) throws Exception {
+    List<String> list = new ArrayList<>();
+    listChildren(fs.getRootDirectory(), list);
+    Collections.sort(list);
+    assertEquals(Lists.newArrayList(LISTING), list);
+  }
+
+  @Test
+  public void testListing() throws Exception {
+    checkListing(zipFS1);
+    checkListing(zipFS2);
+
+    // Regression test for: creation of a path (i.e. a file *name*)
+    // must not affect the result of getDirectoryEntries().
+    zipFS1.getPath("/dir1/notthere");
+    checkListing(zipFS1);
+  }
+
+  private void checkFileSize(FileSystem fs, String name, long expectedSize)
+      throws IOException {
+    assertEquals(expectedSize, fs.getPath(name).getFileSize());
+  }
+
+  @Test
+  public void testCanReadRoot() {
+    Path rootDirectory = zipFS1.getRootDirectory();
+    assertTrue(rootDirectory.isDirectory());
+  }
+
+  @Test
+  public void testFileSize() throws IOException {
+    checkFileSize(zipFS1, "/dir1/file1a", 5);
+    checkFileSize(zipFS2, "/dir1/file1a", 5);
+    checkFileSize(zipFS1, "/dir2/dir3/dir4/file4", 5000);
+    checkFileSize(zipFS2, "/dir2/dir3/dir4/file4", 5000);
+  }
+
+  private void checkCantGetFileSize(FileSystem fs, String name) {
+    try {
+      fs.getPath(name).getFileSize();
+      fail();
+    } catch (IOException expected) {
+      // expected
+    }
+  }
+
+  @Test
+  public void testCantGetFileSize() {
+    checkCantGetFileSize(zipFS1, "/dir2/dir3/dir4/bogus");
+    checkCantGetFileSize(zipFS2, "/dir2/dir3/dir4/bogus");
+  }
+
+  private void checkOpenFile(FileSystem fs, String name, int expectedSize)
+      throws Exception {
+    InputStream is = fs.getPath(name).getInputStream();
+    List<String> lines = CharStreams.readLines(new InputStreamReader(is, "ISO-8859-1"));
+    assertEquals(expectedSize, lines.size());
+    for (int i = 0; i < expectedSize; i++) {
+      assertEquals("body", lines.get(i));
+    }
+  }
+
+  @Test
+  public void testOpenSmallFile() throws Exception {
+    checkOpenFile(zipFS1, "/dir1/file1a", 1);
+    checkOpenFile(zipFS2, "/dir1/file1a", 1);
+  }
+
+  @Test
+  public void testOpenBigFile() throws Exception {
+    checkOpenFile(zipFS1, "/dir2/dir3/dir4/file4", 1000);
+    checkOpenFile(zipFS2, "/dir2/dir3/dir4/file4", 1000);
+  }
+
+  private void checkCantOpenFile(FileSystem fs, String name) {
+    try {
+      fs.getPath(name).getInputStream();
+      fail();
+    } catch (IOException expected) {
+      // expected
+    }
+  }
+
+  @Test
+  public void testCantOpenFile() throws Exception {
+    checkCantOpenFile(zipFS1, "/dir2/dir3/dir4/bogus");
+    checkCantOpenFile(zipFS2, "/dir2/dir3/dir4/bogus");
+  }
+
+  private void checkCantCreateAnything(FileSystem fs, String name)  {
+    Path p = fs.getPath(name);
+    try {
+      p.createDirectory();
+      fail();
+    } catch (Exception expected) {}
+    try {
+      FileSystemUtils.createEmptyFile(p);
+      fail();
+    } catch (Exception expected) {}
+    try {
+      p.createSymbolicLink(p);
+      fail();
+    } catch (Exception expected) {}
+  }
+
+  @Test
+  public void testCantCreateAnything() throws Exception {
+    checkCantCreateAnything(zipFS1, "/dir2/dir3/dir4/new");
+    checkCantCreateAnything(zipFS2, "/dir2/dir3/dir4/new");
+  }
+
+}