Replace path implementation.

Path and PathFragment have been replaced with String-based implementations. They are pretty similar, but each method is dissimilar enough that I did not feel sharing code was appropriate.

A summary of changes:

PATH
====

* Subsumes LocalPath (deleted, its tests repurposed)
* Use a simple string to back Path
* Path instances are no longer interned; Reference equality will no longer work
* Always normalized (same as before)
* Some operations will now be slower, like instance compares (which were previously just a reference check)
* Multiple identical paths will now consume more memory since they are not interned

PATH FRAGMENT
=============

* Use a simple string to back PathFragment
* No more segment arrays with interned strings
* Always normalized
* Remove isNormalized
* Replace some isNormalizied uses with containsUpLevelReferences() to check if path fragments try to escape their scope
* To check if user input is normalized, supply static methods on PathFragment to validate the string before constructing a PathFragment
* Because PathFragments are always normalized, we have to replace checks for literal "." from PathFragment#getPathString to PathFragment#getSafePathString. The latter returns "." for the empty string.
* The previous implementation supported efficient segment semantics (segment count, iterating over segments). This is now expensive since we do longer have a segment array.

ARTIFACT
========

* Remove Path instance. It is instead dynamically constructed on request. This is necessary to avoid this CL becoming a memory regression.

RELNOTES: None
PiperOrigin-RevId: 185062932

1 files changed, 112 insertions, 203 deletions

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());
   }
 }