diff options
Diffstat (limited to 'src/test/java/com/google/devtools/build/lib/vfs')
14 files changed, 645 insertions, 1266 deletions
diff --git a/src/test/java/com/google/devtools/build/lib/vfs/FileSystemTest.java b/src/test/java/com/google/devtools/build/lib/vfs/FileSystemTest.java index e8896bbc0d..47ae76aa8b 100644 --- a/src/test/java/com/google/devtools/build/lib/vfs/FileSystemTest.java +++ b/src/test/java/com/google/devtools/build/lib/vfs/FileSystemTest.java @@ -14,7 +14,6 @@ package com.google.devtools.build.lib.vfs; import static com.google.common.truth.Truth.assertThat; -import static com.google.common.truth.Truth.assertWithMessage; import static java.nio.charset.StandardCharsets.UTF_8; import static org.junit.Assert.fail; @@ -789,23 +788,6 @@ public abstract class FileSystemTest { assertThat(xNonEmptyDirectoryFoo.isFile()).isTrue(); } - @Test - public void testCannotRemoveRoot() { - Path rootDirectory = testFS.getRootDirectory(); - try { - rootDirectory.delete(); - fail(); - } catch (IOException e) { - String msg = e.getMessage(); - assertWithMessage(String.format("got %s want EBUSY or ENOTEMPTY", msg)) - .that( - msg.endsWith(" (Directory not empty)") - || msg.endsWith(" (Device or resource busy)") - || msg.endsWith(" (Is a directory)")) - .isTrue(); // Happens on OS X. - } - } - // Test the date functions @Test public void testCreateFileChangesTimeOfDirectory() throws Exception { @@ -1105,22 +1087,13 @@ public abstract class FileSystemTest { // Test the Paths @Test public void testGetPathOnlyAcceptsAbsolutePath() { - try { - testFS.getPath("not-absolute"); - fail("The expected Exception was not thrown."); - } catch (IllegalArgumentException ex) { - assertThat(ex).hasMessage("not-absolute (not an absolute path)"); - } + MoreAsserts.expectThrows(IllegalArgumentException.class, () -> testFS.getPath("not-absolute")); } @Test public void testGetPathOnlyAcceptsAbsolutePathFragment() { - try { - testFS.getPath(PathFragment.create("not-absolute")); - fail("The expected Exception was not thrown."); - } catch (IllegalArgumentException ex) { - assertThat(ex).hasMessage("not-absolute (not an absolute path)"); - } + MoreAsserts.expectThrows( + IllegalArgumentException.class, () -> testFS.getPath(PathFragment.create("not-absolute"))); } // Test the access permissions diff --git a/src/test/java/com/google/devtools/build/lib/vfs/FileSystemUtilsTest.java b/src/test/java/com/google/devtools/build/lib/vfs/FileSystemUtilsTest.java index 656363333e..f9cc1a9031 100644 --- a/src/test/java/com/google/devtools/build/lib/vfs/FileSystemUtilsTest.java +++ b/src/test/java/com/google/devtools/build/lib/vfs/FileSystemUtilsTest.java @@ -175,11 +175,29 @@ public class FileSystemUtilsTest { @Test public void testRelativePath() throws IOException { createTestDirectoryTree(); - assertThat(relativePath(topDir, file1).getPathString()).isEqualTo("file-1"); - assertThat(relativePath(topDir, topDir).getPathString()).isEqualTo("."); - assertThat(relativePath(topDir, dirLink).getPathString()).isEqualTo("a-dir/inner-dir/dir-link"); - assertThat(relativePath(topDir, file4).getPathString()).isEqualTo("../file-4"); - assertThat(relativePath(innerDir, file4).getPathString()).isEqualTo("../../../file-4"); + 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 diff --git a/src/test/java/com/google/devtools/build/lib/vfs/LocalPathAbstractTest.java b/src/test/java/com/google/devtools/build/lib/vfs/LocalPathAbstractTest.java deleted file mode 100644 index 93869521ad..0000000000 --- a/src/test/java/com/google/devtools/build/lib/vfs/LocalPathAbstractTest.java +++ /dev/null @@ -1,180 +0,0 @@ -// Copyright 2017 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.testutil.MoreAsserts.assertThrows; -import static java.util.stream.Collectors.toList; - -import com.google.common.collect.Lists; -import com.google.common.testing.EqualsTester; -import com.google.devtools.build.lib.vfs.LocalPath.OsPathPolicy; -import java.util.Collections; -import java.util.List; -import org.junit.Before; -import org.junit.Test; - -/** Tests for {@link LocalPath}. */ -public abstract class LocalPathAbstractTest { - - private OsPathPolicy os; - - @Before - public void setup() { - os = getFilePathOs(); - } - - @Test - public void testEqualsAndHashCode() { - new EqualsTester() - .addEqualityGroup( - create("../relative/path"), create("..").getRelative("relative").getRelative("path")) - .addEqualityGroup(create("something/else")) - .addEqualityGroup(create(""), LocalPath.EMPTY) - .testEquals(); - } - - @Test - public void testRelativeTo() { - assertThat(create("").relativeTo(create("")).getPathString()).isEmpty(); - assertThat(create("foo").relativeTo(create("foo")).getPathString()).isEmpty(); - assertThat(create("foo/bar/baz").relativeTo(create("foo")).getPathString()) - .isEqualTo("bar/baz"); - assertThat(create("foo/bar/baz").relativeTo(create("foo/bar")).getPathString()) - .isEqualTo("baz"); - assertThat(create("foo").relativeTo(create("")).getPathString()).isEqualTo("foo"); - - // Cannot relativize non-ancestors - assertThrows(IllegalArgumentException.class, () -> create("foo/bar").relativeTo(create("fo"))); - - // Make sure partial directory matches aren't reported - assertThrows( - IllegalArgumentException.class, () -> create("foo/bar").relativeTo(create("foo/ba"))); - } - - @Test - public void testGetRelative() { - assertThat(create("a").getRelative("b").getPathString()).isEqualTo("a/b"); - assertThat(create("a/b").getRelative("c/d").getPathString()).isEqualTo("a/b/c/d"); - assertThat(create("a").getRelative("").getPathString()).isEqualTo("a"); - assertThat(create("a/b").getRelative("../c").getPathString()).isEqualTo("a/c"); - assertThat(create("a/b").getRelative("..").getPathString()).isEqualTo("a"); - } - - @Test - public void testEmptyPathToEmptyPath() { - // compare string forms - assertThat(create("").getPathString()).isEmpty(); - // compare fragment forms - assertThat(create("")).isEqualTo(create("")); - } - - @Test - public void testSimpleNameToSimpleName() { - // compare string forms - assertThat(create("foo").getPathString()).isEqualTo("foo"); - // compare fragment forms - assertThat(create("foo")).isEqualTo(create("foo")); - } - - @Test - public void testSimplePathToSimplePath() { - // compare string forms - assertThat(create("foo/bar").getPathString()).isEqualTo("foo/bar"); - // compare fragment forms - assertThat(create("foo/bar")).isEqualTo(create("foo/bar")); - } - - @Test - public void testStripsTrailingSlash() { - // compare string forms - assertThat(create("foo/bar/").getPathString()).isEqualTo("foo/bar"); - // compare fragment forms - assertThat(create("foo/bar/")).isEqualTo(create("foo/bar")); - } - - @Test - public void testGetParentDirectory() { - LocalPath fooBarWiz = create("foo/bar/wiz"); - LocalPath fooBar = create("foo/bar"); - LocalPath foo = create("foo"); - LocalPath empty = create(""); - assertThat(fooBarWiz.getParentDirectory()).isEqualTo(fooBar); - assertThat(fooBar.getParentDirectory()).isEqualTo(foo); - assertThat(foo.getParentDirectory()).isEqualTo(empty); - assertThat(empty.getParentDirectory()).isNull(); - } - - @Test - public void testBasename() throws Exception { - assertThat(create("foo/bar").getBaseName()).isEqualTo("bar"); - assertThat(create("foo/").getBaseName()).isEqualTo("foo"); - assertThat(create("foo").getBaseName()).isEqualTo("foo"); - assertThat(create("").getBaseName()).isEmpty(); - } - - @Test - public void testStartsWith() { - // (relative path, relative prefix) => true - assertThat(create("foo/bar").startsWith(create("foo/bar"))).isTrue(); - assertThat(create("foo/bar").startsWith(create("foo"))).isTrue(); - assertThat(create("foot/bar").startsWith(create("foo"))).isFalse(); - } - - @Test - public void testNormalize() { - assertThat(create("a/b")).isEqualTo(create("a/b")); - assertThat(create("a/../../b")).isEqualTo(create("../b")); - assertThat(create("a/../..")).isEqualTo(create("..")); - assertThat(create("a/../b")).isEqualTo(create("b")); - assertThat(create("a/b/../b")).isEqualTo(create("a/b")); - } - - @Test - public void testNormalStringsDoNotAllocate() { - String normal1 = "a/b/hello.txt"; - assertThat(create(normal1).getPathString()).isSameAs(normal1); - - // Sanity check our testing strategy - String notNormal = "a/../b"; - assertThat(create(notNormal).getPathString()).isNotSameAs(notNormal); - } - - @Test - public void testComparableSortOrder() { - List<LocalPath> list = - Lists.newArrayList( - create("zzz"), - create("ZZZ"), - create("ABC"), - create("aBc"), - create("AbC"), - create("abc")); - Collections.sort(list); - List<String> result = list.stream().map(LocalPath::getPathString).collect(toList()); - - if (os.isCaseSensitive()) { - assertThat(result).containsExactly("ABC", "AbC", "ZZZ", "aBc", "abc", "zzz").inOrder(); - } else { - // Partial ordering among case-insensitive items guaranteed by Collections.sort stability - assertThat(result).containsExactly("ABC", "aBc", "AbC", "abc", "zzz", "ZZZ").inOrder(); - } - } - - protected abstract OsPathPolicy getFilePathOs(); - - protected LocalPath create(String path) { - return LocalPath.createWithOs(path, os); - } -} diff --git a/src/test/java/com/google/devtools/build/lib/vfs/MacOsLocalPathTest.java b/src/test/java/com/google/devtools/build/lib/vfs/MacOsLocalPathTest.java deleted file mode 100644 index c99ad487ee..0000000000 --- a/src/test/java/com/google/devtools/build/lib/vfs/MacOsLocalPathTest.java +++ /dev/null @@ -1,48 +0,0 @@ -// Copyright 2017 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 com.google.common.testing.EqualsTester; -import com.google.devtools.build.lib.vfs.LocalPath.MacOsPathPolicy; -import com.google.devtools.build.lib.vfs.LocalPath.OsPathPolicy; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.JUnit4; - -/** Tests Mac-specific parts of {@link LocalPath}. */ -@RunWith(JUnit4.class) -public class MacOsLocalPathTest extends UnixLocalPathTest { - - @Override - protected OsPathPolicy getFilePathOs() { - return new MacOsPathPolicy(); - } - - @Test - public void testMacEqualsAndHashCode() { - new EqualsTester() - .addEqualityGroup(create("a/b"), create("A/B")) - .addEqualityGroup(create("/a/b"), create("/A/B")) - .addEqualityGroup(create("something/else")) - .addEqualityGroup(create("/something/else")) - .testEquals(); - } - - @Test - public void testCaseIsPreserved() { - assertThat(create("a/B").getPathString()).isEqualTo("a/B"); - } -} diff --git a/src/test/java/com/google/devtools/build/lib/vfs/NativePathTest.java b/src/test/java/com/google/devtools/build/lib/vfs/NativePathTest.java index 6d112853fd..5dc43a2567 100644 --- a/src/test/java/com/google/devtools/build/lib/vfs/NativePathTest.java +++ b/src/test/java/com/google/devtools/build/lib/vfs/NativePathTest.java @@ -106,13 +106,6 @@ public class NativePathTest { } @Test - public void testParentOfRootIsRoot() { - assertThat(fs.getPath("/..")).isEqualTo(fs.getPath("/")); - assertThat(fs.getPath("/../../../../../..")).isEqualTo(fs.getPath("/")); - assertThat(fs.getPath("/../../../foo")).isEqualTo(fs.getPath("/foo")); - } - - @Test public void testIsDirectory() { assertThat(fs.getPath(aDirectory.getPath()).isDirectory()).isTrue(); assertThat(fs.getPath(aFile.getPath()).isDirectory()).isFalse(); @@ -241,14 +234,4 @@ public class NativePathTest { assertThat(in.read()).isEqualTo(-1); in.close(); } - - @Test - public void testDerivedSegmentEquality() { - Path absoluteSegment = fs.getRootDirectory(); - - Path derivedNode = absoluteSegment.getChild("derivedSegment"); - Path otherDerivedNode = absoluteSegment.getChild("derivedSegment"); - - assertThat(otherDerivedNode).isSameAs(derivedNode); - } } diff --git a/src/test/java/com/google/devtools/build/lib/vfs/PathAbstractTest.java b/src/test/java/com/google/devtools/build/lib/vfs/PathAbstractTest.java new file mode 100644 index 0000000000..7494683391 --- /dev/null +++ b/src/test/java/com/google/devtools/build/lib/vfs/PathAbstractTest.java @@ -0,0 +1,141 @@ +// Copyright 2017 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 java.util.stream.Collectors.toList; + +import com.google.common.collect.Lists; +import com.google.common.testing.EqualsTester; +import com.google.devtools.build.lib.clock.BlazeClock; +import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.util.Collections; +import java.util.List; +import org.junit.Before; +import org.junit.Test; + +/** Tests for {@link Path}. */ +public abstract class PathAbstractTest { + + private FileSystem fileSystem; + private boolean isCaseSensitive; + + @Before + public void setup() { + fileSystem = new InMemoryFileSystem(BlazeClock.instance()); + isCaseSensitive = OsPathPolicy.getFilePathOs().isCaseSensitive(); + } + + @Test + public void testStripsTrailingSlash() { + // compare string forms + assertThat(create("/foo/bar/").getPathString()).isEqualTo("/foo/bar"); + // compare fragment forms + assertThat(create("/foo/bar/")).isEqualTo(create("/foo/bar")); + } + + @Test + public void testBasename() throws Exception { + assertThat(create("/foo/bar").getBaseName()).isEqualTo("bar"); + assertThat(create("/foo/").getBaseName()).isEqualTo("foo"); + assertThat(create("/foo").getBaseName()).isEqualTo("foo"); + assertThat(create("/").getBaseName()).isEmpty(); + } + + @Test + public void testNormalStringsDoNotAllocate() { + String normal1 = "/a/b/hello.txt"; + assertThat(create(normal1).getPathString()).isSameAs(normal1); + + // Sanity check our testing strategy + String notNormal = "/a/../b"; + assertThat(create(notNormal).getPathString()).isNotSameAs(notNormal); + } + + @Test + public void testComparableSortOrder() { + List<Path> list = + Lists.newArrayList( + create("/zzz"), + create("/ZZZ"), + create("/ABC"), + create("/aBc"), + create("/AbC"), + create("/abc")); + Collections.sort(list); + List<String> result = list.stream().map(Path::getPathString).collect(toList()); + + if (isCaseSensitive) { + assertThat(result).containsExactly("/ABC", "/AbC", "/ZZZ", "/aBc", "/abc", "/zzz").inOrder(); + } else { + // Partial ordering among case-insensitive items guaranteed by Collections.sort stability + assertThat(result).containsExactly("/ABC", "/aBc", "/AbC", "/abc", "/zzz", "/ZZZ").inOrder(); + } + } + + @Test + public void testSerialization() throws Exception { + FileSystem oldFileSystem = Path.getFileSystemForSerialization(); + try { + Path.setFileSystemForSerialization(fileSystem); + Path root = fileSystem.getPath("/"); + Path p1 = fileSystem.getPath("/foo"); + Path p2 = fileSystem.getPath("/foo/bar"); + + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + ObjectOutputStream oos = new ObjectOutputStream(bos); + + oos.writeObject(root); + oos.writeObject(p1); + oos.writeObject(p2); + + ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); + ObjectInputStream ois = new ObjectInputStream(bis); + + Path dsRoot = (Path) ois.readObject(); + Path dsP1 = (Path) ois.readObject(); + Path dsP2 = (Path) ois.readObject(); + + new EqualsTester() + .addEqualityGroup(root, dsRoot) + .addEqualityGroup(p1, dsP1) + .addEqualityGroup(p2, dsP2) + .testEquals(); + + assertThat(p2.startsWith(p1)).isTrue(); + assertThat(p2.startsWith(dsP1)).isTrue(); + assertThat(dsP2.startsWith(p1)).isTrue(); + assertThat(dsP2.startsWith(dsP1)).isTrue(); + + // Regression test for a very specific bug in compareTo involving our incorrect usage of + // reference equality rather than logical equality. + String relativePathStringA = "child/grandchildA"; + String relativePathStringB = "child/grandchildB"; + assertThat( + p1.getRelative(relativePathStringA).compareTo(dsP1.getRelative(relativePathStringB))) + .isEqualTo( + p1.getRelative(relativePathStringA).compareTo(p1.getRelative(relativePathStringB))); + } finally { + Path.setFileSystemForSerialization(oldFileSystem); + } + } + + protected Path create(String path) { + return Path.create(path, fileSystem); + } +} diff --git a/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentTest.java b/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentTest.java index 7fa3c73d89..02446c0337 100644 --- a/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentTest.java +++ b/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentTest.java @@ -15,13 +15,14 @@ package com.google.devtools.build.lib.vfs; import static com.google.common.collect.ImmutableList.toImmutableList; import static com.google.common.truth.Truth.assertThat; -import static org.junit.Assert.fail; +import static com.google.devtools.build.lib.vfs.PathFragment.create; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Lists; import com.google.common.testing.EqualsTester; import com.google.devtools.build.lib.skyframe.serialization.testutils.ObjectCodecTester; +import com.google.devtools.build.lib.testutil.MoreAsserts; import com.google.devtools.build.lib.testutil.TestUtils; import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem; import java.io.File; @@ -36,32 +37,6 @@ import org.junit.runners.JUnit4; */ @RunWith(JUnit4.class) public class PathFragmentTest { - @Test - public void testMergeFourPathsWithAbsolute() { - assertThat( - PathFragment.create( - PathFragment.create("x/y"), - PathFragment.create("z/a"), - PathFragment.create("/b/c"), - PathFragment.create("d/e"))) - .isEqualTo(PathFragment.create("x/y/z/a/b/c/d/e")); - } - - @Test - public void testCreateInternsPathFragments() { - String[] firstSegments = new String[] {"hello", "world"}; - PathFragment first = PathFragment.create( - /*driveLetter=*/ '\0', /*isAbsolute=*/ false, firstSegments); - - String[] secondSegments = new String[] {new String("hello"), new String("world")}; - PathFragment second = PathFragment.create( - /*driveLetter=*/ '\0', /*isAbsolute=*/ false, secondSegments); - - assertThat(first.segmentCount()).isEqualTo(second.segmentCount()); - for (int i = 0; i < first.segmentCount(); i++) { - assertThat(first.getSegment(i)).isSameAs(second.getSegment(i)); - } - } @Test public void testEqualsAndHashCode() { @@ -69,23 +44,21 @@ public class PathFragmentTest { new EqualsTester() .addEqualityGroup( - PathFragment.create("../relative/path"), - PathFragment.create("..").getRelative("relative").getRelative("path"), - PathFragment.createAlreadyInterned( - '\0', false, new String[] {"..", "relative", "path"}), - PathFragment.create(new File("../relative/path"))) - .addEqualityGroup(PathFragment.create("something/else")) - .addEqualityGroup(PathFragment.create("/something/else")) - .addEqualityGroup(PathFragment.create("/"), PathFragment.create("//////")) - .addEqualityGroup(PathFragment.create(""), PathFragment.EMPTY_FRAGMENT) + create("../relative/path"), + create("..").getRelative("relative").getRelative("path"), + create(new File("../relative/path").getPath())) + .addEqualityGroup(create("something/else")) + .addEqualityGroup(create("/something/else")) + .addEqualityGroup(create("/"), create("//////")) + .addEqualityGroup(create(""), PathFragment.EMPTY_FRAGMENT) .addEqualityGroup(filesystem.getPath("/")) // A Path object. .testEquals(); } @Test public void testHashCodeCache() { - PathFragment relativePath = PathFragment.create("../relative/path"); - PathFragment rootPath = PathFragment.create("/"); + PathFragment relativePath = create("../relative/path"); + PathFragment rootPath = create("/"); int oldResult = relativePath.hashCode(); int rootResult = rootPath.hashCode(); @@ -93,279 +66,272 @@ public class PathFragmentTest { assertThat(rootPath.hashCode()).isEqualTo(rootResult); } - private void checkRelativeTo(String path, String base) { - PathFragment relative = PathFragment.create(path).relativeTo(base); - assertThat(PathFragment.create(base).getRelative(relative).normalize()) - .isEqualTo(PathFragment.create(path)); - } - @Test public void testRelativeTo() { - assertPath("bar/baz", PathFragment.create("foo/bar/baz").relativeTo("foo")); - assertPath("bar/baz", PathFragment.create("/foo/bar/baz").relativeTo("/foo")); - assertPath("baz", PathFragment.create("foo/bar/baz").relativeTo("foo/bar")); - assertPath("baz", PathFragment.create("/foo/bar/baz").relativeTo("/foo/bar")); - assertPath("foo", PathFragment.create("/foo").relativeTo("/")); - assertPath("foo", PathFragment.create("foo").relativeTo("")); - assertPath("foo/bar", PathFragment.create("foo/bar").relativeTo("")); - - checkRelativeTo("foo/bar/baz", "foo"); - checkRelativeTo("/foo/bar/baz", "/foo"); - checkRelativeTo("foo/bar/baz", "foo/bar"); - checkRelativeTo("/foo/bar/baz", "/foo/bar"); - checkRelativeTo("/foo", "/"); - checkRelativeTo("foo", ""); - checkRelativeTo("foo/bar", ""); + assertThat(create("foo/bar/baz").relativeTo("foo").getPathString()).isEqualTo("bar/baz"); + assertThat(create("/foo/bar/baz").relativeTo("/foo").getPathString()).isEqualTo("bar/baz"); + assertThat(create("foo/bar/baz").relativeTo("foo/bar").getPathString()).isEqualTo("baz"); + assertThat(create("/foo/bar/baz").relativeTo("/foo/bar").getPathString()).isEqualTo("baz"); + assertThat(create("/foo").relativeTo("/").getPathString()).isEqualTo("foo"); + assertThat(create("foo").relativeTo("").getPathString()).isEqualTo("foo"); + assertThat(create("foo/bar").relativeTo("").getPathString()).isEqualTo("foo/bar"); } @Test public void testIsAbsolute() { - assertThat(PathFragment.create("/absolute/test").isAbsolute()).isTrue(); - assertThat(PathFragment.create("relative/test").isAbsolute()).isFalse(); - assertThat(PathFragment.create(new File("/absolute/test")).isAbsolute()).isTrue(); - assertThat(PathFragment.create(new File("relative/test")).isAbsolute()).isFalse(); + assertThat(create("/absolute/test").isAbsolute()).isTrue(); + assertThat(create("relative/test").isAbsolute()).isFalse(); + assertThat(create(new File("/absolute/test").getPath()).isAbsolute()).isTrue(); + assertThat(create(new File("relative/test").getPath()).isAbsolute()).isFalse(); } @Test public void testIsNormalized() { - assertThat(PathFragment.create("/absolute/path").isNormalized()).isTrue(); - assertThat(PathFragment.create("some//path").isNormalized()).isTrue(); - assertThat(PathFragment.create("some/./path").isNormalized()).isFalse(); - assertThat(PathFragment.create("../some/path").isNormalized()).isFalse(); - assertThat(PathFragment.create("some/other/../path").isNormalized()).isFalse(); - assertThat(PathFragment.create("some/other//tricky..path..").isNormalized()).isTrue(); - assertThat(PathFragment.create("/some/other//tricky..path..").isNormalized()).isTrue(); + assertThat(PathFragment.isNormalized("/absolute/path")).isTrue(); + assertThat(PathFragment.isNormalized("some//path")).isTrue(); + assertThat(PathFragment.isNormalized("some/./path")).isFalse(); + assertThat(PathFragment.isNormalized("../some/path")).isFalse(); + assertThat(PathFragment.isNormalized("./some/path")).isFalse(); + assertThat(PathFragment.isNormalized("some/path/..")).isFalse(); + assertThat(PathFragment.isNormalized("some/path/.")).isFalse(); + assertThat(PathFragment.isNormalized("some/other/../path")).isFalse(); + assertThat(PathFragment.isNormalized("some/other//tricky..path..")).isTrue(); + assertThat(PathFragment.isNormalized("/some/other//tricky..path..")).isTrue(); + } + + @Test + public void testContainsUpLevelReferences() { + assertThat(PathFragment.containsUplevelReferences("/absolute/path")).isFalse(); + assertThat(PathFragment.containsUplevelReferences("some//path")).isFalse(); + assertThat(PathFragment.containsUplevelReferences("some/./path")).isFalse(); + assertThat(PathFragment.containsUplevelReferences("../some/path")).isTrue(); + assertThat(PathFragment.containsUplevelReferences("./some/path")).isFalse(); + assertThat(PathFragment.containsUplevelReferences("some/path/..")).isTrue(); + assertThat(PathFragment.containsUplevelReferences("some/path/.")).isFalse(); + assertThat(PathFragment.containsUplevelReferences("some/other/../path")).isTrue(); + assertThat(PathFragment.containsUplevelReferences("some/other//tricky..path..")).isFalse(); + assertThat(PathFragment.containsUplevelReferences("/some/other//tricky..path..")).isFalse(); + + // Normalization cannot remove leading uplevel references, so this will be true + assertThat(create("../some/path").containsUplevelReferences()).isTrue(); + // Normalization will remove these, so no uplevel references left + assertThat(create("some/path/..").containsUplevelReferences()).isFalse(); } @Test public void testRootNodeReturnsRootString() { - PathFragment rootFragment = PathFragment.create("/"); + PathFragment rootFragment = create("/"); assertThat(rootFragment.getPathString()).isEqualTo("/"); } @Test - public void testGetPathFragmentDoesNotNormalize() { - String nonCanonicalPath = "/a/weird/noncanonical/../path/."; - assertThat(PathFragment.create(nonCanonicalPath).getPathString()).isEqualTo(nonCanonicalPath); - } - - @Test public void testGetRelative() { - assertThat(PathFragment.create("a").getRelative("b").getPathString()).isEqualTo("a/b"); - assertThat(PathFragment.create("a/b").getRelative("c/d").getPathString()).isEqualTo("a/b/c/d"); - assertThat(PathFragment.create("c/d").getRelative("/a/b").getPathString()).isEqualTo("/a/b"); - assertThat(PathFragment.create("a").getRelative("").getPathString()).isEqualTo("a"); - assertThat(PathFragment.create("/").getRelative("").getPathString()).isEqualTo("/"); + assertThat(create("a").getRelative("b").getPathString()).isEqualTo("a/b"); + assertThat(create("a/b").getRelative("c/d").getPathString()).isEqualTo("a/b/c/d"); + assertThat(create("c/d").getRelative("/a/b").getPathString()).isEqualTo("/a/b"); + assertThat(create("a").getRelative("").getPathString()).isEqualTo("a"); + assertThat(create("/").getRelative("").getPathString()).isEqualTo("/"); + assertThat(create("a/b").getRelative("../foo").getPathString()).isEqualTo("a/foo"); + assertThat(create("/a/b").getRelative("../foo").getPathString()).isEqualTo("/a/foo"); + + // Make sure any fast path of PathFragment#getRelative(PathFragment) works + assertThat(create("a/b").getRelative(create("../foo")).getPathString()).isEqualTo("a/foo"); + assertThat(create("/a/b").getRelative(create("../foo")).getPathString()).isEqualTo("/a/foo"); + + // Make sure any fast path of PathFragment#getRelative(PathFragment) works + assertThat(create("c/d").getRelative(create("/a/b")).getPathString()).isEqualTo("/a/b"); + + // Test normalization + assertThat(create("a").getRelative(".").getPathString()).isEqualTo("a"); } @Test public void testGetChildWorks() { - PathFragment pf = PathFragment.create("../some/path"); - assertThat(pf.getChild("hi")).isEqualTo(PathFragment.create("../some/path/hi")); + PathFragment pf = create("../some/path"); + assertThat(pf.getChild("hi")).isEqualTo(create("../some/path/hi")); } @Test public void testGetChildRejectsInvalidBaseNames() { - PathFragment pf = PathFragment.create("../some/path"); - assertGetChildFails(pf, "."); - assertGetChildFails(pf, ".."); - assertGetChildFails(pf, "x/y"); - assertGetChildFails(pf, "/y"); - assertGetChildFails(pf, "y/"); - assertGetChildFails(pf, ""); - } - - private void assertGetChildFails(PathFragment pf, String baseName) { - try { - pf.getChild(baseName); - fail(); - } catch (Exception e) { /* Expected. */ } - } - - // Tests after here test the canonicalization - private void assertRegular(String expected, String actual) { - // compare string forms - assertThat(PathFragment.create(actual).getPathString()).isEqualTo(expected); - // compare fragment forms - assertThat(PathFragment.create(actual)).isEqualTo(PathFragment.create(expected)); + PathFragment pf = create("../some/path"); + MoreAsserts.expectThrows(IllegalArgumentException.class, () -> pf.getChild(".")); + MoreAsserts.expectThrows(IllegalArgumentException.class, () -> pf.getChild("..")); + MoreAsserts.expectThrows(IllegalArgumentException.class, () -> pf.getChild("x/y")); + MoreAsserts.expectThrows(IllegalArgumentException.class, () -> pf.getChild("/y")); + MoreAsserts.expectThrows(IllegalArgumentException.class, () -> pf.getChild("y/")); + MoreAsserts.expectThrows(IllegalArgumentException.class, () -> pf.getChild("")); } @Test public void testEmptyPathToEmptyPath() { - assertRegular("/", "/"); - assertRegular("", ""); + assertThat(create("/").getPathString()).isEqualTo("/"); + assertThat(create("").getPathString()).isEqualTo(""); } @Test public void testRedundantSlashes() { - assertRegular("/", "///"); - assertRegular("/foo/bar", "/foo///bar"); - assertRegular("/foo/bar", "////foo//bar"); + assertThat(create("///").getPathString()).isEqualTo("/"); + assertThat(create("/foo///bar").getPathString()).isEqualTo("/foo/bar"); + assertThat(create("////foo//bar").getPathString()).isEqualTo("/foo/bar"); } @Test public void testSimpleNameToSimpleName() { - assertRegular("/foo", "/foo"); - assertRegular("foo", "foo"); + assertThat(create("/foo").getPathString()).isEqualTo("/foo"); + assertThat(create("foo").getPathString()).isEqualTo("foo"); } @Test public void testSimplePathToSimplePath() { - assertRegular("/foo/bar", "/foo/bar"); - assertRegular("foo/bar", "foo/bar"); + assertThat(create("/foo/bar").getPathString()).isEqualTo("/foo/bar"); + assertThat(create("foo/bar").getPathString()).isEqualTo("foo/bar"); } @Test public void testStripsTrailingSlash() { - assertRegular("/foo/bar", "/foo/bar/"); + assertThat(create("/foo/bar/").getPathString()).isEqualTo("/foo/bar"); } @Test public void testGetParentDirectory() { - PathFragment fooBarWiz = PathFragment.create("foo/bar/wiz"); - PathFragment fooBar = PathFragment.create("foo/bar"); - PathFragment foo = PathFragment.create("foo"); - PathFragment empty = PathFragment.create(""); + PathFragment fooBarWiz = create("foo/bar/wiz"); + PathFragment fooBar = create("foo/bar"); + PathFragment foo = create("foo"); + PathFragment empty = create(""); assertThat(fooBarWiz.getParentDirectory()).isEqualTo(fooBar); assertThat(fooBar.getParentDirectory()).isEqualTo(foo); assertThat(foo.getParentDirectory()).isEqualTo(empty); assertThat(empty.getParentDirectory()).isNull(); - PathFragment fooBarWizAbs = PathFragment.create("/foo/bar/wiz"); - PathFragment fooBarAbs = PathFragment.create("/foo/bar"); - PathFragment fooAbs = PathFragment.create("/foo"); - PathFragment rootAbs = PathFragment.create("/"); + PathFragment fooBarWizAbs = create("/foo/bar/wiz"); + PathFragment fooBarAbs = create("/foo/bar"); + PathFragment fooAbs = create("/foo"); + PathFragment rootAbs = create("/"); assertThat(fooBarWizAbs.getParentDirectory()).isEqualTo(fooBarAbs); assertThat(fooBarAbs.getParentDirectory()).isEqualTo(fooAbs); assertThat(fooAbs.getParentDirectory()).isEqualTo(rootAbs); assertThat(rootAbs.getParentDirectory()).isNull(); - - // Note, this is surprising but correct behavior: - assertThat(PathFragment.create("/foo/bar/..").getParentDirectory()).isEqualTo(fooBarAbs); } @Test public void testSegmentsCount() { - assertThat(PathFragment.create("foo/bar").segmentCount()).isEqualTo(2); - assertThat(PathFragment.create("/foo/bar").segmentCount()).isEqualTo(2); - assertThat(PathFragment.create("foo//bar").segmentCount()).isEqualTo(2); - assertThat(PathFragment.create("/foo//bar").segmentCount()).isEqualTo(2); - assertThat(PathFragment.create("foo/").segmentCount()).isEqualTo(1); - assertThat(PathFragment.create("/foo/").segmentCount()).isEqualTo(1); - assertThat(PathFragment.create("foo").segmentCount()).isEqualTo(1); - assertThat(PathFragment.create("/foo").segmentCount()).isEqualTo(1); - assertThat(PathFragment.create("/").segmentCount()).isEqualTo(0); - assertThat(PathFragment.create("").segmentCount()).isEqualTo(0); + assertThat(create("foo/bar").segmentCount()).isEqualTo(2); + assertThat(create("/foo/bar").segmentCount()).isEqualTo(2); + assertThat(create("foo//bar").segmentCount()).isEqualTo(2); + assertThat(create("/foo//bar").segmentCount()).isEqualTo(2); + assertThat(create("foo/").segmentCount()).isEqualTo(1); + assertThat(create("/foo/").segmentCount()).isEqualTo(1); + assertThat(create("foo").segmentCount()).isEqualTo(1); + assertThat(create("/foo").segmentCount()).isEqualTo(1); + assertThat(create("/").segmentCount()).isEqualTo(0); + assertThat(create("").segmentCount()).isEqualTo(0); } @Test public void testGetSegment() { - assertThat(PathFragment.create("foo/bar").getSegment(0)).isEqualTo("foo"); - assertThat(PathFragment.create("foo/bar").getSegment(1)).isEqualTo("bar"); - assertThat(PathFragment.create("/foo/bar").getSegment(0)).isEqualTo("foo"); - assertThat(PathFragment.create("/foo/bar").getSegment(1)).isEqualTo("bar"); - assertThat(PathFragment.create("foo/").getSegment(0)).isEqualTo("foo"); - assertThat(PathFragment.create("/foo/").getSegment(0)).isEqualTo("foo"); - assertThat(PathFragment.create("foo").getSegment(0)).isEqualTo("foo"); - assertThat(PathFragment.create("/foo").getSegment(0)).isEqualTo("foo"); + assertThat(create("foo/bar").getSegment(0)).isEqualTo("foo"); + assertThat(create("foo/bar").getSegment(1)).isEqualTo("bar"); + assertThat(create("/foo/bar").getSegment(0)).isEqualTo("foo"); + assertThat(create("/foo/bar").getSegment(1)).isEqualTo("bar"); + assertThat(create("foo/").getSegment(0)).isEqualTo("foo"); + assertThat(create("/foo/").getSegment(0)).isEqualTo("foo"); + assertThat(create("foo").getSegment(0)).isEqualTo("foo"); + assertThat(create("/foo").getSegment(0)).isEqualTo("foo"); } @Test public void testBasename() throws Exception { - assertThat(PathFragment.create("foo/bar").getBaseName()).isEqualTo("bar"); - assertThat(PathFragment.create("/foo/bar").getBaseName()).isEqualTo("bar"); - assertThat(PathFragment.create("foo/").getBaseName()).isEqualTo("foo"); - assertThat(PathFragment.create("/foo/").getBaseName()).isEqualTo("foo"); - assertThat(PathFragment.create("foo").getBaseName()).isEqualTo("foo"); - assertThat(PathFragment.create("/foo").getBaseName()).isEqualTo("foo"); - assertThat(PathFragment.create("/").getBaseName()).isEmpty(); - assertThat(PathFragment.create("").getBaseName()).isEmpty(); + assertThat(create("foo/bar").getBaseName()).isEqualTo("bar"); + assertThat(create("/foo/bar").getBaseName()).isEqualTo("bar"); + assertThat(create("foo/").getBaseName()).isEqualTo("foo"); + assertThat(create("/foo/").getBaseName()).isEqualTo("foo"); + assertThat(create("foo").getBaseName()).isEqualTo("foo"); + assertThat(create("/foo").getBaseName()).isEqualTo("foo"); + assertThat(create("/").getBaseName()).isEmpty(); + assertThat(create("").getBaseName()).isEmpty(); } @Test public void testFileExtension() throws Exception { - assertThat(PathFragment.create("foo.bar").getFileExtension()).isEqualTo("bar"); - assertThat(PathFragment.create("foo.barr").getFileExtension()).isEqualTo("barr"); - assertThat(PathFragment.create("foo.b").getFileExtension()).isEqualTo("b"); - assertThat(PathFragment.create("foo.").getFileExtension()).isEmpty(); - assertThat(PathFragment.create("foo").getFileExtension()).isEmpty(); - assertThat(PathFragment.create(".").getFileExtension()).isEmpty(); - assertThat(PathFragment.create("").getFileExtension()).isEmpty(); - assertThat(PathFragment.create("foo/bar.baz").getFileExtension()).isEqualTo("baz"); - assertThat(PathFragment.create("foo.bar.baz").getFileExtension()).isEqualTo("baz"); - assertThat(PathFragment.create("foo.bar/baz").getFileExtension()).isEmpty(); - } - - private static void assertPath(String expected, PathFragment actual) { - assertThat(actual.getPathString()).isEqualTo(expected); + assertThat(create("foo.bar").getFileExtension()).isEqualTo("bar"); + assertThat(create("foo.barr").getFileExtension()).isEqualTo("barr"); + assertThat(create("foo.b").getFileExtension()).isEqualTo("b"); + assertThat(create("foo.").getFileExtension()).isEmpty(); + assertThat(create("foo").getFileExtension()).isEmpty(); + assertThat(create(".").getFileExtension()).isEmpty(); + assertThat(create("").getFileExtension()).isEmpty(); + assertThat(create("foo/bar.baz").getFileExtension()).isEqualTo("baz"); + assertThat(create("foo.bar.baz").getFileExtension()).isEqualTo("baz"); + assertThat(create("foo.bar/baz").getFileExtension()).isEmpty(); } @Test public void testReplaceName() throws Exception { - assertPath("foo/baz", PathFragment.create("foo/bar").replaceName("baz")); - assertPath("/foo/baz", PathFragment.create("/foo/bar").replaceName("baz")); - assertPath("foo", PathFragment.create("foo/bar").replaceName("")); - assertPath("baz", PathFragment.create("foo/").replaceName("baz")); - assertPath("/baz", PathFragment.create("/foo/").replaceName("baz")); - assertPath("baz", PathFragment.create("foo").replaceName("baz")); - assertPath("/baz", PathFragment.create("/foo").replaceName("baz")); - assertThat(PathFragment.create("/").replaceName("baz")).isNull(); - assertThat(PathFragment.create("/").replaceName("")).isNull(); - assertThat(PathFragment.create("").replaceName("baz")).isNull(); - assertThat(PathFragment.create("").replaceName("")).isNull(); - - assertPath("foo/bar/baz", PathFragment.create("foo/bar").replaceName("bar/baz")); - assertPath("foo/bar/baz", PathFragment.create("foo/bar").replaceName("bar/baz/")); + assertThat(create("foo/bar").replaceName("baz").getPathString()).isEqualTo("foo/baz"); + assertThat(create("/foo/bar").replaceName("baz").getPathString()).isEqualTo("/foo/baz"); + assertThat(create("foo/bar").replaceName("").getPathString()).isEqualTo("foo"); + assertThat(create("foo/").replaceName("baz").getPathString()).isEqualTo("baz"); + assertThat(create("/foo/").replaceName("baz").getPathString()).isEqualTo("/baz"); + assertThat(create("foo").replaceName("baz").getPathString()).isEqualTo("baz"); + assertThat(create("/foo").replaceName("baz").getPathString()).isEqualTo("/baz"); + assertThat(create("/").replaceName("baz")).isNull(); + assertThat(create("/").replaceName("")).isNull(); + assertThat(create("").replaceName("baz")).isNull(); + assertThat(create("").replaceName("")).isNull(); + + assertThat(create("foo/bar").replaceName("bar/baz").getPathString()).isEqualTo("foo/bar/baz"); + assertThat(create("foo/bar").replaceName("bar/baz/").getPathString()).isEqualTo("foo/bar/baz"); // Absolute path arguments will clobber the original path. - assertPath("/absolute", PathFragment.create("foo/bar").replaceName("/absolute")); - assertPath("/", PathFragment.create("foo/bar").replaceName("/")); + assertThat(create("foo/bar").replaceName("/absolute").getPathString()).isEqualTo("/absolute"); + assertThat(create("foo/bar").replaceName("/").getPathString()).isEqualTo("/"); } @Test public void testSubFragment() throws Exception { - assertPath("/foo/bar/baz", - PathFragment.create("/foo/bar/baz").subFragment(0, 3)); - assertPath("foo/bar/baz", - PathFragment.create("foo/bar/baz").subFragment(0, 3)); - assertPath("/foo/bar", - PathFragment.create("/foo/bar/baz").subFragment(0, 2)); - assertPath("bar/baz", - PathFragment.create("/foo/bar/baz").subFragment(1, 3)); - assertPath("/foo", - PathFragment.create("/foo/bar/baz").subFragment(0, 1)); - assertPath("bar", - PathFragment.create("/foo/bar/baz").subFragment(1, 2)); - assertPath("baz", PathFragment.create("/foo/bar/baz").subFragment(2, 3)); - assertPath("/", PathFragment.create("/foo/bar/baz").subFragment(0, 0)); - assertPath("", PathFragment.create("foo/bar/baz").subFragment(0, 0)); - assertPath("", PathFragment.create("foo/bar/baz").subFragment(1, 1)); - assertPath("/foo/bar/baz", PathFragment.create("/foo/bar/baz").subFragment(0)); - assertPath("bar/baz", PathFragment.create("/foo/bar/baz").subFragment(1)); - try { - fail("unexpectedly succeeded: " + PathFragment.create("foo/bar/baz").subFragment(3, 2)); - } catch (IndexOutOfBoundsException e) { /* Expected. */ } - try { - fail("unexpectedly succeeded: " + PathFragment.create("foo/bar/baz").subFragment(4, 4)); - } catch (IndexOutOfBoundsException e) { /* Expected. */ } + assertThat(create("/foo/bar/baz").subFragment(0, 3).getPathString()).isEqualTo("/foo/bar/baz"); + assertThat(create("foo/bar/baz").subFragment(0, 3).getPathString()).isEqualTo("foo/bar/baz"); + assertThat(create("/foo/bar/baz").subFragment(0, 2).getPathString()).isEqualTo("/foo/bar"); + assertThat(create("/foo/bar/baz").subFragment(1, 3).getPathString()).isEqualTo("bar/baz"); + assertThat(create("/foo/bar/baz").subFragment(0, 1).getPathString()).isEqualTo("/foo"); + assertThat(create("/foo/bar/baz").subFragment(1, 2).getPathString()).isEqualTo("bar"); + assertThat(create("/foo/bar/baz").subFragment(2, 3).getPathString()).isEqualTo("baz"); + assertThat(create("/foo/bar/baz").subFragment(0, 0).getPathString()).isEqualTo("/"); + assertThat(create("foo/bar/baz").subFragment(0, 0).getPathString()).isEqualTo(""); + assertThat(create("foo/bar/baz").subFragment(1, 1).getPathString()).isEqualTo(""); + + assertThat(create("/foo/bar/baz").subFragment(0).getPathString()).isEqualTo("/foo/bar/baz"); + assertThat(create("foo/bar/baz").subFragment(0).getPathString()).isEqualTo("foo/bar/baz"); + assertThat(create("/foo/bar/baz").subFragment(1).getPathString()).isEqualTo("bar/baz"); + assertThat(create("foo/bar/baz").subFragment(1).getPathString()).isEqualTo("bar/baz"); + assertThat(create("foo/bar/baz").subFragment(2).getPathString()).isEqualTo("baz"); + assertThat(create("foo/bar/baz").subFragment(3).getPathString()).isEqualTo(""); + + MoreAsserts.expectThrows( + IndexOutOfBoundsException.class, () -> create("foo/bar/baz").subFragment(3, 2)); + MoreAsserts.expectThrows( + IndexOutOfBoundsException.class, () -> create("foo/bar/baz").subFragment(4, 4)); + MoreAsserts.expectThrows( + IndexOutOfBoundsException.class, () -> create("foo/bar/baz").subFragment(3, 2)); + MoreAsserts.expectThrows( + IndexOutOfBoundsException.class, () -> create("foo/bar/baz").subFragment(4)); } @Test public void testStartsWith() { - PathFragment foobar = PathFragment.create("/foo/bar"); - PathFragment foobarRelative = PathFragment.create("foo/bar"); + PathFragment foobar = create("/foo/bar"); + PathFragment foobarRelative = create("foo/bar"); // (path, prefix) => true assertThat(foobar.startsWith(foobar)).isTrue(); - assertThat(foobar.startsWith(PathFragment.create("/"))).isTrue(); - assertThat(foobar.startsWith(PathFragment.create("/foo"))).isTrue(); - assertThat(foobar.startsWith(PathFragment.create("/foo/"))).isTrue(); - assertThat(foobar.startsWith(PathFragment.create("/foo/bar/"))) - .isTrue(); // Includes trailing slash. + assertThat(foobar.startsWith(create("/"))).isTrue(); + assertThat(foobar.startsWith(create("/foo"))).isTrue(); + assertThat(foobar.startsWith(create("/foo/"))).isTrue(); + assertThat(foobar.startsWith(create("/foo/bar/"))).isTrue(); // Includes trailing slash. // (prefix, path) => false - assertThat(PathFragment.create("/foo").startsWith(foobar)).isFalse(); - assertThat(PathFragment.create("/").startsWith(foobar)).isFalse(); + assertThat(create("/foo").startsWith(foobar)).isFalse(); + assertThat(create("/").startsWith(foobar)).isFalse(); // (absolute, relative) => false assertThat(foobar.startsWith(foobarRelative)).isFalse(); @@ -373,69 +339,53 @@ public class PathFragmentTest { // (relative path, relative prefix) => true assertThat(foobarRelative.startsWith(foobarRelative)).isTrue(); - assertThat(foobarRelative.startsWith(PathFragment.create("foo"))).isTrue(); - assertThat(foobarRelative.startsWith(PathFragment.create(""))).isTrue(); + assertThat(foobarRelative.startsWith(create("foo"))).isTrue(); + assertThat(foobarRelative.startsWith(create(""))).isTrue(); // (path, sibling) => false - assertThat(PathFragment.create("/foo/wiz").startsWith(foobar)).isFalse(); - assertThat(foobar.startsWith(PathFragment.create("/foo/wiz"))).isFalse(); - - // Does not normalize. - PathFragment foodotbar = PathFragment.create("foo/./bar"); - assertThat(foodotbar.startsWith(foodotbar)).isTrue(); - assertThat(foodotbar.startsWith(PathFragment.create("foo/."))).isTrue(); - assertThat(foodotbar.startsWith(PathFragment.create("foo/./"))).isTrue(); - assertThat(foodotbar.startsWith(PathFragment.create("foo/./bar"))).isTrue(); - assertThat(foodotbar.startsWith(PathFragment.create("foo/bar"))).isFalse(); + assertThat(create("/foo/wiz").startsWith(foobar)).isFalse(); + assertThat(foobar.startsWith(create("/foo/wiz"))).isFalse(); } @Test public void testCheckAllPathsStartWithButAreNotEqualTo() { // Check passes: - PathFragment.checkAllPathsAreUnder(toPathsSet("a/b", "a/c"), - PathFragment.create("a")); + PathFragment.checkAllPathsAreUnder(toPathsSet("a/b", "a/c"), create("a")); // Check trivially passes: - PathFragment.checkAllPathsAreUnder(ImmutableList.<PathFragment>of(), - PathFragment.create("a")); + PathFragment.checkAllPathsAreUnder(ImmutableList.<PathFragment>of(), create("a")); // Check fails when some path does not start with startingWithPath: - try { - PathFragment.checkAllPathsAreUnder(toPathsSet("a/b", "b/c"), - PathFragment.create("a")); - fail(); - } catch (IllegalArgumentException expected) { - } + MoreAsserts.expectThrows( + IllegalArgumentException.class, + () -> PathFragment.checkAllPathsAreUnder(toPathsSet("a/b", "b/c"), create("a"))); // Check fails when some path is equal to startingWithPath: - try { - PathFragment.checkAllPathsAreUnder(toPathsSet("a/b", "a"), - PathFragment.create("a")); - fail(); - } catch (IllegalArgumentException expected) { - } + MoreAsserts.expectThrows( + IllegalArgumentException.class, + () -> PathFragment.checkAllPathsAreUnder(toPathsSet("a/b", "a"), create("a"))); } @Test public void testEndsWith() { - PathFragment foobar = PathFragment.create("/foo/bar"); - PathFragment foobarRelative = PathFragment.create("foo/bar"); + PathFragment foobar = create("/foo/bar"); + PathFragment foobarRelative = create("foo/bar"); // (path, suffix) => true assertThat(foobar.endsWith(foobar)).isTrue(); - assertThat(foobar.endsWith(PathFragment.create("bar"))).isTrue(); - assertThat(foobar.endsWith(PathFragment.create("foo/bar"))).isTrue(); - assertThat(foobar.endsWith(PathFragment.create("/foo/bar"))).isTrue(); - assertThat(foobar.endsWith(PathFragment.create("/bar"))).isFalse(); + assertThat(foobar.endsWith(create("bar"))).isTrue(); + assertThat(foobar.endsWith(create("foo/bar"))).isTrue(); + assertThat(foobar.endsWith(create("/foo/bar"))).isTrue(); + assertThat(foobar.endsWith(create("/bar"))).isFalse(); // (prefix, path) => false - assertThat(PathFragment.create("/foo").endsWith(foobar)).isFalse(); - assertThat(PathFragment.create("/").endsWith(foobar)).isFalse(); + assertThat(create("/foo").endsWith(foobar)).isFalse(); + assertThat(create("/").endsWith(foobar)).isFalse(); // (suffix, path) => false - assertThat(PathFragment.create("/bar").endsWith(foobar)).isFalse(); - assertThat(PathFragment.create("bar").endsWith(foobar)).isFalse(); - assertThat(PathFragment.create("").endsWith(foobar)).isFalse(); + assertThat(create("/bar").endsWith(foobar)).isFalse(); + assertThat(create("bar").endsWith(foobar)).isFalse(); + assertThat(create("").endsWith(foobar)).isFalse(); // (absolute, relative) => true assertThat(foobar.endsWith(foobarRelative)).isTrue(); @@ -445,18 +395,32 @@ public class PathFragmentTest { // (relative path, relative prefix) => true assertThat(foobarRelative.endsWith(foobarRelative)).isTrue(); - assertThat(foobarRelative.endsWith(PathFragment.create("bar"))).isTrue(); - assertThat(foobarRelative.endsWith(PathFragment.create(""))).isTrue(); + assertThat(foobarRelative.endsWith(create("bar"))).isTrue(); + assertThat(foobarRelative.endsWith(create(""))).isTrue(); // (path, sibling) => false - assertThat(PathFragment.create("/foo/wiz").endsWith(foobar)).isFalse(); - assertThat(foobar.endsWith(PathFragment.create("/foo/wiz"))).isFalse(); + assertThat(create("/foo/wiz").endsWith(foobar)).isFalse(); + assertThat(foobar.endsWith(create("/foo/wiz"))).isFalse(); + } + + @Test + public void testToRelative() { + assertThat(create("/foo/bar").toRelative()).isEqualTo(create("foo/bar")); + assertThat(create("/").toRelative()).isEqualTo(create("")); + MoreAsserts.expectThrows(IllegalArgumentException.class, () -> create("foo").toRelative()); + } + + @Test + public void testGetDriveStr() { + assertThat(create("/foo/bar").getDriveStr()).isEqualTo("/"); + assertThat(create("/").getDriveStr()).isEqualTo("/"); + MoreAsserts.expectThrows(IllegalArgumentException.class, () -> create("foo").getDriveStr()); } static List<PathFragment> toPaths(List<String> strs) { List<PathFragment> paths = Lists.newArrayList(); for (String s : strs) { - paths.add(PathFragment.create(s)); + paths.add(create(s)); } return paths; } @@ -464,15 +428,26 @@ public class PathFragmentTest { static ImmutableSet<PathFragment> toPathsSet(String... strs) { ImmutableSet.Builder<PathFragment> builder = ImmutableSet.builder(); for (String str : strs) { - builder.add(PathFragment.create(str)); + builder.add(create(str)); } return builder.build(); } @Test public void testCompareTo() throws Exception { - List<String> pathStrs = ImmutableList.of( - "", "/", "//", ".", "/./", "foo/.//bar", "foo", "/foo", "foo/bar", "foo/Bar", "Foo/bar"); + List<String> pathStrs = + ImmutableList.of( + "", + "/", + "foo", + "/foo", + "foo/bar", + "foo.bar", + "foo/bar.baz", + "foo/bar/baz", + "foo/barfile", + "foo/Bar", + "Foo/bar"); List<PathFragment> paths = toPaths(pathStrs); // First test that compareTo is self-consistent. for (PathFragment x : paths) { @@ -493,36 +468,80 @@ public class PathFragmentTest { } } } - // Now test that compareTo does what we expect. The exact ordering here doesn't matter much, - // but there are three things to notice: 1. absolute < relative, 2. comparison is lexicographic - // 3. repeated slashes are ignored. (PathFragment("//") prints as "/"). + // Now test that compareTo does what we expect. The exact ordering here doesn't matter much. Collections.shuffle(paths); Collections.sort(paths); - List<PathFragment> expectedOrder = toPaths(ImmutableList.of( - "/", "//", "/./", "/foo", "", ".", "Foo/bar", "foo", "foo/.//bar", "foo/Bar", "foo/bar")); + List<PathFragment> expectedOrder = + toPaths( + ImmutableList.of( + "", + "/", + "/foo", + "Foo/bar", + "foo", + "foo.bar", + "foo/Bar", + "foo/bar", + "foo/bar.baz", + "foo/bar/baz", + "foo/barfile")); assertThat(paths).isEqualTo(expectedOrder); } @Test public void testGetSafePathString() { - assertThat(PathFragment.create("/").getSafePathString()).isEqualTo("/"); - assertThat(PathFragment.create("/abc").getSafePathString()).isEqualTo("/abc"); - assertThat(PathFragment.create("").getSafePathString()).isEqualTo("."); + assertThat(create("/").getSafePathString()).isEqualTo("/"); + assertThat(create("/abc").getSafePathString()).isEqualTo("/abc"); + assertThat(create("").getSafePathString()).isEqualTo("."); assertThat(PathFragment.EMPTY_FRAGMENT.getSafePathString()).isEqualTo("."); - assertThat(PathFragment.create("abc/def").getSafePathString()).isEqualTo("abc/def"); + assertThat(create("abc/def").getSafePathString()).isEqualTo("abc/def"); } @Test public void testNormalize() { - assertThat(PathFragment.create("/a/b").normalize()).isEqualTo(PathFragment.create("/a/b")); - assertThat(PathFragment.create("/a/./b").normalize()).isEqualTo(PathFragment.create("/a/b")); - assertThat(PathFragment.create("/a/../b").normalize()).isEqualTo(PathFragment.create("/b")); - assertThat(PathFragment.create("a/b").normalize()).isEqualTo(PathFragment.create("a/b")); - assertThat(PathFragment.create("a/../../b").normalize()).isEqualTo(PathFragment.create("../b")); - assertThat(PathFragment.create("a/../..").normalize()).isEqualTo(PathFragment.create("..")); - assertThat(PathFragment.create("a/../b").normalize()).isEqualTo(PathFragment.create("b")); - assertThat(PathFragment.create("a/b/../b").normalize()).isEqualTo(PathFragment.create("a/b")); - assertThat(PathFragment.create("/..").normalize()).isEqualTo(PathFragment.create("/..")); + assertThat(create("/a/b")).isEqualTo(create("/a/b")); + assertThat(create("/a/./b")).isEqualTo(create("/a/b")); + assertThat(create("/a/../b")).isEqualTo(create("/b")); + assertThat(create("a/b")).isEqualTo(create("a/b")); + assertThat(create("a/../../b")).isEqualTo(create("../b")); + assertThat(create("a/../..")).isEqualTo(create("..")); + assertThat(create("a/../b")).isEqualTo(create("b")); + assertThat(create("a/b/../b")).isEqualTo(create("a/b")); + assertThat(create("/..")).isEqualTo(create("/..")); + assertThat(create("..")).isEqualTo(create("..")); + } + + @Test + public void testSegments() { + assertThat(create("").segmentCount()).isEqualTo(0); + assertThat(create("a").segmentCount()).isEqualTo(1); + assertThat(create("a/b").segmentCount()).isEqualTo(2); + assertThat(create("a/b/c").segmentCount()).isEqualTo(3); + assertThat(create("/").segmentCount()).isEqualTo(0); + assertThat(create("/a").segmentCount()).isEqualTo(1); + assertThat(create("/a/b").segmentCount()).isEqualTo(2); + assertThat(create("/a/b/c").segmentCount()).isEqualTo(3); + + assertThat(create("").getSegments()).isEmpty(); + assertThat(create("a").getSegments()).containsExactly("a").inOrder(); + assertThat(create("a/b").getSegments()).containsExactly("a", "b").inOrder(); + assertThat(create("a/b/c").getSegments()).containsExactly("a", "b", "c").inOrder(); + assertThat(create("/").getSegments()).isEmpty(); + assertThat(create("/a").getSegments()).containsExactly("a").inOrder(); + assertThat(create("/a/b").getSegments()).containsExactly("a", "b").inOrder(); + assertThat(create("/a/b/c").getSegments()).containsExactly("a", "b", "c").inOrder(); + + assertThat(create("a").getSegment(0)).isEqualTo("a"); + assertThat(create("a/b").getSegment(0)).isEqualTo("a"); + assertThat(create("a/b").getSegment(1)).isEqualTo("b"); + assertThat(create("a/b/c").getSegment(2)).isEqualTo("c"); + assertThat(create("/a").getSegment(0)).isEqualTo("a"); + assertThat(create("/a/b").getSegment(0)).isEqualTo("a"); + assertThat(create("/a/b").getSegment(1)).isEqualTo("b"); + assertThat(create("/a/b/c").getSegment(2)).isEqualTo("c"); + + MoreAsserts.expectThrows(IllegalArgumentException.class, () -> create("").getSegment(0)); + MoreAsserts.expectThrows(IllegalArgumentException.class, () -> create("a/b").getSegment(2)); } @Test @@ -552,7 +571,7 @@ public class PathFragmentTest { } private void checkSerialization(String pathFragmentString, int expectedSize) throws Exception { - PathFragment a = PathFragment.create(pathFragmentString); + PathFragment a = create(pathFragmentString); byte[] sa = TestUtils.serializeObject(a); assertThat(sa).hasLength(expectedSize); diff --git a/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentWindowsTest.java b/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentWindowsTest.java index 1f18d07475..b2a8a52977 100644 --- a/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentWindowsTest.java +++ b/src/test/java/com/google/devtools/build/lib/vfs/PathFragmentWindowsTest.java @@ -14,9 +14,9 @@ package com.google.devtools.build.lib.vfs; import static com.google.common.truth.Truth.assertThat; -import static com.google.common.truth.Truth.assertWithMessage; -import static org.junit.Assert.fail; +import static com.google.devtools.build.lib.vfs.PathFragment.create; +import com.google.devtools.build.lib.testutil.MoreAsserts; import java.io.File; import org.junit.Test; import org.junit.runner.RunWith; @@ -30,303 +30,199 @@ public class PathFragmentWindowsTest { @Test public void testWindowsSeparator() { - assertThat(PathFragment.create("bar\\baz").toString()).isEqualTo("bar/baz"); - assertThat(PathFragment.create("c:\\bar\\baz").toString()).isEqualTo("C:/bar/baz"); + assertThat(create("bar\\baz").toString()).isEqualTo("bar/baz"); + assertThat(create("c:\\bar\\baz").toString()).isEqualTo("C:/bar/baz"); } @Test public void testIsAbsoluteWindows() { - assertThat(PathFragment.create("C:/").isAbsolute()).isTrue(); - assertThat(PathFragment.create("C:/").isAbsolute()).isTrue(); - assertThat(PathFragment.create("C:/foo").isAbsolute()).isTrue(); - assertThat(PathFragment.create("d:/foo/bar").isAbsolute()).isTrue(); + assertThat(create("C:/").isAbsolute()).isTrue(); + assertThat(create("C:/").isAbsolute()).isTrue(); + assertThat(create("C:/foo").isAbsolute()).isTrue(); + assertThat(create("d:/foo/bar").isAbsolute()).isTrue(); - assertThat(PathFragment.create("*:/").isAbsolute()).isFalse(); + assertThat(create("*:/").isAbsolute()).isFalse(); } @Test public void testAbsoluteAndAbsoluteLookingPaths() { - PathFragment p1 = PathFragment.create("/c"); - assertThat(p1.isAbsolute()).isTrue(); - assertThat(p1.getDriveLetter()).isEqualTo('\0'); - assertThat(p1.getSegments()).containsExactly("c"); - - PathFragment p2 = PathFragment.create("/c/"); - assertThat(p2.isAbsolute()).isTrue(); - assertThat(p2.getDriveLetter()).isEqualTo('\0'); - assertThat(p2.getSegments()).containsExactly("c"); - - PathFragment p3 = PathFragment.create("C:/"); - assertThat(p3.isAbsolute()).isTrue(); - assertThat(p3.getDriveLetter()).isEqualTo('C'); - assertThat(p3.getSegments()).isEmpty(); - - PathFragment p5 = PathFragment.create("/c:"); + assertThat(create("/c").isAbsolute()).isTrue(); + assertThat(create("/c").getSegments()).containsExactly("c"); + + assertThat(create("/c/").isAbsolute()).isTrue(); + assertThat(create("/c/").getSegments()).containsExactly("c"); + + assertThat(create("C:/").isAbsolute()).isTrue(); + assertThat(create("C:/").getSegments()).isEmpty(); + + PathFragment p5 = create("/c:"); assertThat(p5.isAbsolute()).isTrue(); - assertThat(p5.getDriveLetter()).isEqualTo('\0'); assertThat(p5.getSegments()).containsExactly("c:"); + assertThat(create("C:").isAbsolute()).isFalse(); - assertThat(p1).isEqualTo(p2); - assertThat(p1).isNotEqualTo(p3); - assertThat(p1).isNotEqualTo(p5); - assertThat(p3).isNotEqualTo(p5); - } + assertThat(create("/c:").isAbsolute()).isTrue(); + assertThat(create("/c:").getSegments()).containsExactly("c:"); - @Test - public void testIsAbsoluteWindowsBackslash() { - assertThat(PathFragment.create(new File("C:\\blah")).isAbsolute()).isTrue(); - assertThat(PathFragment.create(new File("C:\\")).isAbsolute()).isTrue(); - assertThat(PathFragment.create(new File("\\blah")).isAbsolute()).isTrue(); - assertThat(PathFragment.create(new File("\\")).isAbsolute()).isTrue(); + assertThat(create("/c")).isEqualTo(create("/c/")); + assertThat(create("/c")).isNotEqualTo(create("C:/")); + assertThat(create("/c")).isNotEqualTo(create("C:")); + assertThat(create("/c")).isNotEqualTo(create("/c:")); + assertThat(create("C:/")).isNotEqualTo(create("C:")); + assertThat(create("C:/")).isNotEqualTo(create("/c:")); } @Test - public void testIsNormalizedWindows() { - assertThat(PathFragment.create("C:/").isNormalized()).isTrue(); - assertThat(PathFragment.create("C:/absolute/path").isNormalized()).isTrue(); - assertThat(PathFragment.create("C:/absolute/./path").isNormalized()).isFalse(); - assertThat(PathFragment.create("C:/absolute/../path").isNormalized()).isFalse(); + public void testIsAbsoluteWindowsBackslash() { + assertThat(create(new File("C:\\blah").getPath()).isAbsolute()).isTrue(); + assertThat(create(new File("C:\\").getPath()).isAbsolute()).isTrue(); + assertThat(create(new File("\\blah").getPath()).isAbsolute()).isTrue(); + assertThat(create(new File("\\").getPath()).isAbsolute()).isTrue(); } @Test public void testRootNodeReturnsRootStringWindows() { - PathFragment rootFragment = PathFragment.create("C:/"); - assertThat(rootFragment.getPathString()).isEqualTo("C:/"); + assertThat(create("C:/").getPathString()).isEqualTo("C:/"); } @Test public void testGetRelativeWindows() { - assertThat(PathFragment.create("C:/a").getRelative("b").getPathString()).isEqualTo("C:/a/b"); - assertThat(PathFragment.create("C:/a/b").getRelative("c/d").getPathString()) - .isEqualTo("C:/a/b/c/d"); - assertThat(PathFragment.create("C:/a").getRelative("C:/b").getPathString()).isEqualTo("C:/b"); - assertThat(PathFragment.create("C:/a/b").getRelative("C:/c/d").getPathString()) - .isEqualTo("C:/c/d"); - assertThat(PathFragment.create("a").getRelative("C:/b").getPathString()).isEqualTo("C:/b"); - assertThat(PathFragment.create("a/b").getRelative("C:/c/d").getPathString()) - .isEqualTo("C:/c/d"); - } - - private void assertGetRelative(String path, String relative, PathFragment expected) - throws Exception { - PathFragment actual = PathFragment.create(path).getRelative(relative); - assertThat(actual.getPathString()).isEqualTo(expected.getPathString()); - assertThat(actual).isEqualTo(expected); - assertThat(actual.getDriveLetter()).isEqualTo(expected.getDriveLetter()); - assertThat(actual.hashCode()).isEqualTo(expected.hashCode()); - } - - private void assertRelativeTo(String path, String relativeTo, String... expectedPathSegments) - throws Exception { - PathFragment expected = PathFragment.createAlreadyInterned('\0', false, expectedPathSegments); - PathFragment actual = PathFragment.create(path).relativeTo(relativeTo); - assertThat(actual.getPathString()).isEqualTo(expected.getPathString()); - assertThat(actual).isEqualTo(expected); - assertThat(actual.getDriveLetter()).isEqualTo(expected.getDriveLetter()); - assertThat(actual.hashCode()).isEqualTo(expected.hashCode()); - } - - private void assertCantComputeRelativeTo(String path, String relativeTo) throws Exception { - try { - PathFragment.create(path).relativeTo(relativeTo); - fail("expected failure"); - } catch (Exception e) { - assertThat(e).hasMessageThat().contains("is not beneath"); - } - } - - private static PathFragment makePath(char drive, boolean absolute, String... segments) { - return PathFragment.createAlreadyInterned(drive, absolute, segments); + assertThat(create("C:/a").getRelative("b").getPathString()).isEqualTo("C:/a/b"); + assertThat(create("C:/a/b").getRelative("c/d").getPathString()).isEqualTo("C:/a/b/c/d"); + assertThat(create("C:/a").getRelative("C:/b").getPathString()).isEqualTo("C:/b"); + assertThat(create("C:/a/b").getRelative("C:/c/d").getPathString()).isEqualTo("C:/c/d"); + assertThat(create("a").getRelative("C:/b").getPathString()).isEqualTo("C:/b"); + assertThat(create("a/b").getRelative("C:/c/d").getPathString()).isEqualTo("C:/c/d"); } @Test public void testGetRelativeMixed() throws Exception { - assertGetRelative("a", "b", makePath('\0', false, "a", "b")); - assertGetRelative("a", "/b", makePath('\0', true, "b")); - assertGetRelative("a", "E:/b", makePath('E', true, "b")); + assertThat(create("a").getRelative("b")).isEqualTo(create("a/b")); + assertThat(create("a").getRelative("/b")).isEqualTo(create("/b")); + assertThat(create("a").getRelative("E:/b")).isEqualTo(create("E:/b")); - assertGetRelative("/a", "b", makePath('\0', true, "a", "b")); - assertGetRelative("/a", "/b", makePath('\0', true, "b")); - assertGetRelative("/a", "E:/b", makePath('E', true, "b")); + assertThat(create("/a").getRelative("b")).isEqualTo(create("/a/b")); + assertThat(create("/a").getRelative("/b")).isEqualTo(create("/b")); + assertThat(create("/a").getRelative("E:/b")).isEqualTo(create("E:/b")); - assertGetRelative("D:/a", "b", makePath('D', true, "a", "b")); - assertGetRelative("D:/a", "/b", makePath('D', true, "b")); - assertGetRelative("D:/a", "E:/b", makePath('E', true, "b")); + assertThat(create("D:/a").getRelative("b")).isEqualTo(create("D:/a/b")); + assertThat(create("D:/a").getRelative("/b")).isEqualTo(create("/b")); + assertThat(create("D:/a").getRelative("E:/b")).isEqualTo(create("E:/b")); } @Test public void testRelativeTo() throws Exception { - assertRelativeTo("", ""); - assertCantComputeRelativeTo("", "a"); + assertThat(create("").relativeTo("").getPathString()).isEqualTo(""); + MoreAsserts.expectThrows(IllegalArgumentException.class, () -> create("").relativeTo("a")); - assertRelativeTo("a", "", "a"); - assertRelativeTo("a", "a"); - assertCantComputeRelativeTo("a", "b"); - assertRelativeTo("a/b", "a", "b"); + assertThat(create("a").relativeTo("")).isEqualTo(create("a")); + assertThat(create("a").relativeTo("a").getPathString()).isEqualTo(""); + MoreAsserts.expectThrows(IllegalArgumentException.class, () -> create("a").relativeTo("b")); + assertThat(create("a/b").relativeTo("a")).isEqualTo(create("b")); - assertCantComputeRelativeTo("C:/", ""); - assertRelativeTo("C:/", "C:/"); + MoreAsserts.expectThrows(IllegalArgumentException.class, () -> create("C:/").relativeTo("")); + assertThat(create("C:/").relativeTo("C:/").getPathString()).isEqualTo(""); } @Test public void testGetChildWorks() { - PathFragment pf = PathFragment.create("../some/path"); - assertThat(pf.getChild("hi")).isEqualTo(PathFragment.create("../some/path/hi")); - } - - // Tests after here test the canonicalization - private void assertRegular(String expected, String actual) { - PathFragment exp = PathFragment.create(expected); - PathFragment act = PathFragment.create(actual); - assertThat(exp.getPathString()).isEqualTo(expected); - assertThat(act.getPathString()).isEqualTo(expected); - assertThat(act).isEqualTo(exp); - assertThat(act.hashCode()).isEqualTo(exp.hashCode()); + assertThat(create("../some/path").getChild("hi")).isEqualTo(create("../some/path/hi")); } @Test public void testEmptyPathToEmptyPathWindows() { - assertRegular("C:/", "C:/"); - } - - private void assertAllEqual(PathFragment... ps) { - assertThat(ps.length).isGreaterThan(1); - for (int i = 1; i < ps.length; i++) { - String msg = "comparing items 0 and " + i; - assertWithMessage(msg + " for getPathString") - .that(ps[i].getPathString()) - .isEqualTo(ps[0].getPathString()); - assertWithMessage(msg + " for equals").that(ps[0]).isEqualTo(ps[i]); - assertWithMessage(msg + " for hashCode").that(ps[0].hashCode()).isEqualTo(ps[i].hashCode()); - } - } - - @Test - public void testEmptyRelativePathToEmptyPathWindows() { - // Surprising but correct behavior: a PathFragment made of just a drive identifier (and not the - // absolute path "C:/") is equal not only to the empty fragment, but (therefore) also to other - // drive identifiers. - // This makes sense if you consider that these are still empty paths, the drive letter adds no - // information to the path itself. - assertAllEqual( - PathFragment.EMPTY_FRAGMENT, - PathFragment.createAlreadyInterned('\0', false, new String[0]), - PathFragment.createAlreadyInterned('C', false, new String[0]), - PathFragment.createAlreadyInterned('D', false, new String[0])); - assertAllEqual(PathFragment.create("/c"), PathFragment.create("/c/")); - assertThat(PathFragment.create("C:/")).isNotEqualTo(PathFragment.create("/c")); - assertThat(PathFragment.create("C:/foo")).isNotEqualTo(PathFragment.create("/c/foo")); - - assertThat(PathFragment.create("C:/")).isNotEqualTo(PathFragment.create("C:")); - assertThat(PathFragment.create("C:/").getPathString()) - .isNotEqualTo(PathFragment.create("C:").getPathString()); + assertThat(create("C:/")).isEqualTo(create("C:/")); } @Test public void testWindowsVolumeUppercase() { - assertRegular("C:/", "c:/"); + assertThat(create("C:/")).isEqualTo(create("c:/")); } @Test public void testRedundantSlashesWindows() { - assertRegular("C:/", "C:///"); - assertRegular("C:/foo/bar", "C:/foo///bar"); - assertRegular("C:/foo/bar", "C:////foo//bar"); + assertThat(create("C:/")).isEqualTo(create("C:///")); + assertThat(create("C:/foo/bar")).isEqualTo(create("C:/foo///bar")); + assertThat(create("C:/foo/bar")).isEqualTo(create("C:////foo//bar")); } @Test public void testSimpleNameToSimpleNameWindows() { - assertRegular("C:/foo", "C:/foo"); + assertThat(create("C:/foo")).isEqualTo(create("C:/foo")); } @Test public void testStripsTrailingSlashWindows() { - assertRegular("C:/foo/bar", "C:/foo/bar/"); + assertThat(create("C:/foo/bar")).isEqualTo(create("C:/foo/bar/")); } @Test public void testGetParentDirectoryWindows() { - PathFragment fooBarWizAbs = PathFragment.create("C:/foo/bar/wiz"); - PathFragment fooBarAbs = PathFragment.create("C:/foo/bar"); - PathFragment fooAbs = PathFragment.create("C:/foo"); - PathFragment rootAbs = PathFragment.create("C:/"); - assertThat(fooBarWizAbs.getParentDirectory()).isEqualTo(fooBarAbs); - assertThat(fooBarAbs.getParentDirectory()).isEqualTo(fooAbs); - assertThat(fooAbs.getParentDirectory()).isEqualTo(rootAbs); - assertThat(rootAbs.getParentDirectory()).isNull(); - - // Note, this is suprising but correct behaviour: - assertThat(PathFragment.create("C:/foo/bar/..").getParentDirectory()).isEqualTo(fooBarAbs); + assertThat(create("C:/foo/bar/wiz").getParentDirectory()).isEqualTo(create("C:/foo/bar")); + assertThat(create("C:/foo/bar").getParentDirectory()).isEqualTo(create("C:/foo")); + assertThat(create("C:/foo").getParentDirectory()).isEqualTo(create("C:/")); + assertThat(create("C:/").getParentDirectory()).isNull(); } @Test public void testSegmentsCountWindows() { - assertThat(PathFragment.create("C:/foo").segmentCount()).isEqualTo(1); - assertThat(PathFragment.create("C:/").segmentCount()).isEqualTo(0); + assertThat(create("C:/foo").segmentCount()).isEqualTo(1); + assertThat(create("C:/").segmentCount()).isEqualTo(0); } @Test public void testGetSegmentWindows() { - assertThat(PathFragment.create("C:/foo/bar").getSegment(0)).isEqualTo("foo"); - assertThat(PathFragment.create("C:/foo/bar").getSegment(1)).isEqualTo("bar"); - assertThat(PathFragment.create("C:/foo/").getSegment(0)).isEqualTo("foo"); - assertThat(PathFragment.create("C:/foo").getSegment(0)).isEqualTo("foo"); + assertThat(create("C:/foo/bar").getSegment(0)).isEqualTo("foo"); + assertThat(create("C:/foo/bar").getSegment(1)).isEqualTo("bar"); + assertThat(create("C:/foo/").getSegment(0)).isEqualTo("foo"); + assertThat(create("C:/foo").getSegment(0)).isEqualTo("foo"); } @Test public void testBasenameWindows() throws Exception { - assertThat(PathFragment.create("C:/foo/bar").getBaseName()).isEqualTo("bar"); - assertThat(PathFragment.create("C:/foo").getBaseName()).isEqualTo("foo"); + assertThat(create("C:/foo/bar").getBaseName()).isEqualTo("bar"); + assertThat(create("C:/foo").getBaseName()).isEqualTo("foo"); // Never return the drive name as a basename. - assertThat(PathFragment.create("C:/").getBaseName()).isEmpty(); - } - - private static void assertPath(String expected, PathFragment actual) { - assertThat(actual.getPathString()).isEqualTo(expected); + assertThat(create("C:/").getBaseName()).isEmpty(); } @Test public void testReplaceNameWindows() throws Exception { - assertPath("C:/foo/baz", PathFragment.create("C:/foo/bar").replaceName("baz")); - assertThat(PathFragment.create("C:/").replaceName("baz")).isNull(); + assertThat(create("C:/foo/bar").replaceName("baz").getPathString()).isEqualTo("C:/foo/baz"); + assertThat(create("C:/").replaceName("baz")).isNull(); } @Test public void testStartsWithWindows() { - assertThat(PathFragment.create("C:/foo/bar").startsWith(PathFragment.create("C:/foo"))) - .isTrue(); - assertThat(PathFragment.create("C:/foo/bar").startsWith(PathFragment.create("C:/"))).isTrue(); - assertThat(PathFragment.create("C:/").startsWith(PathFragment.create("C:/"))).isTrue(); + assertThat(create("C:/foo/bar").startsWith(create("C:/foo"))).isTrue(); + assertThat(create("C:/foo/bar").startsWith(create("C:/"))).isTrue(); + assertThat(create("C:/").startsWith(create("C:/"))).isTrue(); // The first path is absolute, the second is not. - assertThat(PathFragment.create("C:/foo/bar").startsWith(PathFragment.create("C:"))).isFalse(); - assertThat(PathFragment.create("C:/").startsWith(PathFragment.create("C:"))).isFalse(); + assertThat(create("C:/foo/bar").startsWith(create("C:"))).isFalse(); + assertThat(create("C:/").startsWith(create("C:"))).isFalse(); } @Test public void testEndsWithWindows() { - assertThat(PathFragment.create("C:/foo/bar").endsWith(PathFragment.create("bar"))).isTrue(); - assertThat(PathFragment.create("C:/foo/bar").endsWith(PathFragment.create("foo/bar"))).isTrue(); - assertThat(PathFragment.create("C:/foo/bar").endsWith(PathFragment.create("C:/foo/bar"))) - .isTrue(); - assertThat(PathFragment.create("C:/").endsWith(PathFragment.create("C:/"))).isTrue(); + assertThat(create("C:/foo/bar").endsWith(create("bar"))).isTrue(); + assertThat(create("C:/foo/bar").endsWith(create("foo/bar"))).isTrue(); + assertThat(create("C:/foo/bar").endsWith(create("C:/foo/bar"))).isTrue(); + assertThat(create("C:/").endsWith(create("C:/"))).isTrue(); } @Test public void testGetSafePathStringWindows() { - assertThat(PathFragment.create("C:/").getSafePathString()).isEqualTo("C:/"); - assertThat(PathFragment.create("C:/abc").getSafePathString()).isEqualTo("C:/abc"); - assertThat(PathFragment.create("C:/abc/def").getSafePathString()).isEqualTo("C:/abc/def"); + assertThat(create("C:/").getSafePathString()).isEqualTo("C:/"); + assertThat(create("C:/abc").getSafePathString()).isEqualTo("C:/abc"); + assertThat(create("C:/abc/def").getSafePathString()).isEqualTo("C:/abc/def"); } @Test public void testNormalizeWindows() { - assertThat(PathFragment.create("C:/a/b").normalize()).isEqualTo(PathFragment.create("C:/a/b")); - assertThat(PathFragment.create("C:/a/./b").normalize()) - .isEqualTo(PathFragment.create("C:/a/b")); - assertThat(PathFragment.create("C:/a/../b").normalize()).isEqualTo(PathFragment.create("C:/b")); - assertThat(PathFragment.create("C:/../b").normalize()) - .isEqualTo(PathFragment.create("C:/../b")); + assertThat(create("C:/a/b")).isEqualTo(create("C:/a/b")); + assertThat(create("C:/a/./b")).isEqualTo(create("C:/a/b")); + assertThat(create("C:/a/../b")).isEqualTo(create("C:/b")); + assertThat(create("C:/../b")).isEqualTo(create("C:/../b")); } @Test @@ -335,8 +231,21 @@ public class PathFragmentWindowsTest { // of drive C:\". // Bazel doesn't resolve such paths, and just takes them literally like normal path segments. // If the user attempts to open files under such paths, the file system API will give an error. - assertThat(PathFragment.create("C:").isAbsolute()).isFalse(); - assertThat(PathFragment.create("C:").getDriveLetter()).isEqualTo('\0'); - assertThat(PathFragment.create("C:").getSegments()).containsExactly("C:"); + assertThat(create("C:").isAbsolute()).isFalse(); + assertThat(create("C:").getSegments()).containsExactly("C:"); + } + + @Test + public void testToRelative() { + assertThat(create("C:/foo/bar").toRelative()).isEqualTo(create("foo/bar")); + assertThat(create("C:/").toRelative()).isEqualTo(create("")); + MoreAsserts.expectThrows(IllegalArgumentException.class, () -> create("foo").toRelative()); + } + + @Test + public void testGetDriveStr() { + assertThat(create("C:/foo/bar").getDriveStr()).isEqualTo("C:/"); + assertThat(create("C:/").getDriveStr()).isEqualTo("C:/"); + MoreAsserts.expectThrows(IllegalArgumentException.class, () -> create("foo").getDriveStr()); } } diff --git a/src/test/java/com/google/devtools/build/lib/vfs/PathTest.java b/src/test/java/com/google/devtools/build/lib/vfs/PathTest.java deleted file mode 100644 index eaad458438..0000000000 --- a/src/test/java/com/google/devtools/build/lib/vfs/PathTest.java +++ /dev/null @@ -1,341 +0,0 @@ -// 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 org.junit.Assert.fail; - -import com.google.common.collect.ImmutableList; -import com.google.common.collect.Lists; -import com.google.common.testing.EqualsTester; -import com.google.common.testing.GcFinalization; -import com.google.devtools.build.lib.clock.BlazeClock; -import com.google.devtools.build.lib.skyframe.serialization.InjectingObjectCodecAdapter; -import com.google.devtools.build.lib.skyframe.serialization.testutils.FsUtils; -import com.google.devtools.build.lib.skyframe.serialization.testutils.ObjectCodecTester; -import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem; -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.ObjectInputStream; -import java.io.ObjectOutputStream; -import java.lang.ref.WeakReference; -import java.net.URI; -import java.util.Collections; -import java.util.List; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.JUnit4; - -/** - * A test for {@link Path}. - */ -@RunWith(JUnit4.class) -public class PathTest { - private FileSystem filesystem; - private Path root; - - @Before - public final void initializeFileSystem() throws Exception { - filesystem = new InMemoryFileSystem(BlazeClock.instance()); - root = filesystem.getRootDirectory(); - Path first = root.getChild("first"); - first.createDirectory(); - } - - @Test - public void testStartsWithWorksForSelf() { - assertStartsWithReturns(true, "/first/child", "/first/child"); - } - - @Test - public void testStartsWithWorksForChild() { - assertStartsWithReturns(true, - "/first/child", "/first/child/grandchild"); - } - - @Test - public void testStartsWithWorksForDeepDescendant() { - assertStartsWithReturns(true, - "/first/child", "/first/child/grandchild/x/y/z"); - } - - @Test - public void testStartsWithFailsForParent() { - assertStartsWithReturns(false, "/first/child", "/first"); - } - - @Test - public void testStartsWithFailsForSibling() { - assertStartsWithReturns(false, "/first/child", "/first/child2"); - } - - @Test - public void testStartsWithFailsForLinkToDescendant() - throws Exception { - Path linkTarget = filesystem.getPath("/first/linked_to"); - FileSystemUtils.createEmptyFile(linkTarget); - Path second = filesystem.getPath("/second/"); - second.createDirectory(); - second.getChild("child_link").createSymbolicLink(linkTarget); - assertStartsWithReturns(false, "/first", "/second/child_link"); - } - - @Test - public void testStartsWithFailsForNullPrefix() { - try { - filesystem.getPath("/first").startsWith(null); - fail(); - } catch (Exception e) { - } - } - - private void assertStartsWithReturns(boolean expected, - String ancestor, - String descendant) { - Path parent = filesystem.getPath(ancestor); - Path child = filesystem.getPath(descendant); - assertThat(child.startsWith(parent)).isEqualTo(expected); - } - - @Test - public void testGetChildWorks() { - assertGetChildWorks("second"); - assertGetChildWorks("..."); - assertGetChildWorks("...."); - } - - private void assertGetChildWorks(String childName) { - assertThat(filesystem.getPath("/first").getChild(childName)) - .isEqualTo(filesystem.getPath("/first/" + childName)); - } - - @Test - public void testGetChildFailsForChildWithSlashes() { - assertGetChildFails("second/third"); - assertGetChildFails("./third"); - assertGetChildFails("../third"); - assertGetChildFails("second/.."); - assertGetChildFails("second/."); - assertGetChildFails("/third"); - assertGetChildFails("third/"); - } - - private void assertGetChildFails(String childName) { - try { - filesystem.getPath("/first").getChild(childName); - fail(); - } catch (IllegalArgumentException e) { - // Expected. - } - } - - @Test - public void testGetChildFailsForDotAndDotDot() { - assertGetChildFails("."); - assertGetChildFails(".."); - } - - @Test - public void testGetChildFailsForEmptyString() { - assertGetChildFails(""); - } - - @Test - public void testRelativeToWorks() { - assertRelativeToWorks("apple", "/fruit/apple", "/fruit"); - assertRelativeToWorks("apple/jonagold", "/fruit/apple/jonagold", "/fruit"); - } - - @Test - public void testGetRelativeWithStringWorks() { - assertGetRelativeWorks("/first/x/y", "y"); - assertGetRelativeWorks("/y", "/y"); - assertGetRelativeWorks("/first/x/x", "./x"); - assertGetRelativeWorks("/first/y", "../y"); - assertGetRelativeWorks("/", "../../../../.."); - } - - @Test - public void testAsFragmentWorks() { - assertAsFragmentWorks("/"); - assertAsFragmentWorks("//"); - assertAsFragmentWorks("/first"); - assertAsFragmentWorks("/first/x/y"); - assertAsFragmentWorks("/first/x/y.foo"); - } - - @Test - public void testGetRelativeWithFragmentWorks() { - Path dir = filesystem.getPath("/first/x"); - assertThat(dir.getRelative(PathFragment.create("y")).toString()).isEqualTo("/first/x/y"); - assertThat(dir.getRelative(PathFragment.create("./x")).toString()).isEqualTo("/first/x/x"); - assertThat(dir.getRelative(PathFragment.create("../y")).toString()).isEqualTo("/first/y"); - } - - @Test - public void testGetRelativeWithAbsoluteFragmentWorks() { - Path root = filesystem.getPath("/first/x"); - assertThat(root.getRelative(PathFragment.create("/x/y")).toString()).isEqualTo("/x/y"); - } - - @Test - public void testGetRelativeWithAbsoluteStringWorks() { - Path root = filesystem.getPath("/first/x"); - assertThat(root.getRelative("/x/y").toString()).isEqualTo("/x/y"); - } - - @Test - public void testComparableSortOrder() { - Path zzz = filesystem.getPath("/zzz"); - Path ZZZ = filesystem.getPath("/ZZZ"); - Path abc = filesystem.getPath("/abc"); - Path aBc = filesystem.getPath("/aBc"); - Path AbC = filesystem.getPath("/AbC"); - Path ABC = filesystem.getPath("/ABC"); - List<Path> list = Lists.newArrayList(zzz, ZZZ, ABC, aBc, AbC, abc); - Collections.sort(list); - assertThat(list).containsExactly(ABC, AbC, ZZZ, aBc, abc, zzz).inOrder(); - } - - @Test - public void testParentOfRootIsRoot() { - assertThat(root.getRelative("..")).isSameAs(root); - - assertThat(root.getRelative("broken/../../dots")).isSameAs(root.getRelative("dots")); - } - - @Test - public void testSingleSegmentEquivalence() { - assertThat(root.getRelative("aSingleSegment")).isSameAs(root.getRelative("aSingleSegment")); - } - - @Test - public void testSiblingNonEquivalenceString() { - assertThat(root.getRelative("aDifferentSegment")) - .isNotSameAs(root.getRelative("aSingleSegment")); - } - - @Test - public void testSiblingNonEquivalenceFragment() { - assertThat(root.getRelative(PathFragment.create("aDifferentSegment"))) - .isNotSameAs(root.getRelative(PathFragment.create("aSingleSegment"))); - } - - @Test - public void testHashCodeStableAcrossGarbageCollections() { - Path parent = filesystem.getPath("/a"); - PathFragment childFragment = PathFragment.create("b"); - Path child = parent.getRelative(childFragment); - WeakReference<Path> childRef = new WeakReference<>(child); - int childHashCode1 = childRef.get().hashCode(); - assertThat(parent.getRelative(childFragment).hashCode()).isEqualTo(childHashCode1); - child = null; - GcFinalization.awaitClear(childRef); - int childHashCode2 = parent.getRelative(childFragment).hashCode(); - assertThat(childHashCode2).isEqualTo(childHashCode1); - } - - @Test - public void testSerialization() throws Exception { - FileSystem oldFileSystem = Path.getFileSystemForSerialization(); - try { - Path.setFileSystemForSerialization(filesystem); - Path root = filesystem.getPath("/"); - Path p1 = filesystem.getPath("/foo"); - Path p2 = filesystem.getPath("/foo/bar"); - - ByteArrayOutputStream bos = new ByteArrayOutputStream(); - ObjectOutputStream oos = new ObjectOutputStream(bos); - - oos.writeObject(root); - oos.writeObject(p1); - oos.writeObject(p2); - - ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); - ObjectInputStream ois = new ObjectInputStream(bis); - - Path dsRoot = (Path) ois.readObject(); - Path dsP1 = (Path) ois.readObject(); - Path dsP2 = (Path) ois.readObject(); - - new EqualsTester() - .addEqualityGroup(root, dsRoot) - .addEqualityGroup(p1, dsP1) - .addEqualityGroup(p2, dsP2) - .testEquals(); - - assertThat(p2.startsWith(p1)).isTrue(); - assertThat(p2.startsWith(dsP1)).isTrue(); - assertThat(dsP2.startsWith(p1)).isTrue(); - assertThat(dsP2.startsWith(dsP1)).isTrue(); - - // Regression test for a very specific bug in compareTo involving our incorrect usage of - // reference equality rather than logical equality. - String relativePathStringA = "child/grandchildA"; - String relativePathStringB = "child/grandchildB"; - assertThat( - p1.getRelative(relativePathStringA).compareTo(dsP1.getRelative(relativePathStringB))) - .isEqualTo( - p1.getRelative(relativePathStringA).compareTo(p1.getRelative(relativePathStringB))); - } finally { - Path.setFileSystemForSerialization(oldFileSystem); - } - } - - @Test - public void testAbsolutePathRoot() { - assertThat(new Path(null).toString()).isEqualTo("/"); - } - - @Test - public void testAbsolutePath() { - Path segment = new Path(null, "bar.txt", - new Path(null, "foo", new Path(null))); - assertThat(segment.toString()).isEqualTo("/foo/bar.txt"); - } - - @Test - public void testToURI() throws Exception { - Path p = root.getRelative("/tmp/foo bar.txt"); - URI uri = p.toURI(); - assertThat(uri.toString()).isEqualTo("file:///tmp/foo%20bar.txt"); - } - - @Test - public void testCodec() throws Exception { - ObjectCodecTester.newBuilder( - new InjectingObjectCodecAdapter<>(Path.CODEC, FsUtils.TEST_FILESYSTEM_PROVIDER)) - .addSubjects( - ImmutableList.of( - FsUtils.TEST_FILESYSTEM.getPath("/"), - FsUtils.TEST_FILESYSTEM.getPath("/some/path"), - FsUtils.TEST_FILESYSTEM.getPath("/some/other/path/with/empty/last/fragment/"))) - .buildAndRunTests(); - } - - private void assertAsFragmentWorks(String expected) { - assertThat(filesystem.getPath(expected).asFragment()).isEqualTo(PathFragment.create(expected)); - } - - private void assertGetRelativeWorks(String expected, String relative) { - assertThat(filesystem.getPath("/first/x").getRelative(relative)) - .isEqualTo(filesystem.getPath(expected)); - } - - private void assertRelativeToWorks(String expected, String relative, String original) { - assertThat(filesystem.getPath(relative).relativeTo(filesystem.getPath(original))) - .isEqualTo(PathFragment.create(expected)); - } -} diff --git a/src/test/java/com/google/devtools/build/lib/vfs/PathTrieTest.java b/src/test/java/com/google/devtools/build/lib/vfs/PathTrieTest.java deleted file mode 100644 index 0807b4aa5d..0000000000 --- a/src/test/java/com/google/devtools/build/lib/vfs/PathTrieTest.java +++ /dev/null @@ -1,78 +0,0 @@ -// 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.testutil.MoreAsserts.assertThrows; - -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.JUnit4; - -/** Unit tests for {@link PathTrie}. */ -@RunWith(JUnit4.class) -public class PathTrieTest { - @Test - public void empty() { - PathTrie<Integer> pathTrie = new PathTrie<>(); - assertThat(pathTrie.get(PathFragment.EMPTY_FRAGMENT)).isNull(); - assertThat(pathTrie.get(PathFragment.create("/x"))).isNull(); - assertThat(pathTrie.get(PathFragment.create("/x/y"))).isNull(); - } - - @Test - public void simpleBranches() { - PathTrie<Integer> pathTrie = new PathTrie<>(); - pathTrie.put(PathFragment.create("/a"), 1); - pathTrie.put(PathFragment.create("/b"), 2); - - assertThat(pathTrie.get(PathFragment.EMPTY_FRAGMENT)).isNull(); - assertThat(pathTrie.get(PathFragment.create("/a"))).isEqualTo(1); - assertThat(pathTrie.get(PathFragment.create("/a/b"))).isEqualTo(1); - assertThat(pathTrie.get(PathFragment.create("/a/b/c"))).isEqualTo(1); - assertThat(pathTrie.get(PathFragment.create("/b"))).isEqualTo(2); - assertThat(pathTrie.get(PathFragment.create("/b/c"))).isEqualTo(2); - } - - @Test - public void nestedDirectories() { - PathTrie<Integer> pathTrie = new PathTrie<>(); - pathTrie.put(PathFragment.create("/a/b/c"), 3); - assertThat(pathTrie.get(PathFragment.EMPTY_FRAGMENT)).isNull(); - assertThat(pathTrie.get(PathFragment.create("/a"))).isNull(); - assertThat(pathTrie.get(PathFragment.create("/a/b"))).isNull(); - assertThat(pathTrie.get(PathFragment.create("/a/b/c"))).isEqualTo(3); - assertThat(pathTrie.get(PathFragment.create("/a/b/c/d"))).isEqualTo(3); - - pathTrie.put(PathFragment.create("/a"), 1); - assertThat(pathTrie.get(PathFragment.EMPTY_FRAGMENT)).isNull(); - assertThat(pathTrie.get(PathFragment.create("/b"))).isNull(); - assertThat(pathTrie.get(PathFragment.create("/a"))).isEqualTo(1); - assertThat(pathTrie.get(PathFragment.create("/a/b"))).isEqualTo(1); - assertThat(pathTrie.get(PathFragment.create("/a/b/c"))).isEqualTo(3); - assertThat(pathTrie.get(PathFragment.create("/a/b/c/d"))).isEqualTo(3); - - pathTrie.put(PathFragment.ROOT_FRAGMENT, 0); - assertThat(pathTrie.get(PathFragment.EMPTY_FRAGMENT)).isEqualTo(0); - assertThat(pathTrie.get(PathFragment.create("/b"))).isEqualTo(0); - assertThat(pathTrie.get(PathFragment.create("/a"))).isEqualTo(1); - assertThat(pathTrie.get(PathFragment.create("/a/b"))).isEqualTo(1); - } - - @Test - public void unrootedDirectoriesError() { - PathTrie<Integer> pathTrie = new PathTrie<>(); - assertThrows(IllegalArgumentException.class, () -> pathTrie.put(PathFragment.create("a"), 1)); - } -} diff --git a/src/test/java/com/google/devtools/build/lib/vfs/SymlinkAwareFileSystemTest.java b/src/test/java/com/google/devtools/build/lib/vfs/SymlinkAwareFileSystemTest.java index 4720a6e773..ba7029daf2 100644 --- a/src/test/java/com/google/devtools/build/lib/vfs/SymlinkAwareFileSystemTest.java +++ b/src/test/java/com/google/devtools/build/lib/vfs/SymlinkAwareFileSystemTest.java @@ -16,6 +16,7 @@ package com.google.devtools.build.lib.vfs; import static com.google.common.truth.Truth.assertThat; import static org.junit.Assert.fail; +import com.google.devtools.build.lib.util.OS; import com.google.devtools.build.lib.vfs.FileSystem.NotASymlinkException; import java.io.FileNotFoundException; import java.io.IOException; @@ -197,7 +198,8 @@ public abstract class SymlinkAwareFileSystemTest extends FileSystemTest { linkPath.delete(); createSymbolicLink(linkPath, relative); if (testFS.supportsSymbolicLinksNatively(linkPath)) { - assertThat(linkPath.getFileSize(Symlinks.NOFOLLOW)).isEqualTo(linkTarget.length()); + assertThat(linkPath.getFileSize(Symlinks.NOFOLLOW)) + .isEqualTo(relative.getSafePathString().length()); assertThat(linkPath.readSymbolicLink()).isEqualTo(relative); } } @@ -205,6 +207,10 @@ public abstract class SymlinkAwareFileSystemTest extends FileSystemTest { @Test public void testLinkToRootResolvesCorrectly() throws IOException { + if (OS.getCurrent() == OS.WINDOWS) { + // This test cannot be run on Windows, it mixes "/" paths with "C:/" paths + return; + } Path rootPath = testFS.getPath("/"); try { diff --git a/src/test/java/com/google/devtools/build/lib/vfs/UnionFileSystemTest.java b/src/test/java/com/google/devtools/build/lib/vfs/UnionFileSystemTest.java index 1e877a5255..3799cfdd46 100644 --- a/src/test/java/com/google/devtools/build/lib/vfs/UnionFileSystemTest.java +++ b/src/test/java/com/google/devtools/build/lib/vfs/UnionFileSystemTest.java @@ -163,7 +163,7 @@ public class UnionFileSystemTest extends SymlinkAwareFileSystemTest { // FileSystemTest.setUp() silently creates the test root on the filesystem... Path testDirUnderRoot = unionfs.getPath(workingDir.asFragment().subFragment(0, 1)); - assertThat(unionfs.getDirectoryEntries(unionfs.getRootDirectory())) + assertThat(unionfs.getDirectoryEntries(unionfs.getPath("/"))) .containsExactly( foo.getBaseName(), bar.getBaseName(), diff --git a/src/test/java/com/google/devtools/build/lib/vfs/UnixLocalPathTest.java b/src/test/java/com/google/devtools/build/lib/vfs/UnixPathTest.java index 2cdb4014ae..306ca9bc08 100644 --- a/src/test/java/com/google/devtools/build/lib/vfs/UnixLocalPathTest.java +++ b/src/test/java/com/google/devtools/build/lib/vfs/UnixPathTest.java @@ -17,15 +17,13 @@ import static com.google.common.truth.Truth.assertThat; import static com.google.devtools.build.lib.testutil.MoreAsserts.assertThrows; import com.google.common.testing.EqualsTester; -import com.google.devtools.build.lib.vfs.LocalPath.OsPathPolicy; -import com.google.devtools.build.lib.vfs.LocalPath.UnixOsPathPolicy; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; -/** Tests the unix implementation of {@link LocalPath}. */ +/** Tests the unix implementation of {@link Path}. */ @RunWith(JUnit4.class) -public class UnixLocalPathTest extends LocalPathAbstractTest { +public class UnixPathTest extends PathAbstractTest { @Test public void testEqualsAndHashCodeUnix() { @@ -37,8 +35,6 @@ public class UnixLocalPathTest extends LocalPathAbstractTest { @Test public void testRelativeToUnix() { - // Cannot relativize absolute and non-absolute - assertThat(create("c/d").getRelative("/a/b").getPathString()).isEqualTo("/a/b"); assertThat(create("/").relativeTo(create("/")).getPathString()).isEmpty(); assertThat(create("/foo").relativeTo(create("/foo")).getPathString()).isEmpty(); assertThat(create("/foo/bar/baz").relativeTo(create("/foo")).getPathString()) @@ -53,16 +49,24 @@ public class UnixLocalPathTest extends LocalPathAbstractTest { } @Test - public void testIsAbsoluteUnix() { - assertThat(create("/absolute/test").isAbsolute()).isTrue(); - assertThat(create("relative/test").isAbsolute()).isFalse(); - } - - @Test public void testGetRelativeUnix() { assertThat(create("/a").getRelative("b").getPathString()).isEqualTo("/a/b"); + assertThat(create("/a/b").getRelative("c/d").getPathString()).isEqualTo("/a/b/c/d"); + assertThat(create("/c/d").getRelative("/a/b").getPathString()).isEqualTo("/a/b"); + assertThat(create("/a").getRelative("").getPathString()).isEqualTo("/a"); assertThat(create("/").getRelative("").getPathString()).isEqualTo("/"); - assertThat(create("c/d").getRelative("/a/b").getPathString()).isEqualTo("/a/b"); + assertThat(create("/a/b").getRelative("../foo").getPathString()).isEqualTo("/a/foo"); + + // Make sure any fast path of Path#getRelative(PathFragment) works + assertThat(create("/a/b").getRelative(PathFragment.create("../foo")).getPathString()) + .isEqualTo("/a/foo"); + + // Make sure any fast path of Path#getRelative(PathFragment) works + assertThat(create("/c/d").getRelative(PathFragment.create("/a/b")).getPathString()) + .isEqualTo("/a/b"); + + // Test normalization + assertThat(create("/a").getRelative(".").getPathString()).isEqualTo("/a"); } @Test @@ -107,14 +111,10 @@ public class UnixLocalPathTest extends LocalPathAbstractTest { @Test public void testGetParentDirectoryUnix() { - LocalPath fooBarWizAbs = create("/foo/bar/wiz"); - LocalPath fooBarAbs = create("/foo/bar"); - LocalPath fooAbs = create("/foo"); - LocalPath rootAbs = create("/"); - assertThat(fooBarWizAbs.getParentDirectory()).isEqualTo(fooBarAbs); - assertThat(fooBarAbs.getParentDirectory()).isEqualTo(fooAbs); - assertThat(fooAbs.getParentDirectory()).isEqualTo(rootAbs); - assertThat(rootAbs.getParentDirectory()).isNull(); + assertThat(create("/foo/bar/wiz").getParentDirectory()).isEqualTo(create("/foo/bar")); + assertThat(create("/foo/bar").getParentDirectory()).isEqualTo(create("/foo")); + assertThat(create("/foo").getParentDirectory()).isEqualTo(create("/")); + assertThat(create("/").getParentDirectory()).isNull(); } @Test @@ -127,8 +127,7 @@ public class UnixLocalPathTest extends LocalPathAbstractTest { @Test public void testStartsWithUnix() { - LocalPath foobar = create("/foo/bar"); - LocalPath foobarRelative = create("foo/bar"); + Path foobar = create("/foo/bar"); // (path, prefix) => true assertThat(foobar.startsWith(foobar)).isTrue(); @@ -141,13 +140,6 @@ public class UnixLocalPathTest extends LocalPathAbstractTest { assertThat(create("/foo").startsWith(foobar)).isFalse(); assertThat(create("/").startsWith(foobar)).isFalse(); - // (absolute, relative) => false - assertThat(foobar.startsWith(foobarRelative)).isFalse(); - assertThat(foobarRelative.startsWith(foobar)).isFalse(); - - // relative paths start with nothing, absolute paths do not - assertThat(foobar.startsWith(create(""))).isFalse(); - // (path, sibling) => false assertThat(create("/foo/wiz").startsWith(foobar)).isFalse(); assertThat(foobar.startsWith(create("/foo/wiz"))).isFalse(); @@ -162,8 +154,10 @@ public class UnixLocalPathTest extends LocalPathAbstractTest { assertThat(create("/..")).isEqualTo(create("/..")); } - @Override - protected OsPathPolicy getFilePathOs() { - return new UnixOsPathPolicy(); + @Test + public void testParentOfRootIsRootUnix() { + assertThat(create("/..")).isEqualTo(create("/")); + assertThat(create("/../../../../../..")).isEqualTo(create("/")); + assertThat(create("/../../../foo")).isEqualTo(create("/foo")); } } diff --git a/src/test/java/com/google/devtools/build/lib/vfs/WindowsLocalPathTest.java b/src/test/java/com/google/devtools/build/lib/vfs/WindowsPathTest.java index ac5acef1f4..c7592197e1 100644 --- a/src/test/java/com/google/devtools/build/lib/vfs/WindowsLocalPathTest.java +++ b/src/test/java/com/google/devtools/build/lib/vfs/WindowsPathTest.java @@ -17,18 +17,16 @@ import static com.google.common.truth.Truth.assertThat; import com.google.common.testing.EqualsTester; import com.google.devtools.build.lib.testutil.MoreAsserts; -import com.google.devtools.build.lib.vfs.LocalPath.OsPathPolicy; -import com.google.devtools.build.lib.vfs.LocalPath.WindowsOsPathPolicy; -import com.google.devtools.build.lib.vfs.LocalPath.WindowsOsPathPolicy.ShortPathResolver; +import com.google.devtools.build.lib.vfs.WindowsOsPathPolicy.ShortPathResolver; import java.util.HashMap; import java.util.Map; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; -/** Tests windows-specific parts of {@link LocalPath} */ +/** Tests windows-specific parts of {@link Path} */ @RunWith(JUnit4.class) -public class WindowsLocalPathTest extends LocalPathAbstractTest { +public class WindowsPathTest extends PathAbstractTest { private static final class MockShortPathResolver implements ShortPathResolver { // Full path to resolved child mapping. @@ -52,26 +50,18 @@ public class WindowsLocalPathTest extends LocalPathAbstractTest { } } - private final MockShortPathResolver shortPathResolver = new MockShortPathResolver(); - - @Override - protected OsPathPolicy getFilePathOs() { - return new WindowsOsPathPolicy(shortPathResolver); - } - @Test public void testEqualsAndHashcodeWindows() { new EqualsTester() - .addEqualityGroup(create("a/b"), create("A/B")) .addEqualityGroup(create("/a/b"), create("/A/B")) .addEqualityGroup(create("c:/a/b"), create("C:\\A\\B")) - .addEqualityGroup(create("something/else")) + .addEqualityGroup(create("C:/something/else")) .testEquals(); } @Test public void testCaseIsPreserved() { - assertThat(create("a/B").getPathString()).isEqualTo("a/B"); + assertThat(create("C:/a/B").getPathString()).isEqualTo("C:/a/B"); } @Test @@ -96,69 +86,62 @@ public class WindowsLocalPathTest extends LocalPathAbstractTest { public void testGetParentDirectoryWindows() { assertThat(create("C:/foo").getParentDirectory()).isEqualTo(create("C:/")); assertThat(create("C:/").getParentDirectory()).isNull(); + assertThat(create("/").getParentDirectory()).isNull(); } @Test - public void testisAbsoluteWindows() { - assertThat(create("C:/").isAbsolute()).isTrue(); - // test that msys paths turn into absolute paths - assertThat(create("/").isAbsolute()).isTrue(); + public void testParentOfRootIsRootWindows() { + assertThat(create("C:/..")).isEqualTo(create("C:/")); + assertThat(create("C:/../../../../../..")).isEqualTo(create("C:/")); + assertThat(create("C:/../../../foo")).isEqualTo(create("C:/foo")); } @Test public void testRelativeToWindows() { - assertThat(create("C:/foo").relativeTo(create("C:/"))).isEqualTo(create("foo")); + assertThat(create("C:/foo").relativeTo(create("C:/")).getPathString()).isEqualTo("foo"); // Case insensitivity test - assertThat(create("C:/foo/bar").relativeTo(create("C:/FOO"))).isEqualTo(create("bar")); + assertThat(create("C:/foo/bar").relativeTo(create("C:/FOO")).getPathString()).isEqualTo("bar"); MoreAsserts.assertThrows( IllegalArgumentException.class, () -> create("D:/foo").relativeTo(create("C:/"))); } @Test - public void testAbsoluteUnixPathIsRelativeToWindowsUnixRoot() { - assertThat(create("/").getPathString()).isEqualTo("C:/fake/msys"); - assertThat(create("/foo/bar").getPathString()).isEqualTo("C:/fake/msys/foo/bar"); - assertThat(create("/foo/bar").getPathString()).isEqualTo("C:/fake/msys/foo/bar"); - } - - @Test - public void testAbsoluteUnixPathReferringToDriveIsRecognized() { - assertThat(create("/c/foo").getPathString()).isEqualTo("C:/foo"); - assertThat(create("/c/foo").getPathString()).isEqualTo("C:/foo"); - assertThat(create("/c:").getPathString()).isNotEqualTo("C:/foo"); - } - - @Test public void testResolvesShortenedPaths() { + MockShortPathResolver shortPathResolver = new MockShortPathResolver(); + WindowsOsPathPolicy osPathPolicy = new WindowsOsPathPolicy(shortPathResolver); shortPathResolver.resolutions.put("d:/progra~1", "program files"); shortPathResolver.resolutions.put("d:/program files/micros~1", "microsoft something"); shortPathResolver.resolutions.put( "d:/program files/microsoft something/foo/~bar~1", "~bar_hello"); // Assert normal shortpath resolution. - LocalPath normal = create("d:/progra~1/micros~1/foo/~bar~1/baz"); - // The path string has an upper-case drive letter because that's how path printing works. - assertThat(normal.getPathString()) + assertThat(normalize(osPathPolicy, "d:/progra~1/micros~1/foo/~bar~1/baz")) .isEqualTo("D:/program files/microsoft something/foo/~bar_hello/baz"); - LocalPath notYetExistent = create("d:/progra~1/micros~1/foo/will~1.exi/bar"); - // The path string has an upper-case drive letter because that's how path printing works. - assertThat(notYetExistent.getPathString()) + assertThat(normalize(osPathPolicy, "d:/progra~1/micros~1/foo/will~1.exi/bar")) .isEqualTo("D:/program files/microsoft something/foo/will~1.exi/bar"); - LocalPath msRoot = create("d:/progra~1/micros~1"); - assertThat(msRoot.getPathString()).isEqualTo("D:/program files/microsoft something"); + assertThat(normalize(osPathPolicy, "d:/progra~1/micros~1")) + .isEqualTo("D:/program files/microsoft something"); // Pretend that a path we already failed to resolve once came into existence. shortPathResolver.resolutions.put( "d:/program files/microsoft something/foo/will~1.exi", "will.exist"); // Assert that this time we can resolve the previously non-existent path. - LocalPath nowExists = create("d:/progra~1/micros~1/foo/will~1.exi/bar"); // The path string has an upper-case drive letter because that's how path printing works. - assertThat(nowExists.getPathString()) + assertThat(normalize(osPathPolicy, "d:/progra~1/micros~1/foo/will~1.exi/bar")) .isEqualTo("D:/program files/microsoft something/foo/will.exist/bar"); - // Assert relative paths that look like short paths are untouched - assertThat(create("progra~1").getPathString()).isEqualTo("progra~1"); + // Check needsToNormalized + assertThat(osPathPolicy.needsToNormalize("d:/progra~1/micros~1/foo/will~1.exi/bar")) + .isEqualTo(WindowsOsPathPolicy.NEEDS_SHORT_PATH_NORMALIZATION); + assertThat(osPathPolicy.needsToNormalize("will~1.exi")) + .isEqualTo(WindowsOsPathPolicy.NEEDS_SHORT_PATH_NORMALIZATION); + assertThat(osPathPolicy.needsToNormalize("d:/no-normalization")) + .isEqualTo(WindowsOsPathPolicy.NORMALIZED); // Sanity check + } + + private static String normalize(OsPathPolicy osPathPolicy, String str) { + return osPathPolicy.normalize(str, osPathPolicy.needsToNormalize(str)); } } |