blob: 2b1d57bf81c83fe73ed92bef06f31e54e82a734d [file] [log] [blame]
// Copyright 2014 The Bazel Authors. 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 com.google.common.truth.Truth.assertThat;
import static com.google.devtools.build.lib.vfs.FileSystemUtils.appendWithoutExtension;
import static com.google.devtools.build.lib.vfs.FileSystemUtils.commonAncestor;
import static com.google.devtools.build.lib.vfs.FileSystemUtils.copyFile;
import static com.google.devtools.build.lib.vfs.FileSystemUtils.copyTool;
import static com.google.devtools.build.lib.vfs.FileSystemUtils.moveFile;
import static com.google.devtools.build.lib.vfs.FileSystemUtils.relativePath;
import static com.google.devtools.build.lib.vfs.FileSystemUtils.removeExtension;
import static com.google.devtools.build.lib.vfs.FileSystemUtils.touchFile;
import static com.google.devtools.build.lib.vfs.FileSystemUtils.traverseTree;
import static java.nio.charset.StandardCharsets.ISO_8859_1;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.fail;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.google.common.collect.Lists;
import com.google.devtools.build.lib.testutil.BlazeTestUtils;
import com.google.devtools.build.lib.testutil.ManualClock;
import com.google.devtools.build.lib.vfs.FileSystemUtils.MoveResult;
import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Collection;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
/**
* This class tests the file system utilities.
*/
@RunWith(JUnit4.class)
public class FileSystemUtilsTest {
private ManualClock clock;
private FileSystem fileSystem;
private Path workingDir;
@Before
public final void initializeFileSystem() throws Exception {
clock = new ManualClock();
fileSystem = new InMemoryFileSystem(clock);
workingDir = fileSystem.getPath("/workingDir");
workingDir.createDirectory();
}
Path topDir;
Path file1;
Path file2;
Path aDir;
Path bDir;
Path file3;
Path innerDir;
Path link1;
Path dirLink;
Path file4;
Path file5;
/*
* Build a directory tree that looks like:
* top-dir/
* file-1
* file-2
* a-dir/
* file-3
* inner-dir/
* link-1 => file-4
* dir-link => b-dir
* file-4
*/
private void createTestDirectoryTree() throws IOException {
topDir = fileSystem.getPath("/top-dir");
file1 = fileSystem.getPath("/top-dir/file-1");
file2 = fileSystem.getPath("/top-dir/file-2");
aDir = fileSystem.getPath("/top-dir/a-dir");
bDir = fileSystem.getPath("/top-dir/b-dir");
file3 = fileSystem.getPath("/top-dir/a-dir/file-3");
innerDir = fileSystem.getPath("/top-dir/a-dir/inner-dir");
link1 = fileSystem.getPath("/top-dir/a-dir/inner-dir/link-1");
dirLink = fileSystem.getPath("/top-dir/a-dir/inner-dir/dir-link");
file4 = fileSystem.getPath("/file-4");
file5 = fileSystem.getPath("/top-dir/b-dir/file-5");
topDir.createDirectory();
FileSystemUtils.createEmptyFile(file1);
FileSystemUtils.createEmptyFile(file2);
aDir.createDirectory();
bDir.createDirectory();
FileSystemUtils.createEmptyFile(file3);
innerDir.createDirectory();
link1.createSymbolicLink(file4); // simple symlink
dirLink.createSymbolicLink(bDir);
FileSystemUtils.createEmptyFile(file4);
FileSystemUtils.createEmptyFile(file5);
}
private Path checkTestDirectoryTreesBelowExceptSymlinks(Path toPath) throws IOException {
Path copiedFile1 = toPath.getChild("file-1");
assertThat(copiedFile1.exists()).isTrue();
assertThat(copiedFile1.isFile()).isTrue();
Path copiedFile2 = toPath.getChild("file-2");
assertThat(copiedFile2.exists()).isTrue();
assertThat(copiedFile2.isFile()).isTrue();
Path copiedADir = toPath.getChild("a-dir");
assertThat(copiedADir.exists()).isTrue();
assertThat(copiedADir.isDirectory()).isTrue();
Collection<Path> aDirEntries = copiedADir.getDirectoryEntries();
assertThat(aDirEntries).hasSize(2);
Path copiedFile3 = copiedADir.getChild("file-3");
assertThat(copiedFile3.exists()).isTrue();
assertThat(copiedFile3.isFile()).isTrue();
Path copiedInnerDir = copiedADir.getChild("inner-dir");
assertThat(copiedInnerDir.exists()).isTrue();
assertThat(copiedInnerDir.isDirectory()).isTrue();
return copiedInnerDir;
}
private void checkTestDirectoryTreesBelow(Path toPath) throws IOException {
Path copiedInnerDir = checkTestDirectoryTreesBelowExceptSymlinks(toPath);
Path copiedLink1 = copiedInnerDir.getChild("link-1");
assertThat(copiedLink1.exists()).isTrue();
assertThat(copiedLink1.isSymbolicLink()).isFalse();
Path copiedDirLink = copiedInnerDir.getChild("dir-link");
assertThat(copiedDirLink.exists()).isTrue();
assertThat(copiedDirLink.isDirectory()).isTrue();
assertThat(copiedDirLink.getChild("file-5").exists()).isTrue();
}
// tests
@Test
public void testChangeModtime() throws IOException {
Path file = fileSystem.getPath("/my-file");
try {
BlazeTestUtils.changeModtime(file);
fail();
} catch (FileNotFoundException e) {
/* ok */
}
FileSystemUtils.createEmptyFile(file);
long prevMtime = file.getLastModifiedTime();
BlazeTestUtils.changeModtime(file);
assertThat(prevMtime == file.getLastModifiedTime()).isFalse();
}
@Test
public void testCommonAncestor() {
assertThat(commonAncestor(topDir, topDir)).isEqualTo(topDir);
assertThat(commonAncestor(file1, file3)).isEqualTo(topDir);
assertThat(commonAncestor(file1, dirLink)).isEqualTo(topDir);
}
@Test
public void testRelativePath() throws IOException {
createTestDirectoryTree();
assertThat(
relativePath(PathFragment.create("/top-dir"), PathFragment.create("/top-dir/file-1"))
.getPathString())
.isEqualTo("file-1");
assertThat(
relativePath(PathFragment.create("/top-dir"), PathFragment.create("/top-dir"))
.getPathString())
.isEqualTo("");
assertThat(
relativePath(
PathFragment.create("/top-dir"),
PathFragment.create("/top-dir/a-dir/inner-dir/dir-link"))
.getPathString())
.isEqualTo("a-dir/inner-dir/dir-link");
assertThat(
relativePath(PathFragment.create("/top-dir"), PathFragment.create("/file-4"))
.getPathString())
.isEqualTo("../file-4");
assertThat(
relativePath(
PathFragment.create("/top-dir/a-dir/inner-dir"), PathFragment.create("/file-4"))
.getPathString())
.isEqualTo("../../../file-4");
}
@Test
public void testRemoveExtension_Strings() throws Exception {
assertThat(removeExtension("foo.c")).isEqualTo("foo");
assertThat(removeExtension("a/foo.c")).isEqualTo("a/foo");
assertThat(removeExtension("a.b/foo")).isEqualTo("a.b/foo");
assertThat(removeExtension("foo")).isEqualTo("foo");
assertThat(removeExtension("foo.")).isEqualTo("foo");
}
@Test
public void testRemoveExtension_Paths() throws Exception {
assertPath("/foo", removeExtension(fileSystem.getPath("/foo.c")));
assertPath("/a/foo", removeExtension(fileSystem.getPath("/a/foo.c")));
assertPath("/a.b/foo", removeExtension(fileSystem.getPath("/a.b/foo")));
assertPath("/foo", removeExtension(fileSystem.getPath("/foo")));
assertPath("/foo", removeExtension(fileSystem.getPath("/foo.")));
}
private static void assertPath(String expected, PathFragment actual) {
assertThat(actual.getPathString()).isEqualTo(expected);
}
private static void assertPath(String expected, Path actual) {
assertThat(actual.getPathString()).isEqualTo(expected);
}
@Test
public void testReplaceExtension_Path() throws Exception {
assertPath("/foo/bar.baz",
FileSystemUtils.replaceExtension(fileSystem.getPath("/foo/bar"), ".baz"));
assertPath("/foo/bar.baz",
FileSystemUtils.replaceExtension(fileSystem.getPath("/foo/bar.cc"), ".baz"));
assertPath("/foo.baz", FileSystemUtils.replaceExtension(fileSystem.getPath("/foo/"), ".baz"));
assertPath("/foo.baz",
FileSystemUtils.replaceExtension(fileSystem.getPath("/foo.cc/"), ".baz"));
assertPath("/foo.baz", FileSystemUtils.replaceExtension(fileSystem.getPath("/foo"), ".baz"));
assertPath("/foo.baz", FileSystemUtils.replaceExtension(fileSystem.getPath("/foo.cc"), ".baz"));
assertPath("/.baz", FileSystemUtils.replaceExtension(fileSystem.getPath("/.cc"), ".baz"));
assertThat(FileSystemUtils.replaceExtension(fileSystem.getPath("/"), ".baz")).isNull();
}
@Test
public void testReplaceExtension_PathFragment() throws Exception {
assertPath("foo/bar.baz",
FileSystemUtils.replaceExtension(PathFragment.create("foo/bar"), ".baz"));
assertPath("foo/bar.baz",
FileSystemUtils.replaceExtension(PathFragment.create("foo/bar.cc"), ".baz"));
assertPath("/foo/bar.baz",
FileSystemUtils.replaceExtension(PathFragment.create("/foo/bar"), ".baz"));
assertPath("/foo/bar.baz",
FileSystemUtils.replaceExtension(PathFragment.create("/foo/bar.cc"), ".baz"));
assertPath("foo.baz", FileSystemUtils.replaceExtension(PathFragment.create("foo/"), ".baz"));
assertPath("foo.baz", FileSystemUtils.replaceExtension(PathFragment.create("foo.cc/"), ".baz"));
assertPath("/foo.baz", FileSystemUtils.replaceExtension(PathFragment.create("/foo/"), ".baz"));
assertPath("/foo.baz",
FileSystemUtils.replaceExtension(PathFragment.create("/foo.cc/"), ".baz"));
assertPath("foo.baz", FileSystemUtils.replaceExtension(PathFragment.create("foo"), ".baz"));
assertPath("foo.baz", FileSystemUtils.replaceExtension(PathFragment.create("foo.cc"), ".baz"));
assertPath("/foo.baz", FileSystemUtils.replaceExtension(PathFragment.create("/foo"), ".baz"));
assertPath("/foo.baz",
FileSystemUtils.replaceExtension(PathFragment.create("/foo.cc"), ".baz"));
assertPath(".baz", FileSystemUtils.replaceExtension(PathFragment.create(".cc"), ".baz"));
assertThat(FileSystemUtils.replaceExtension(PathFragment.create("/"), ".baz")).isNull();
assertThat(FileSystemUtils.replaceExtension(PathFragment.create(""), ".baz")).isNull();
assertPath("foo/bar.baz",
FileSystemUtils.replaceExtension(PathFragment.create("foo/bar.pony"), ".baz", ".pony"));
assertPath("foo/bar.baz",
FileSystemUtils.replaceExtension(PathFragment.create("foo/bar"), ".baz", ""));
assertThat(FileSystemUtils.replaceExtension(PathFragment.create(""), ".baz", ".pony")).isNull();
assertThat(
FileSystemUtils.replaceExtension(
PathFragment.create("foo/bar.pony"), ".baz", ".unicorn"))
.isNull();
}
@Test
public void testAppendWithoutExtension() throws Exception {
assertPath("libfoo-src.jar",
appendWithoutExtension(PathFragment.create("libfoo.jar"), "-src"));
assertPath("foo/libfoo-src.jar",
appendWithoutExtension(PathFragment.create("foo/libfoo.jar"), "-src"));
assertPath("java/com/google/foo/libfoo-src.jar",
appendWithoutExtension(PathFragment.create("java/com/google/foo/libfoo.jar"), "-src"));
assertPath("libfoo.bar-src.jar",
appendWithoutExtension(PathFragment.create("libfoo.bar.jar"), "-src"));
assertPath("libfoo-src",
appendWithoutExtension(PathFragment.create("libfoo"), "-src"));
assertPath("libfoo-src.jar",
appendWithoutExtension(PathFragment.create("libfoo.jar/"), "-src"));
assertPath("libfoo.src.jar",
appendWithoutExtension(PathFragment.create("libfoo.jar"), ".src"));
assertThat(appendWithoutExtension(PathFragment.create("/"), "-src")).isNull();
assertThat(appendWithoutExtension(PathFragment.create(""), "-src")).isNull();
}
@Test
public void testGetWorkingDirectory() {
String userDir = System.getProperty("user.dir");
assertThat(fileSystem.getPath(System.getProperty("user.dir", "/")))
.isEqualTo(FileSystemUtils.getWorkingDirectory(fileSystem));
System.setProperty("user.dir", "/blah/blah/blah");
assertThat(fileSystem.getPath("/blah/blah/blah"))
.isEqualTo(FileSystemUtils.getWorkingDirectory(fileSystem));
System.setProperty("user.dir", userDir);
}
@Test
public void testResolveRelativeToFilesystemWorkingDir() {
PathFragment relativePath = PathFragment.create("relative/path");
assertThat(workingDir.getRelative(relativePath))
.isEqualTo(workingDir.getRelative(relativePath));
PathFragment absolutePath = PathFragment.create("/absolute/path");
assertThat(workingDir.getRelative(absolutePath)).isEqualTo(fileSystem.getPath(absolutePath));
}
@Test
public void testTouchFileCreatesFile() throws IOException {
createTestDirectoryTree();
Path nonExistingFile = fileSystem.getPath("/previously-non-existing");
assertThat(nonExistingFile.exists()).isFalse();
touchFile(nonExistingFile);
assertThat(nonExistingFile.exists()).isTrue();
}
@Test
public void testTouchFileAdjustsFileTime() throws IOException {
createTestDirectoryTree();
Path testFile = file4;
long oldTime = testFile.getLastModifiedTime();
testFile.setLastModifiedTime(42);
touchFile(testFile);
assertThat(testFile.getLastModifiedTime()).isAtLeast(oldTime);
}
@Test
public void testCopyFile() throws IOException {
createTestDirectoryTree();
Path originalFile = file1;
byte[] content = new byte[] { 'a', 'b', 'c', 23, 42 };
FileSystemUtils.writeContent(originalFile, content);
Path copyTarget = file2;
copyFile(originalFile, copyTarget);
assertThat(FileSystemUtils.readContent(copyTarget)).isEqualTo(content);
}
@Test
public void testMoveFile() throws IOException {
createTestDirectoryTree();
Path originalFile = file1;
byte[] content = new byte[] { 'a', 'b', 'c', 23, 42 };
FileSystemUtils.writeContent(originalFile, content);
Path moveTarget = file2;
assertThat(moveFile(originalFile, moveTarget)).isEqualTo(MoveResult.FILE_MOVED);
assertThat(FileSystemUtils.readContent(moveTarget)).isEqualTo(content);
assertThat(originalFile.exists()).isFalse();
}
@Test
public void testMoveFileAcrossDevices() throws Exception {
class MultipleDeviceFS extends InMemoryFileSystem {
@Override
public void renameTo(Path source, Path target) throws IOException {
if (!source.startsWith(target.asFragment().subFragment(0, 1))) {
throw new IOException("EXDEV");
}
super.renameTo(source, target);
}
}
FileSystem fs = new MultipleDeviceFS();
Path dev1 = fs.getPath("/fs1");
dev1.createDirectory();
Path dev2 = fs.getPath("/fs2");
dev2.createDirectory();
Path source = dev1.getChild("source");
Path target = dev2.getChild("target");
FileSystemUtils.writeContent(source, UTF_8, "hello, world");
source.setLastModifiedTime(142);
assertThat(FileSystemUtils.moveFile(source, target)).isEqualTo(MoveResult.FILE_COPIED);
assertThat(source.exists(Symlinks.NOFOLLOW)).isFalse();
assertThat(target.isFile(Symlinks.NOFOLLOW)).isTrue();
assertThat(FileSystemUtils.readContent(target, UTF_8)).isEqualTo("hello, world");
assertThat(target.getLastModifiedTime()).isEqualTo(142);
source.createSymbolicLink(PathFragment.create("link-target"));
assertThat(FileSystemUtils.moveFile(source, target)).isEqualTo(MoveResult.FILE_COPIED);
assertThat(source.exists(Symlinks.NOFOLLOW)).isFalse();
assertThat(target.isSymbolicLink()).isTrue();
assertThat(target.readSymbolicLink()).isEqualTo(PathFragment.create("link-target"));
}
@Test
public void testReadContentWithLimit() throws IOException {
createTestDirectoryTree();
String str = "this is a test of readContentWithLimit method";
FileSystemUtils.writeContent(file1, StandardCharsets.ISO_8859_1, str);
assertThat(readStringFromFile(file1, 0)).isEmpty();
assertThat(str.substring(0, 10)).isEqualTo(readStringFromFile(file1, 10));
assertThat(str).isEqualTo(readStringFromFile(file1, 1000000));
}
private String readStringFromFile(Path file, int limit) throws IOException {
byte[] bytes = FileSystemUtils.readContentWithLimit(file, limit);
return new String(bytes, StandardCharsets.ISO_8859_1);
}
@Test
public void testAppend() throws IOException {
createTestDirectoryTree();
FileSystemUtils.writeIsoLatin1(file1, "nobody says ");
FileSystemUtils.writeIsoLatin1(file1, "mary had");
FileSystemUtils.appendIsoLatin1(file1, "a little lamb");
assertThat(new String(FileSystemUtils.readContentAsLatin1(file1)))
.isEqualTo("mary had\na little lamb\n");
}
@Test
public void testCopyFileAttributes() throws IOException {
createTestDirectoryTree();
Path originalFile = file1;
byte[] content = new byte[] { 'a', 'b', 'c', 23, 42 };
FileSystemUtils.writeContent(originalFile, content);
file1.setLastModifiedTime(12345L);
file1.setWritable(false);
file1.setExecutable(false);
Path copyTarget = file2;
copyFile(originalFile, copyTarget);
assertThat(file2.getLastModifiedTime()).isEqualTo(12345L);
assertThat(file2.isExecutable()).isFalse();
assertThat(file2.isWritable()).isFalse();
file1.setWritable(true);
file1.setExecutable(true);
copyFile(originalFile, copyTarget);
assertThat(file2.getLastModifiedTime()).isEqualTo(12345L);
assertThat(file2.isExecutable()).isTrue();
assertThat(file2.isWritable()).isTrue();
}
@Test
public void testCopyFileThrowsExceptionIfTargetCantBeDeleted() throws IOException {
createTestDirectoryTree();
Path originalFile = file1;
byte[] content = new byte[] { 'a', 'b', 'c', 23, 42 };
FileSystemUtils.writeContent(originalFile, content);
try {
copyFile(originalFile, aDir);
fail();
} catch (IOException ex) {
assertThat(ex)
.hasMessageThat()
.isEqualTo(
"error copying file: couldn't delete destination: "
+ aDir
+ " (Directory not empty)");
}
}
@Test
public void testCopyTool() throws IOException {
createTestDirectoryTree();
Path originalFile = file1;
byte[] content = new byte[] { 'a', 'b', 'c', 23, 42 };
FileSystemUtils.writeContent(originalFile, content);
Path copyTarget = copyTool(topDir.getRelative("file-1"), aDir.getRelative("file-1"));
assertThat(FileSystemUtils.readContent(copyTarget)).isEqualTo(content);
assertThat(copyTarget.isWritable()).isEqualTo(file1.isWritable());
assertThat(copyTarget.isExecutable()).isEqualTo(file1.isExecutable());
assertThat(copyTarget.getLastModifiedTime()).isEqualTo(file1.getLastModifiedTime());
}
@Test
public void testCopyTreesBelow() throws IOException {
createTestDirectoryTree();
Path toPath = fileSystem.getPath("/copy-here");
toPath.createDirectory();
FileSystemUtils.copyTreesBelow(topDir, toPath, Symlinks.FOLLOW);
checkTestDirectoryTreesBelow(toPath);
}
@Test
public void testCopyTreesBelowWithOverriding() throws IOException {
createTestDirectoryTree();
Path toPath = fileSystem.getPath("/copy-here");
toPath.createDirectory();
toPath.getChild("file-2");
FileSystemUtils.copyTreesBelow(topDir, toPath, Symlinks.FOLLOW);
checkTestDirectoryTreesBelow(toPath);
}
@Test
public void testCopyTreesBelowToSubtree() throws IOException {
createTestDirectoryTree();
try {
FileSystemUtils.copyTreesBelow(topDir, aDir, Symlinks.FOLLOW);
fail("Should not be able to copy a directory to a subdir");
} catch (IllegalArgumentException expected) {
assertThat(expected)
.hasMessageThat()
.isEqualTo("/top-dir/a-dir is a subdirectory of /top-dir");
}
}
@Test
public void testCopyFileAsDirectoryTree() throws IOException {
createTestDirectoryTree();
try {
FileSystemUtils.copyTreesBelow(file1, aDir, Symlinks.FOLLOW);
fail("Should not be able to copy a file with copyDirectory method");
} catch (IOException expected) {
assertThat(expected).hasMessageThat().isEqualTo("/top-dir/file-1 (Not a directory)");
}
}
@Test
public void testCopyTreesBelowToFile() throws IOException {
createTestDirectoryTree();
Path copyDir = fileSystem.getPath("/my-dir");
Path copySubDir = fileSystem.getPath("/my-dir/subdir");
FileSystemUtils.createDirectoryAndParents(copySubDir);
try {
FileSystemUtils.copyTreesBelow(copyDir, file4, Symlinks.FOLLOW);
fail("Should not be able to copy a directory to a file");
} catch (IOException expected) {
assertThat(expected).hasMessageThat().isEqualTo("/file-4 (Not a directory)");
}
}
@Test
public void testCopyTreesBelowFromUnexistingDir() throws IOException {
createTestDirectoryTree();
try {
Path unexistingDir = fileSystem.getPath("/unexisting-dir");
FileSystemUtils.copyTreesBelow(unexistingDir, aDir, Symlinks.FOLLOW);
fail("Should not be able to copy from an unexisting path");
} catch (FileNotFoundException expected) {
assertThat(expected)
.hasMessageThat()
.isEqualTo("/unexisting-dir (No such file or directory)");
}
}
@Test
public void testCopyTreesBelowNoFollowSymlinks() throws IOException {
createTestDirectoryTree();
PathFragment relative1 = file1.relativeTo(topDir);
topDir.getRelative("relative-link").createSymbolicLink(relative1);
PathFragment relativeInner = PathFragment.create("..").getRelative(relative1);
bDir.getRelative("relative-inner-link").createSymbolicLink(relativeInner);
PathFragment rootDirectory = PathFragment.create("/");
topDir.getRelative("absolute-link").createSymbolicLink(rootDirectory);
Path toPath = fileSystem.getPath("/copy-here");
toPath.createDirectory();
FileSystemUtils.copyTreesBelow(topDir, toPath, Symlinks.NOFOLLOW);
Path copiedInnerDir = checkTestDirectoryTreesBelowExceptSymlinks(toPath);
Path copiedLink1 = copiedInnerDir.getChild("link-1");
assertThat(copiedLink1.exists()).isTrue();
assertThat(copiedLink1.isSymbolicLink()).isTrue();
assertThat(copiedLink1.readSymbolicLink()).isEqualTo(file4.asFragment());
Path copiedDirLink = copiedInnerDir.getChild("dir-link");
assertThat(copiedDirLink.exists()).isTrue();
assertThat(copiedDirLink.isDirectory()).isTrue();
assertThat(copiedDirLink.readSymbolicLink()).isEqualTo(bDir.asFragment());
assertThat(toPath.getRelative("relative-link").readSymbolicLink()).isEqualTo(relative1);
assertThat(
toPath
.getRelative(bDir.relativeTo(topDir))
.getRelative("relative-inner-link")
.readSymbolicLink())
.isEqualTo(relativeInner);
assertThat(toPath.getRelative("absolute-link").readSymbolicLink()).isEqualTo(rootDirectory);
}
@Test
public void testTraverseTree() throws IOException {
createTestDirectoryTree();
Collection<Path> paths = traverseTree(topDir, new Predicate<Path>() {
@Override
public boolean apply(Path p) {
return !p.getPathString().contains("a-dir");
}
});
assertThat(paths).containsExactly(file1, file2, bDir, file5);
}
@Test
public void testTraverseTreeDeep() throws IOException {
createTestDirectoryTree();
Collection<Path> paths = traverseTree(topDir,
Predicates.alwaysTrue());
assertThat(paths).containsExactly(aDir,
file3,
innerDir,
link1,
file1,
file2,
dirLink,
bDir,
file5);
}
@Test
public void testTraverseTreeLinkDir() throws IOException {
// Use a new little tree for this test:
// top-dir/
// dir-link2 => linked-dir
// linked-dir/
// file
topDir = fileSystem.getPath("/top-dir");
Path dirLink2 = fileSystem.getPath("/top-dir/dir-link2");
Path linkedDir = fileSystem.getPath("/linked-dir");
Path linkedDirFile = fileSystem.getPath("/top-dir/dir-link2/file");
topDir.createDirectory();
linkedDir.createDirectory();
dirLink2.createSymbolicLink(linkedDir); // simple symlink
FileSystemUtils.createEmptyFile(linkedDirFile); // created through the link
// traverseTree doesn't follow links:
Collection<Path> paths = traverseTree(topDir, Predicates.alwaysTrue());
assertThat(paths).containsExactly(dirLink2);
paths = traverseTree(linkedDir, Predicates.alwaysTrue());
assertThat(paths).containsExactly(fileSystem.getPath("/linked-dir/file"));
}
@Test
public void testWriteIsoLatin1() throws Exception {
Path file = fileSystem.getPath("/does/not/exist/yet.txt");
FileSystemUtils.writeIsoLatin1(file, "Line 1", "Line 2", "Line 3");
String expected = "Line 1\nLine 2\nLine 3\n";
String actual = new String(FileSystemUtils.readContentAsLatin1(file));
assertThat(actual).isEqualTo(expected);
}
@Test
public void testWriteLinesAs() throws Exception {
Path file = fileSystem.getPath("/does/not/exist/yet.txt");
FileSystemUtils.writeLinesAs(file, UTF_8, "\u00F6"); // an oe umlaut
byte[] expected = new byte[] {(byte) 0xC3, (byte) 0xB6, 0x0A};//"\u00F6\n";
byte[] actual = FileSystemUtils.readContent(file);
assertThat(actual).isEqualTo(expected);
}
@Test
public void testUpdateContent() throws Exception {
Path file = fileSystem.getPath("/test.txt");
clock.advanceMillis(1000);
byte[] content = new byte[] { 'a', 'b', 'c', 23, 42 };
FileSystemUtils.maybeUpdateContent(file, content);
byte[] actual = FileSystemUtils.readContent(file);
assertThat(actual).isEqualTo(content);
FileStatus stat = file.stat();
assertThat(stat.getLastChangeTime()).isEqualTo(1000);
assertThat(stat.getLastModifiedTime()).isEqualTo(1000);
clock.advanceMillis(1000);
// Update with same contents; should not write anything.
FileSystemUtils.maybeUpdateContent(file, content);
assertThat(actual).isEqualTo(content);
stat = file.stat();
assertThat(stat.getLastChangeTime()).isEqualTo(1000);
assertThat(stat.getLastModifiedTime()).isEqualTo(1000);
clock.advanceMillis(1000);
// Update with different contents; file should be rewritten.
content[0] = 'b';
file.chmod(0400); // Protect the file to ensure we can rewrite it.
FileSystemUtils.maybeUpdateContent(file, content);
actual = FileSystemUtils.readContent(file);
assertThat(actual).isEqualTo(content);
stat = file.stat();
assertThat(stat.getLastChangeTime()).isEqualTo(3000);
assertThat(stat.getLastModifiedTime()).isEqualTo(3000);
}
@Test
public void testGetFileSystem() throws Exception {
Path mountTable = fileSystem.getPath("/proc/mounts");
FileSystemUtils.writeIsoLatin1(mountTable,
"/dev/sda1 / ext2 blah 0 0",
"/dev/mapper/_dev_sda6 /usr/local/google ext3 blah 0 0",
"devshm /dev/shm tmpfs blah 0 0",
"/dev/fuse /fuse/mnt fuse blah 0 0",
"mtvhome22.nfs:/vol/mtvhome22/johndoe /home/johndoe nfs blah 0 0",
"/dev/foo /foo dummy_foo blah 0 0",
"/dev/foobar /foobar dummy_foobar blah 0 0",
"proc proc proc rw,noexec,nosuid,nodev 0 0");
Path path = fileSystem.getPath("/usr/local/google/_blaze");
FileSystemUtils.createDirectoryAndParents(path);
assertThat(FileSystemUtils.getFileSystem(path)).isEqualTo("ext3");
// Should match the root "/"
path = fileSystem.getPath("/usr/local/tmp");
FileSystemUtils.createDirectoryAndParents(path);
assertThat(FileSystemUtils.getFileSystem(path)).isEqualTo("ext2");
// Make sure we don't consider /foobar matches /foo
path = fileSystem.getPath("/foo");
FileSystemUtils.createDirectoryAndParents(path);
assertThat(FileSystemUtils.getFileSystem(path)).isEqualTo("dummy_foo");
path = fileSystem.getPath("/foobar");
FileSystemUtils.createDirectoryAndParents(path);
assertThat(FileSystemUtils.getFileSystem(path)).isEqualTo("dummy_foobar");
path = fileSystem.getPath("/dev/shm/blaze");
FileSystemUtils.createDirectoryAndParents(path);
assertThat(FileSystemUtils.getFileSystem(path)).isEqualTo("tmpfs");
Path fusePath = fileSystem.getPath("/fuse/mnt/tmp");
FileSystemUtils.createDirectoryAndParents(fusePath);
assertThat(FileSystemUtils.getFileSystem(fusePath)).isEqualTo("fuse");
// Create a symlink and make sure it gives the file system of the symlink target.
path = fileSystem.getPath("/usr/local/google/_blaze/out");
path.createSymbolicLink(fusePath);
assertThat(FileSystemUtils.getFileSystem(path)).isEqualTo("fuse");
// Non existent path should return "unknown"
path = fileSystem.getPath("/does/not/exist");
assertThat(FileSystemUtils.getFileSystem(path)).isEqualTo("unknown");
}
@Test
public void testStartsWithAnySuccess() throws Exception {
PathFragment a = PathFragment.create("a");
assertThat(
FileSystemUtils.startsWithAny(
a, Arrays.asList(PathFragment.create("b"), PathFragment.create("a"))))
.isTrue();
}
@Test
public void testStartsWithAnyNotFound() throws Exception {
PathFragment a = PathFragment.create("a");
assertThat(
FileSystemUtils.startsWithAny(
a, Arrays.asList(PathFragment.create("b"), PathFragment.create("c"))))
.isFalse();
}
@Test
public void testIterateLines() throws Exception {
Path file = fileSystem.getPath("/test.txt");
FileSystemUtils.writeContent(file, ISO_8859_1, "a\nb");
assertThat(Lists.newArrayList(FileSystemUtils.iterateLinesAsLatin1(file)))
.isEqualTo(Arrays.asList("a", "b"));
FileSystemUtils.writeContent(file, ISO_8859_1, "a\rb");
assertThat(Lists.newArrayList(FileSystemUtils.iterateLinesAsLatin1(file)))
.isEqualTo(Arrays.asList("a", "b"));
FileSystemUtils.writeContent(file, ISO_8859_1, "a\r\nb");
assertThat(Lists.newArrayList(FileSystemUtils.iterateLinesAsLatin1(file)))
.isEqualTo(Arrays.asList("a", "b"));
}
@Test
public void testEnsureSymbolicLinkDoesNotMakeUnnecessaryChanges() throws Exception {
PathFragment target = PathFragment.create("/b");
Path file = fileSystem.getPath("/a");
file.createSymbolicLink(target);
long prevTimeMillis = clock.currentTimeMillis();
clock.advanceMillis(1000);
FileSystemUtils.ensureSymbolicLink(file, target);
long timestamp = file.getLastModifiedTime(Symlinks.NOFOLLOW);
assertThat(timestamp).isEqualTo(prevTimeMillis);
}
@Test
public void testCreateHardLinkForFile_Success() throws Exception {
/* Original file exists and link file does not exist */
Path originalPath = workingDir.getRelative("original");
Path linkPath = workingDir.getRelative("link");
FileSystemUtils.createEmptyFile(originalPath);
FileSystemUtils.createHardLink(linkPath, originalPath);
assertThat(originalPath.exists()).isTrue();
assertThat(linkPath.exists()).isTrue();
assertThat(fileSystem.stat(linkPath, false).getNodeId())
.isEqualTo(fileSystem.stat(originalPath, false).getNodeId());
}
@Test
public void testCreateHardLinkForEmptyDirectory_Success() throws Exception {
Path originalDir = workingDir.getRelative("originalDir");
Path linkPath = workingDir.getRelative("link");
FileSystemUtils.createDirectoryAndParents(originalDir);
/* Original directory is empty, no link to be created. */
FileSystemUtils.createHardLink(linkPath, originalDir);
assertThat(linkPath.exists()).isFalse();
}
@Test
public void testCreateHardLinkForNonEmptyDirectory_Success() throws Exception {
/* Test when original path is a directory */
Path originalDir = workingDir.getRelative("originalDir");
Path linkPath = workingDir.getRelative("link");
Path originalPath1 = originalDir.getRelative("original1");
Path originalPath2 = originalDir.getRelative("original2");
Path originalPath3 = originalDir.getRelative("original3");
Path linkPath1 = linkPath.getRelative("original1");
Path linkPath2 = linkPath.getRelative("original2");
Path linkPath3 = linkPath.getRelative("original3");
FileSystemUtils.createDirectoryAndParents(originalDir);
FileSystemUtils.createEmptyFile(originalPath1);
FileSystemUtils.createEmptyFile(originalPath2);
FileSystemUtils.createEmptyFile(originalPath3);
/* Three link files created under linkPath */
FileSystemUtils.createHardLink(linkPath, originalDir);
assertThat(linkPath.exists()).isTrue();
assertThat(linkPath1.exists()).isTrue();
assertThat(linkPath2.exists()).isTrue();
assertThat(linkPath3.exists()).isTrue();
assertThat(fileSystem.stat(linkPath1, false).getNodeId())
.isEqualTo(fileSystem.stat(originalPath1, false).getNodeId());
assertThat(fileSystem.stat(linkPath2, false).getNodeId())
.isEqualTo(fileSystem.stat(originalPath2, false).getNodeId());
assertThat(fileSystem.stat(linkPath3, false).getNodeId())
.isEqualTo(fileSystem.stat(originalPath3, false).getNodeId());
}
}