diff --git a/gitiles-servlet/BUCK b/gitiles-servlet/BUCK
index 9e7a1e8..6e89181 100644
--- a/gitiles-servlet/BUCK
+++ b/gitiles-servlet/BUCK
@@ -36,6 +36,7 @@
     ':servlet',
     # Gitiles is designed to compile against the Servlet API v2.5.
     '//lib:servlet-api_2_5',
+    '//lib:truth',
     '//lib/jgit:junit',
     '//lib/junit:junit',
   ],
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/ConfigUtilTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/ConfigUtilTest.java
index a767b0d..a22cc72 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/ConfigUtilTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/ConfigUtilTest.java
@@ -14,8 +14,8 @@
 
 package com.google.gitiles;
 
+import static com.google.common.truth.Truth.assertThat;
 import static com.google.gitiles.ConfigUtil.getDuration;
-import static org.junit.Assert.assertEquals;
 
 import org.eclipse.jgit.lib.Config;
 import org.joda.time.Duration;
@@ -34,14 +34,14 @@
 
     config.setString("core", "dht", "timeout", "500 ms");
     t = getDuration(config, "core", "dht", "timeout", def);
-    assertEquals(500, t.getMillis());
+    assertThat(t.getMillis()).isEqualTo(500);
 
     config.setString("core", "dht", "timeout", "5.2 sec");
     t = getDuration(config, "core", "dht", "timeout", def);
-    assertEquals(5200, t.getMillis());
+    assertThat(t.getMillis()).isEqualTo(5200);
 
     config.setString("core", "dht", "timeout", "1 min");
     t = getDuration(config, "core", "dht", "timeout", def);
-    assertEquals(60000, t.getMillis());
+    assertThat(t.getMillis()).isEqualTo(60000);
   }
 }
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/DateFormatterTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/DateFormatterTest.java
index b66bffe..ed65fef 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/DateFormatterTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/DateFormatterTest.java
@@ -14,10 +14,10 @@
 
 package com.google.gitiles;
 
+import static com.google.common.truth.Truth.assertThat;
 import static com.google.gitiles.DateFormatter.Format.DEFAULT;
 import static com.google.gitiles.DateFormatter.Format.ISO;
 import static java.util.TimeZone.getTimeZone;
-import static org.junit.Assert.assertEquals;
 
 import com.google.common.base.Optional;
 
@@ -37,42 +37,42 @@
   public void defaultIncludingTimeZone() throws Exception {
     PersonIdent ident = newIdent("Mon Jan 2 15:04:05 2006", "-0700");
     DateFormatter df = new DateFormatter(Optional.<TimeZone> absent(), DEFAULT);
-    assertEquals("Mon Jan 02 15:04:05 2006 -0700", df.format(ident));
+    assertThat(df.format(ident)).isEqualTo("Mon Jan 02 15:04:05 2006 -0700");
   }
 
   @Test
   public void defaultWithUtc() throws Exception {
     PersonIdent ident = newIdent("Mon Jan 2 15:04:05 2006", "-0700");
     DateFormatter df = new DateFormatter(Optional.of(getTimeZone("UTC")), DEFAULT);
-    assertEquals("Mon Jan 02 22:04:05 2006", df.format(ident));
+    assertThat(df.format(ident)).isEqualTo("Mon Jan 02 22:04:05 2006");
   }
 
   @Test
   public void defaultWithOtherTimeZone() throws Exception {
     PersonIdent ident = newIdent("Mon Jan 2 15:04:05 2006", "-0700");
     DateFormatter df = new DateFormatter(Optional.of(getTimeZone("GMT-0400")), DEFAULT);
-    assertEquals("Mon Jan 02 18:04:05 2006", df.format(ident));
+    assertThat(df.format(ident)).isEqualTo("Mon Jan 02 18:04:05 2006");
   }
 
   @Test
   public void isoIncludingTimeZone() throws Exception {
     PersonIdent ident = newIdent("Mon Jan 2 15:04:05 2006", "-0700");
     DateFormatter df = new DateFormatter(Optional.<TimeZone> absent(), ISO);
-    assertEquals("2006-01-02 15:04:05 -0700", df.format(ident));
+    assertThat(df.format(ident)).isEqualTo("2006-01-02 15:04:05 -0700");
   }
 
   @Test
   public void isoWithUtc() throws Exception {
     PersonIdent ident = newIdent("Mon Jan 2 15:04:05 2006", "-0700");
     DateFormatter df = new DateFormatter(Optional.of(getTimeZone("UTC")), ISO);
-    assertEquals("2006-01-02 22:04:05", df.format(ident));
+    assertThat(df.format(ident)).isEqualTo("2006-01-02 22:04:05");
   }
 
   @Test
   public void isoWithOtherTimeZone() throws Exception {
     PersonIdent ident = newIdent("Mon Jan 2 15:04:05 2006", "-0700");
     DateFormatter df = new DateFormatter(Optional.of(getTimeZone("GMT-0400")), ISO);
-    assertEquals("2006-01-02 18:04:05", df.format(ident));
+    assertThat(df.format(ident)).isEqualTo("2006-01-02 18:04:05");
   }
 
   private PersonIdent newIdent(String whenStr, String tzStr) throws ParseException {
@@ -83,7 +83,7 @@
     // PersonIdent.toString() uses its own format with "d" instead of "dd",
     // hence the mismatches in 2 vs. 02 above. Nonetheless I think this sanity
     // check is useful enough to keep around.
-    assertEquals("PersonIdent[A User, user@example.com, " + whenStr + "]", ident.toString());
+    assertThat(ident.toString()).isEqualTo("PersonIdent[A User, user@example.com, " + whenStr + "]");
     return ident;
   }
 }
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/DiffServletTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/DiffServletTest.java
index 8e1ba51..cfc74ee 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/DiffServletTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/DiffServletTest.java
@@ -15,9 +15,8 @@
 package com.google.gitiles;
 
 import static com.google.common.collect.Iterables.getOnlyElement;
+import static com.google.common.truth.Truth.assertThat;
 import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.io.BaseEncoding;
@@ -49,8 +48,7 @@
     String diffHeader = String.format(
         "diff --git <a href=\"/b/repo/+/%s/foo\">a/foo</a> <a href=\"/b/repo/+/%s/foo\">b/foo</a>",
         c1.name(), c2.name());
-    assertTrue(String.format("Expected diff body to contain [%s]:\n%s", diffHeader, actual),
-        actual.contains(diffHeader));
+    assertThat(actual).contains(diffHeader);
   }
 
   @Test
@@ -62,14 +60,14 @@
 
     Patch p = parsePatch(res.getActualBody());
     FileHeader f = getOnlyElement(p.getFiles());
-    assertEquals(ChangeType.ADD, f.getChangeType());
-    assertEquals(DiffEntry.DEV_NULL, f.getPath(Side.OLD));
-    assertEquals("foo", f.getPath(Side.NEW));
+    assertThat(f.getChangeType()).isEqualTo(ChangeType.ADD);
+    assertThat(f.getPath(Side.OLD)).isEqualTo(DiffEntry.DEV_NULL);
+    assertThat(f.getPath(Side.NEW)).isEqualTo("foo");
 
     RawText rt = new RawText(contents.getBytes(UTF_8));
     Edit e = getOnlyElement(getOnlyElement(f.getHunks()).toEditList());
-    assertEquals(Type.INSERT, e.getType());
-    assertEquals(contents, rt.getString(e.getBeginB(), e.getEndB(), false));
+    assertThat(e.getType()).isEqualTo(Type.INSERT);
+    assertThat(rt.getString(e.getBeginB(), e.getEndB(), false)).isEqualTo(contents);
   }
 
   @Test
@@ -83,14 +81,14 @@
 
     Patch p = parsePatch(res.getActualBody());
     FileHeader f = getOnlyElement(p.getFiles());
-    assertEquals(ChangeType.MODIFY, f.getChangeType());
-    assertEquals("foo", f.getPath(Side.OLD));
-    assertEquals("foo", f.getPath(Side.NEW));
+    assertThat(f.getChangeType()).isEqualTo(ChangeType.MODIFY);
+    assertThat(f.getPath(Side.OLD)).isEqualTo("foo");
+    assertThat(f.getPath(Side.NEW)).isEqualTo("foo");
 
     RawText rt2 = new RawText(contents2.getBytes(UTF_8));
     Edit e = getOnlyElement(getOnlyElement(f.getHunks()).toEditList());
-    assertEquals(Type.INSERT, e.getType());
-    assertEquals("contents\n", rt2.getString(e.getBeginB(), e.getEndB(), false));
+    assertThat(e.getType()).isEqualTo(Type.INSERT);
+    assertThat(rt2.getString(e.getBeginB(), e.getEndB(), false)).isEqualTo("contents\n");
   }
 
   @Test
@@ -104,16 +102,16 @@
     FakeHttpServletResponse res = buildText("/repo/+diff/" + c.name() + "^!/dir");
 
     Patch p = parsePatch(res.getActualBody());
-    assertEquals(2, p.getFiles().size());
-    assertEquals("dir/bar", p.getFiles().get(0).getPath(Side.NEW));
-    assertEquals("dir/foo", p.getFiles().get(1).getPath(Side.NEW));
+    assertThat(p.getFiles().size()).isEqualTo(2);
+    assertThat(p.getFiles().get(0).getPath(Side.NEW)).isEqualTo("dir/bar");
+    assertThat(p.getFiles().get(1).getPath(Side.NEW)).isEqualTo("dir/foo");
   }
 
   private static Patch parsePatch(byte[] enc) {
     byte[] buf = BaseEncoding.base64().decode(new String(enc, UTF_8));
     Patch p = new Patch();
     p.parse(buf, 0, buf.length);
-    assertEquals(ImmutableList.of(), p.getErrors());
+    assertThat(p.getErrors()).isEqualTo(ImmutableList.of());
     return p;
   }
 }
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/GitilesFilterTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/GitilesFilterTest.java
index c2a569d..4b10ca7 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/GitilesFilterTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/GitilesFilterTest.java
@@ -14,12 +14,10 @@
 
 package com.google.gitiles;
 
+import static com.google.common.truth.Truth.assertThat;
 import static com.google.gitiles.GitilesFilter.REPO_PATH_REGEX;
 import static com.google.gitiles.GitilesFilter.REPO_REGEX;
 import static com.google.gitiles.GitilesFilter.ROOT_REGEX;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -32,149 +30,149 @@
 public class GitilesFilterTest {
   @Test
   public void rootUrls() throws Exception {
-    assertFalse(ROOT_REGEX.matcher("").matches());
-    assertFalse(ROOT_REGEX.matcher("/foo").matches());
-    assertFalse(ROOT_REGEX.matcher("/foo/").matches());
-    assertFalse(ROOT_REGEX.matcher("/foo/ ").matches());
-    assertFalse(ROOT_REGEX.matcher("/foo/+").matches());
-    assertFalse(ROOT_REGEX.matcher("/foo/+").matches());
-    assertFalse(ROOT_REGEX.matcher("/foo/ /").matches());
-    assertFalse(ROOT_REGEX.matcher("/foo/+/").matches());
-    assertFalse(ROOT_REGEX.matcher("/foo/+/bar").matches());
+    assertThat("").doesNotMatch(ROOT_REGEX);
+    assertThat("/foo").doesNotMatch(ROOT_REGEX);
+    assertThat("/foo/").doesNotMatch(ROOT_REGEX);
+    assertThat("/foo/ ").doesNotMatch(ROOT_REGEX);
+    assertThat("/foo/+").doesNotMatch(ROOT_REGEX);
+    assertThat("/foo/+").doesNotMatch(ROOT_REGEX);
+    assertThat("/foo/ /").doesNotMatch(ROOT_REGEX);
+    assertThat("/foo/+/").doesNotMatch(ROOT_REGEX);
+    assertThat("/foo/+/bar").doesNotMatch(ROOT_REGEX);
     Matcher m;
 
     m = ROOT_REGEX.matcher("/");
-    assertTrue(m.matches());
-    assertEquals("/", m.group(0));
-    assertEquals(m.group(0), m.group(1));
-    assertEquals("/", m.group(2));
-    assertEquals("", m.group(3));
-    assertEquals("", m.group(4));
+    assertThat(m.matches()).isTrue();
+    assertThat(m.group(0)).isEqualTo("/");
+    assertThat(m.group(1)).isEqualTo(m.group(0));
+    assertThat(m.group(2)).isEqualTo("/");
+    assertThat(m.group(3)).isEqualTo("");
+    assertThat(m.group(4)).isEqualTo("");
 
     m = ROOT_REGEX.matcher("//");
-    assertTrue(m.matches());
-    assertEquals("//", m.group(0));
-    assertEquals(m.group(0), m.group(1));
-    assertEquals("/", m.group(2));
-    assertEquals("", m.group(3));
-    assertEquals("", m.group(4));
+    assertThat(m.matches()).isTrue();
+    assertThat(m.group(0)).isEqualTo("//");
+    assertThat(m.group(1)).isEqualTo(m.group(0));
+    assertThat(m.group(2)).isEqualTo("/");
+    assertThat(m.group(3)).isEqualTo("");
+    assertThat(m.group(4)).isEqualTo("");
   }
 
   @Test
   public void repoUrls() throws Exception {
-    assertFalse(REPO_REGEX.matcher("").matches());
+    assertThat("").doesNotMatch(REPO_REGEX);
 
     // These match the regex but are served by the root regex binder, which is
     // matched first.
-    assertTrue(REPO_REGEX.matcher("/").matches());
-    assertTrue(REPO_REGEX.matcher("//").matches());
+    assertThat("/").matches(REPO_REGEX);
+    assertThat("//").matches(REPO_REGEX);
 
-    assertFalse(REPO_REGEX.matcher("/foo/+").matches());
-    assertFalse(REPO_REGEX.matcher("/foo/bar/+").matches());
-    assertFalse(REPO_REGEX.matcher("/foo/bar/+/").matches());
-    assertFalse(REPO_REGEX.matcher("/foo/bar/+/baz").matches());
+    assertThat("/foo/+").doesNotMatch(REPO_REGEX);
+    assertThat("/foo/bar/+").doesNotMatch(REPO_REGEX);
+    assertThat("/foo/bar/+/").doesNotMatch(REPO_REGEX);
+    assertThat("/foo/bar/+/baz").doesNotMatch(REPO_REGEX);
     Matcher m;
 
     m = REPO_REGEX.matcher("/foo");
-    assertTrue(m.matches());
-    assertEquals("/foo", m.group(0));
-    assertEquals(m.group(0), m.group(1));
-    assertEquals("/foo", m.group(2));
-    assertEquals("", m.group(3));
-    assertEquals("", m.group(4));
+    assertThat(m.matches()).isTrue();
+    assertThat(m.group(0)).isEqualTo("/foo");
+    assertThat(m.group(1)).isEqualTo(m.group(0));
+    assertThat(m.group(2)).isEqualTo("/foo");
+    assertThat(m.group(3)).isEqualTo("");
+    assertThat(m.group(4)).isEqualTo("");
 
     m = REPO_REGEX.matcher("/foo/");
-    assertTrue(m.matches());
-    assertEquals("/foo/", m.group(0));
-    assertEquals(m.group(0), m.group(1));
-    assertEquals("/foo", m.group(2));
-    assertEquals("", m.group(3));
-    assertEquals("", m.group(4));
+    assertThat(m.matches()).isTrue();
+    assertThat(m.group(0)).isEqualTo("/foo/");
+    assertThat(m.group(1)).isEqualTo(m.group(0));
+    assertThat(m.group(2)).isEqualTo("/foo");
+    assertThat(m.group(3)).isEqualTo("");
+    assertThat(m.group(4)).isEqualTo("");
 
     m = REPO_REGEX.matcher("/foo/bar");
-    assertTrue(m.matches());
-    assertEquals("/foo/bar", m.group(0));
-    assertEquals(m.group(0), m.group(1));
-    assertEquals("/foo/bar", m.group(2));
-    assertEquals("", m.group(3));
-    assertEquals("", m.group(4));
+    assertThat(m.matches()).isTrue();
+    assertThat(m.group(0)).isEqualTo("/foo/bar");
+    assertThat(m.group(1)).isEqualTo(m.group(0));
+    assertThat(m.group(2)).isEqualTo("/foo/bar");
+    assertThat(m.group(3)).isEqualTo("");
+    assertThat(m.group(4)).isEqualTo("");
 
     m = REPO_REGEX.matcher("/foo/bar+baz");
-    assertTrue(m.matches());
-    assertEquals("/foo/bar+baz", m.group(0));
-    assertEquals(m.group(0), m.group(1));
-    assertEquals("/foo/bar+baz", m.group(2));
-    assertEquals("", m.group(3));
-    assertEquals("", m.group(4));
+    assertThat(m.matches()).isTrue();
+    assertThat(m.group(0)).isEqualTo("/foo/bar+baz");
+    assertThat(m.group(1)).isEqualTo(m.group(0));
+    assertThat(m.group(2)).isEqualTo("/foo/bar+baz");
+    assertThat(m.group(3)).isEqualTo("");
+    assertThat(m.group(4)).isEqualTo("");
   }
 
   @Test
   public void repoPathUrls() throws Exception {
-    assertFalse(REPO_PATH_REGEX.matcher("").matches());
-    assertFalse(REPO_PATH_REGEX.matcher("/").matches());
-    assertFalse(REPO_PATH_REGEX.matcher("//").matches());
-    assertFalse(REPO_PATH_REGEX.matcher("/foo").matches());
-    assertFalse(REPO_PATH_REGEX.matcher("/foo/ ").matches());
-    assertFalse(REPO_PATH_REGEX.matcher("/foo/ /").matches());
-    assertFalse(REPO_PATH_REGEX.matcher("/foo/ /bar").matches());
-    assertFalse(REPO_PATH_REGEX.matcher("/foo/bar").matches());
-    assertFalse(REPO_PATH_REGEX.matcher("/foo/bar+baz").matches());
+    assertThat("").doesNotMatch(REPO_PATH_REGEX);
+    assertThat("/").doesNotMatch(REPO_PATH_REGEX);
+    assertThat("//").doesNotMatch(REPO_PATH_REGEX);
+    assertThat("/foo").doesNotMatch(REPO_PATH_REGEX);
+    assertThat("/foo/ ").doesNotMatch(REPO_PATH_REGEX);
+    assertThat("/foo/ /").doesNotMatch(REPO_PATH_REGEX);
+    assertThat("/foo/ /bar").doesNotMatch(REPO_PATH_REGEX);
+    assertThat("/foo/bar").doesNotMatch(REPO_PATH_REGEX);
+    assertThat("/foo/bar+baz").doesNotMatch(REPO_PATH_REGEX);
     Matcher m;
 
     m = REPO_PATH_REGEX.matcher("/foo/+");
-    assertTrue(m.matches());
-    assertEquals("/foo/+", m.group(0));
-    assertEquals(m.group(0), m.group(1));
-    assertEquals("/foo", m.group(2));
-    assertEquals("+", m.group(3));
-    assertEquals("", m.group(4));
+    assertThat(m.matches()).isTrue();
+    assertThat(m.group(0)).isEqualTo("/foo/+");
+    assertThat(m.group(1)).isEqualTo(m.group(0));
+    assertThat(m.group(2)).isEqualTo("/foo");
+    assertThat(m.group(3)).isEqualTo("+");
+    assertThat(m.group(4)).isEqualTo("");
 
     m = REPO_PATH_REGEX.matcher("/foo/+/");
-    assertTrue(m.matches());
-    assertEquals("/foo/+/", m.group(0));
-    assertEquals(m.group(0), m.group(1));
-    assertEquals("/foo", m.group(2));
-    assertEquals("+", m.group(3));
-    assertEquals("/", m.group(4));
+    assertThat(m.matches()).isTrue();
+    assertThat(m.group(0)).isEqualTo("/foo/+/");
+    assertThat(m.group(1)).isEqualTo(m.group(0));
+    assertThat(m.group(2)).isEqualTo("/foo");
+    assertThat(m.group(3)).isEqualTo("+");
+    assertThat(m.group(4)).isEqualTo("/");
 
     m = REPO_PATH_REGEX.matcher("/foo/+/bar/baz");
-    assertTrue(m.matches());
-    assertEquals("/foo/+/bar/baz", m.group(0));
-    assertEquals(m.group(0), m.group(1));
-    assertEquals("/foo", m.group(2));
-    assertEquals("+", m.group(3));
-    assertEquals("/bar/baz", m.group(4));
+    assertThat(m.matches()).isTrue();
+    assertThat(m.group(0)).isEqualTo("/foo/+/bar/baz");
+    assertThat(m.group(1)).isEqualTo(m.group(0));
+    assertThat(m.group(2)).isEqualTo("/foo");
+    assertThat(m.group(3)).isEqualTo("+");
+    assertThat(m.group(4)).isEqualTo("/bar/baz");
 
     m = REPO_PATH_REGEX.matcher("/foo/+/bar/baz/");
-    assertTrue(m.matches());
-    assertEquals("/foo/+/bar/baz/", m.group(0));
-    assertEquals(m.group(0), m.group(1));
-    assertEquals("/foo", m.group(2));
-    assertEquals("+", m.group(3));
-    assertEquals("/bar/baz/", m.group(4));
+    assertThat(m.matches()).isTrue();
+    assertThat(m.group(0)).isEqualTo("/foo/+/bar/baz/");
+    assertThat(m.group(1)).isEqualTo(m.group(0));
+    assertThat(m.group(2)).isEqualTo("/foo");
+    assertThat(m.group(3)).isEqualTo("+");
+    assertThat(m.group(4)).isEqualTo("/bar/baz/");
 
     m = REPO_PATH_REGEX.matcher("/foo/+/bar baz");
-    assertTrue(m.matches());
-    assertEquals("/foo/+/bar baz", m.group(0));
-    assertEquals(m.group(0), m.group(1));
-    assertEquals("/foo", m.group(2));
-    assertEquals("+", m.group(3));
-    assertEquals("/bar baz", m.group(4));
+    assertThat(m.matches()).isTrue();
+    assertThat(m.group(0)).isEqualTo("/foo/+/bar baz");
+    assertThat(m.group(1)).isEqualTo(m.group(0));
+    assertThat(m.group(2)).isEqualTo("/foo");
+    assertThat(m.group(3)).isEqualTo("+");
+    assertThat(m.group(4)).isEqualTo("/bar baz");
 
     m = REPO_PATH_REGEX.matcher("/foo/+/bar/+/baz");
-    assertTrue(m.matches());
-    assertEquals("/foo/+/bar/+/baz", m.group(0));
-    assertEquals(m.group(0), m.group(1));
-    assertEquals("/foo", m.group(2));
-    assertEquals("+", m.group(3));
-    assertEquals("/bar/+/baz", m.group(4));
+    assertThat(m.matches()).isTrue();
+    assertThat(m.group(0)).isEqualTo("/foo/+/bar/+/baz");
+    assertThat(m.group(1)).isEqualTo(m.group(0));
+    assertThat(m.group(2)).isEqualTo("/foo");
+    assertThat(m.group(3)).isEqualTo("+");
+    assertThat(m.group(4)).isEqualTo("/bar/+/baz");
 
     m = REPO_PATH_REGEX.matcher("/foo/+bar/baz");
-    assertTrue(m.matches());
-    assertEquals("/foo/+bar/baz", m.group(0));
-    assertEquals(m.group(0), m.group(1));
-    assertEquals("/foo", m.group(2));
-    assertEquals("+bar", m.group(3));
-    assertEquals("/baz", m.group(4));
+    assertThat(m.matches()).isTrue();
+    assertThat(m.group(0)).isEqualTo("/foo/+bar/baz");
+    assertThat(m.group(1)).isEqualTo(m.group(0));
+    assertThat(m.group(2)).isEqualTo("/foo");
+    assertThat(m.group(3)).isEqualTo("+bar");
+    assertThat(m.group(4)).isEqualTo("/baz");
   }
 }
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/GitilesUrlsTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/GitilesUrlsTest.java
index 465e331..4f85bc2 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/GitilesUrlsTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/GitilesUrlsTest.java
@@ -13,8 +13,9 @@
 // limitations under the License.
 
 package com.google.gitiles;
+
+import static com.google.common.truth.Truth.assertThat;
 import static com.google.gitiles.GitilesUrls.NAME_ESCAPER;
-import static org.junit.Assert.assertEquals;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -25,31 +26,31 @@
 public class GitilesUrlsTest {
   @Test
   public void nameEscaperEscapesAppropriateSpecialCharacters() throws Exception {
-    assertEquals("foo_bar", NAME_ESCAPER.apply("foo_bar"));
-    assertEquals("foo-bar", NAME_ESCAPER.apply("foo-bar"));
-    assertEquals("foo%25bar", NAME_ESCAPER.apply("foo%bar"));
-    assertEquals("foo%26bar", NAME_ESCAPER.apply("foo&bar"));
-    assertEquals("foo%28bar", NAME_ESCAPER.apply("foo(bar"));
-    assertEquals("foo%29bar", NAME_ESCAPER.apply("foo)bar"));
-    assertEquals("foo%3Abar", NAME_ESCAPER.apply("foo:bar"));
-    assertEquals("foo%3Bbar", NAME_ESCAPER.apply("foo;bar"));
-    assertEquals("foo%3Dbar", NAME_ESCAPER.apply("foo=bar"));
-    assertEquals("foo%3Fbar", NAME_ESCAPER.apply("foo?bar"));
-    assertEquals("foo%5Bbar", NAME_ESCAPER.apply("foo[bar"));
-    assertEquals("foo%5Dbar", NAME_ESCAPER.apply("foo]bar"));
-    assertEquals("foo%7Bbar", NAME_ESCAPER.apply("foo{bar"));
-    assertEquals("foo%7Dbar", NAME_ESCAPER.apply("foo}bar"));
+    assertThat(NAME_ESCAPER.apply("foo_bar")).isEqualTo("foo_bar");
+    assertThat(NAME_ESCAPER.apply("foo-bar")).isEqualTo("foo-bar");
+    assertThat(NAME_ESCAPER.apply("foo%bar")).isEqualTo("foo%25bar");
+    assertThat(NAME_ESCAPER.apply("foo&bar")).isEqualTo("foo%26bar");
+    assertThat(NAME_ESCAPER.apply("foo(bar")).isEqualTo("foo%28bar");
+    assertThat(NAME_ESCAPER.apply("foo)bar")).isEqualTo("foo%29bar");
+    assertThat(NAME_ESCAPER.apply("foo:bar")).isEqualTo("foo%3Abar");
+    assertThat(NAME_ESCAPER.apply("foo;bar")).isEqualTo("foo%3Bbar");
+    assertThat(NAME_ESCAPER.apply("foo=bar")).isEqualTo("foo%3Dbar");
+    assertThat(NAME_ESCAPER.apply("foo?bar")).isEqualTo("foo%3Fbar");
+    assertThat(NAME_ESCAPER.apply("foo[bar")).isEqualTo("foo%5Bbar");
+    assertThat(NAME_ESCAPER.apply("foo]bar")).isEqualTo("foo%5Dbar");
+    assertThat(NAME_ESCAPER.apply("foo{bar")).isEqualTo("foo%7Bbar");
+    assertThat(NAME_ESCAPER.apply("foo}bar")).isEqualTo("foo%7Dbar");
   }
 
   @Test
   public void nameEscaperDoesNotEscapeSlashes() throws Exception {
-    assertEquals("foo/bar", NAME_ESCAPER.apply("foo/bar"));
+    assertThat(NAME_ESCAPER.apply("foo/bar")).isEqualTo("foo/bar");
   }
 
   @Test
   public void nameEscaperEscapesSpacesWithPercentInsteadOfPlus() throws Exception {
-    assertEquals("foo+bar", NAME_ESCAPER.apply("foo+bar"));
-    assertEquals("foo%20bar", NAME_ESCAPER.apply("foo bar"));
-    assertEquals("foo%2520bar", NAME_ESCAPER.apply("foo%20bar"));
+    assertThat(NAME_ESCAPER.apply("foo+bar")).isEqualTo("foo+bar");
+    assertThat(NAME_ESCAPER.apply("foo bar")).isEqualTo("foo%20bar");
+    assertThat(NAME_ESCAPER.apply("foo%20bar")).isEqualTo("foo%2520bar");
   }
 }
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/GitilesViewTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/GitilesViewTest.java
index 646024d..bdda705 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/GitilesViewTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/GitilesViewTest.java
@@ -14,10 +14,7 @@
 
 package com.google.gitiles;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static com.google.common.truth.Truth.assertThat;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableListMultimap;
@@ -43,32 +40,32 @@
         .setServletPath("")
         .setHostName("host")
         .build();
-    assertEquals("", view.getServletPath());
-    assertEquals(Type.HOST_INDEX, view.getType());
-    assertEquals("host", view.getHostName());
-    assertNull(view.getRepositoryName());
-    assertEquals(Revision.NULL, view.getRevision());
-    assertNull(view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
+    assertThat(view.getServletPath()).isEqualTo("");
+    assertThat(view.getType()).isEqualTo(Type.HOST_INDEX);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isNull();
+    assertThat(view.getRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isNull();
+    assertThat(HOST.getParameters()).isEmpty();
 
-    assertEquals("/?format=HTML", view.toUrl());
-    assertEquals(ImmutableList.of(ImmutableMap.of("text", "host", "url", "/?format=HTML")),
-        view.getBreadcrumbs());
+    assertThat(view.toUrl()).isEqualTo("/?format=HTML");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(breadcrumb("host", "/?format=HTML"));
   }
 
   @Test
   public void hostIndex() throws Exception {
-    assertEquals("/b", HOST.getServletPath());
-    assertEquals(Type.HOST_INDEX, HOST.getType());
-    assertEquals("host", HOST.getHostName());
-    assertNull(HOST.getRepositoryName());
-    assertEquals(Revision.NULL, HOST.getRevision());
-    assertNull(HOST.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
+    assertThat(HOST.getServletPath()).isEqualTo("/b");
+    assertThat(HOST.getType()).isEqualTo(Type.HOST_INDEX);
+    assertThat(HOST.getHostName()).isEqualTo("host");
+    assertThat(HOST.getRepositoryName()).isNull();
+    assertThat(HOST.getRevision()).isEqualTo(Revision.NULL);
+    assertThat(HOST.getPathPart()).isNull();
+    assertThat(HOST.getParameters()).isEmpty();
 
-    assertEquals("/b/?format=HTML", HOST.toUrl());
-    assertEquals(ImmutableList.of(ImmutableMap.of("text", "host", "url", "/b/?format=HTML")),
-        HOST.getBreadcrumbs());
+    assertThat(HOST.toUrl()).isEqualTo("/b/?format=HTML");
+    assertThat(HOST.getBreadcrumbs())
+        .containsExactly(breadcrumb("host", "/b/?format=HTML"));
   }
 
   @Test
@@ -78,11 +75,12 @@
         .setRepositoryPrefix("foo")
         .build();
 
-    assertEquals("/b/foo/", view.toUrl());
-    assertEquals(ImmutableList.of(
-        ImmutableMap.of("text", "host", "url", "/b/?format=HTML"),
-        ImmutableMap.of("text", "foo", "url", "/b/foo/")),
-      view.getBreadcrumbs());
+    assertThat(view.toUrl()).isEqualTo("/b/foo/");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
+          breadcrumb("host", "/b/?format=HTML"),
+          breadcrumb("foo", "/b/foo/"))
+        .inOrder();
   }
 
   @Test
@@ -92,12 +90,13 @@
         .setRepositoryPrefix("foo/bar")
         .build();
 
-    assertEquals("/b/foo/bar/", view.toUrl());
-    assertEquals(ImmutableList.of(
-          ImmutableMap.of("text", "host", "url", "/b/?format=HTML"),
-          ImmutableMap.of("text", "foo", "url", "/b/foo/"),
-          ImmutableMap.of("text", "bar", "url", "/b/foo/bar/")),
-        view.getBreadcrumbs());
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
+            breadcrumb("host", "/b/?format=HTML"),
+            breadcrumb("foo", "/b/foo/"),
+            breadcrumb("bar", "/b/foo/bar/"))
+        .inOrder();
   }
 
   @Test
@@ -109,25 +108,24 @@
         .putParam("bar", "barvalue")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.LOG, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("repo", view.getRepositoryName());
-    assertEquals(Revision.named("master"), view.getRevision());
-    assertNull(view.getPathPart());
-    assertEquals(
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.LOG);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("repo");
+    assertThat(view.getRevision()).isEqualTo(Revision.named("master"));
+    assertThat(view.getPathPart()).isNull();
+    assertThat(view.getParameters()).containsExactly(
         ImmutableListMultimap.of(
             "foo", "foovalue",
-            "bar", "barvalue"),
-        view.getParameters());
+            "bar", "barvalue"));
 
-    assertEquals("/b/repo/+log/master?foo=foovalue&bar=barvalue", view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.toUrl()).isEqualTo("/b/repo/+log/master?foo=foovalue&bar=barvalue");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("repo", "/b/repo/"),
-            breadcrumb("master", "/b/repo/+log/master?foo=foovalue&bar=barvalue")),
-        view.getBreadcrumbs());
+            breadcrumb("master", "/b/repo/+log/master?foo=foovalue&bar=barvalue"))
+        .inOrder();
   }
 
   @Test
@@ -137,10 +135,10 @@
         .putParam("foo", "foovalue")
         .putParam("bar", "barvalue")
         .build();
-    assertFalse(view.getParameters().isEmpty());
-    assertEquals(view.getParameters(),
-        GitilesView.repositoryIndex().copyFrom(view).build().getParameters());
-    assertTrue(GitilesView.hostIndex().copyFrom(view).build().getParameters().isEmpty());
+    assertThat(view.getParameters()).isNotEmpty();
+    assertThat(GitilesView.repositoryIndex().copyFrom(view).build().getParameters())
+        .isEqualTo(view.getParameters());
+    assertThat(GitilesView.hostIndex().copyFrom(view).build().getParameters()).isEmpty();
   }
 
   @Test
@@ -150,21 +148,21 @@
         .setRepositoryName("foo/bar")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.REPOSITORY_INDEX, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(Revision.NULL, view.getRevision());
-    assertNull(view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.REPOSITORY_INDEX);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isNull();
+    assertThat(HOST.getParameters()).isEmpty();
 
-    assertEquals("/b/foo/bar/", view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo", "/b/foo/"),
-            breadcrumb("bar", "/b/foo/bar/")),
-        view.getBreadcrumbs());
+            breadcrumb("bar", "/b/foo/bar/"))
+        .inOrder();
   }
 
   @Test
@@ -174,21 +172,21 @@
         .setRepositoryName("foo/bar")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.REFS, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(Revision.NULL, view.getRevision());
-    assertNull(view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.REFS);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isNull();
+    assertThat(HOST.getParameters()).isEmpty();
 
-    assertEquals("/b/foo/bar/+refs", view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+refs");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo", "/b/foo/"),
-            breadcrumb("bar", "/b/foo/bar/")),
-        view.getBreadcrumbs());
+            breadcrumb("bar", "/b/foo/bar/"))
+        .inOrder();
   }
 
   @Test
@@ -200,23 +198,23 @@
         .setRevision(Revision.unpeeled("master", id))
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.REVISION, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("master", view.getRevision().getName());
-    assertNull(view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.REVISION);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getPathPart()).isNull();
+    assertThat(HOST.getParameters()).isEmpty();
 
-    assertEquals("/b/foo/bar/+/master", view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+/master");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo", "/b/foo/"),
             breadcrumb("bar", "/b/foo/bar/"),
-            breadcrumb("master", "/b/foo/bar/+/master")),
-        view.getBreadcrumbs());
+            breadcrumb("master", "/b/foo/bar/+/master"))
+        .inOrder();
   }
 
   @Test
@@ -227,13 +225,13 @@
         .setPathPart("deadbeef")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.DESCRIBE, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(Revision.NULL, view.getRevision());
-    assertEquals("deadbeef", view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.DESCRIBE);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isEqualTo("deadbeef");
+    assertThat(HOST.getParameters()).isEmpty();
   }
 
   @Test
@@ -246,24 +244,24 @@
         .setPathPart("/")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.PATH, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals("", view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.PATH);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getPathPart()).isEqualTo("");
+    assertThat(HOST.getParameters()).isEmpty();
 
-    assertEquals("/b/foo/bar/+/master/", view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+/master/");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo", "/b/foo/"),
             breadcrumb("bar", "/b/foo/bar/"),
             breadcrumb("master", "/b/foo/bar/+/master"),
-            breadcrumb(".", "/b/foo/bar/+/master/")),
-        view.getBreadcrumbs());
+            breadcrumb(".", "/b/foo/bar/+/master/"))
+        .inOrder();
   }
 
   @Test
@@ -276,25 +274,25 @@
         .setPathPart("/file")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.PATH, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals("file", view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.PATH);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getPathPart()).isEqualTo("file");
+    assertThat(HOST.getParameters()).isEmpty();
 
-    assertEquals("/b/foo/bar/+/master/file", view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+/master/file");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo", "/b/foo/"),
             breadcrumb("bar", "/b/foo/bar/"),
             breadcrumb("master", "/b/foo/bar/+/master"),
             breadcrumb(".", "/b/foo/bar/+/master/"),
-            breadcrumb("file", "/b/foo/bar/+/master/file")),
-        view.getBreadcrumbs());
+            breadcrumb("file", "/b/foo/bar/+/master/file"))
+        .inOrder();
   }
 
   @Test
@@ -307,15 +305,15 @@
         .setPathPart("/README.md")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.DOC, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals("README.md", view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
-    assertEquals("/b/foo/bar/+/master/README.md", view.toUrl());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.DOC);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getPathPart()).isEqualTo("README.md");
+    assertThat(HOST.getParameters()).isEmpty();
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+/master/README.md");
   }
 
   @Test
@@ -328,15 +326,15 @@
         .setPathPart("/docs/")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.DOC, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals("docs", view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
-    assertEquals("/b/foo/bar/+doc/master/docs", view.toUrl());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.DOC);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getPathPart()).isEqualTo("docs");
+    assertThat(HOST.getParameters()).isEmpty();
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+doc/master/docs");
   }
 
   @Test
@@ -349,15 +347,15 @@
         .setPathPart("/README.md")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.SHOW, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals("README.md", view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
-    assertEquals("/b/foo/bar/+show/master/README.md", view.toUrl());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.SHOW);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getPathPart()).isEqualTo("README.md");
+    assertThat(HOST.getParameters()).isEmpty();
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+show/master/README.md");
   }
 
   @Test
@@ -369,14 +367,14 @@
         .setPathPart("/docs/")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.ROOTED_DOC, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals("docs", view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
-    assertEquals("/b/docs", view.toUrl());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.ROOTED_DOC);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getPathPart()).isEqualTo("docs");
+    assertThat(HOST.getParameters()).isEmpty();
+    assertThat(view.toUrl()).isEqualTo("/b/docs");
   }
 
   @Test
@@ -389,18 +387,18 @@
         .setPathPart("/path/to/a/file")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.PATH, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals("path/to/a/file", view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.PATH);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getPathPart()).isEqualTo("path/to/a/file");
+    assertThat(HOST.getParameters()).isEmpty();
 
-    assertEquals("/b/foo/bar/+/master/path/to/a/file", view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+/master/path/to/a/file");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo", "/b/foo/"),
             breadcrumb("bar", "/b/foo/bar/"),
@@ -409,8 +407,8 @@
             breadcrumb("path", "/b/foo/bar/+/master/path"),
             breadcrumb("to", "/b/foo/bar/+/master/path/to"),
             breadcrumb("a", "/b/foo/bar/+/master/path/to/a"),
-            breadcrumb("file", "/b/foo/bar/+/master/path/to/a/file")),
-        view.getBreadcrumbs());
+            breadcrumb("file", "/b/foo/bar/+/master/path/to/a/file"))
+        .inOrder();
   }
 
   @Test
@@ -425,19 +423,19 @@
         .setPathPart("/path/to/a/file")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.DIFF, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals("master^", view.getOldRevision().getName());
-    assertEquals("path/to/a/file", view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.DIFF);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getOldRevision().getName()).isEqualTo("master^");
+    assertThat(view.getPathPart()).isEqualTo("path/to/a/file");
+    assertThat(HOST.getParameters()).isEmpty();
 
-    assertEquals("/b/foo/bar/+/master%5E%21/path/to/a/file", view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+/master%5E%21/path/to/a/file");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo", "/b/foo/"),
             breadcrumb("bar", "/b/foo/bar/"),
@@ -446,8 +444,8 @@
             breadcrumb("path", "/b/foo/bar/+/master%5E%21/path"),
             breadcrumb("to", "/b/foo/bar/+/master%5E%21/path/to"),
             breadcrumb("a", "/b/foo/bar/+/master%5E%21/path/to/a"),
-            breadcrumb("file", "/b/foo/bar/+/master%5E%21/path/to/a/file")),
-        view.getBreadcrumbs());
+            breadcrumb("file", "/b/foo/bar/+/master%5E%21/path/to/a/file"))
+        .inOrder();
   }
 
   @Test
@@ -460,19 +458,19 @@
         .setPathPart("/path/to/a/file")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.DIFF, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals("path/to/a/file", view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.DIFF);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isEqualTo("path/to/a/file");
+    assertThat(HOST.getParameters()).isEmpty();
 
-    assertEquals("/b/foo/bar/+/master%5E%21/path/to/a/file", view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+/master%5E%21/path/to/a/file");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo", "/b/foo/"),
             breadcrumb("bar", "/b/foo/bar/"),
@@ -481,8 +479,8 @@
             breadcrumb("path", "/b/foo/bar/+/master%5E%21/path"),
             breadcrumb("to", "/b/foo/bar/+/master%5E%21/path/to"),
             breadcrumb("a", "/b/foo/bar/+/master%5E%21/path/to/a"),
-            breadcrumb("file", "/b/foo/bar/+/master%5E%21/path/to/a/file")),
-        view.getBreadcrumbs());
+            breadcrumb("file", "/b/foo/bar/+/master%5E%21/path/to/a/file"))
+        .inOrder();
   }
 
   @Test
@@ -497,19 +495,19 @@
         .setPathPart("/path/to/a/file")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.DIFF, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals("efab5678", view.getOldRevision().getName());
-    assertEquals("path/to/a/file", view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.DIFF);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getOldRevision().getName()).isEqualTo("efab5678");
+    assertThat(view.getPathPart()).isEqualTo("path/to/a/file");
+    assertThat(HOST.getParameters()).isEmpty();
 
-    assertEquals("/b/foo/bar/+/efab5678..master/path/to/a/file", view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+/efab5678..master/path/to/a/file");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo", "/b/foo/"),
             breadcrumb("bar", "/b/foo/bar/"),
@@ -518,8 +516,8 @@
             breadcrumb("path", "/b/foo/bar/+/efab5678..master/path"),
             breadcrumb("to", "/b/foo/bar/+/efab5678..master/path/to"),
             breadcrumb("a", "/b/foo/bar/+/efab5678..master/path/to/a"),
-            breadcrumb("file", "/b/foo/bar/+/efab5678..master/path/to/a/file")),
-        view.getBreadcrumbs());
+            breadcrumb("file", "/b/foo/bar/+/efab5678..master/path/to/a/file"))
+        .inOrder();
   }
 
   @Test
@@ -531,24 +529,24 @@
         .setRevision(Revision.unpeeled("master", id))
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.LOG, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertNull(view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.LOG);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isNull();
+    assertThat(HOST.getParameters()).isEmpty();
 
-    assertEquals("/b/foo/bar/+log/master", view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+log/master");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo", "/b/foo/"),
             breadcrumb("bar", "/b/foo/bar/"),
-            breadcrumb("master", "/b/foo/bar/+log/master")),
-        view.getBreadcrumbs());
+            breadcrumb("master", "/b/foo/bar/+log/master"))
+        .inOrder();
   }
 
   @Test
@@ -560,24 +558,24 @@
         .setRevision(Revision.unpeeled("abcd1234", id))
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.LOG, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("abcd1234", view.getRevision().getName());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertNull(view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.LOG);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("abcd1234");
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isNull();
+    assertThat(HOST.getParameters()).isEmpty();
 
-    assertEquals("/b/foo/bar/+log/abcd1234", view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+log/abcd1234");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo", "/b/foo/"),
             breadcrumb("bar", "/b/foo/bar/"),
-            breadcrumb("abcd1234", "/b/foo/bar/+log/abcd1234")),
-        view.getBreadcrumbs());
+            breadcrumb("abcd1234", "/b/foo/bar/+log/abcd1234"))
+        .inOrder();
   }
 
   @Test
@@ -590,19 +588,19 @@
         .setPathPart("/path/to/a/file")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.LOG, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals("path/to/a/file", view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.LOG);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isEqualTo("path/to/a/file");
+    assertThat(HOST.getParameters()).isEmpty();
 
-    assertEquals("/b/foo/bar/+log/master/path/to/a/file", view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+log/master/path/to/a/file");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo", "/b/foo/"),
             breadcrumb("bar", "/b/foo/bar/"),
@@ -610,8 +608,8 @@
             breadcrumb("path", "/b/foo/bar/+log/master/path"),
             breadcrumb("to", "/b/foo/bar/+log/master/path/to"),
             breadcrumb("a", "/b/foo/bar/+log/master/path/to/a"),
-            breadcrumb("file", "/b/foo/bar/+log/master/path/to/a/file")),
-        view.getBreadcrumbs());
+            breadcrumb("file", "/b/foo/bar/+log/master/path/to/a/file"))
+        .inOrder();
   }
 
   @Test
@@ -626,19 +624,19 @@
         .setPathPart("/path/to/a/file")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.LOG, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals("master^", view.getOldRevision().getName());
-    assertEquals("path/to/a/file", view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.LOG);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getOldRevision().getName()).isEqualTo("master^");
+    assertThat(view.getPathPart()).isEqualTo("path/to/a/file");
+    assertThat(HOST.getParameters()).isEmpty();
 
-    assertEquals("/b/foo/bar/+log/master%5E..master/path/to/a/file", view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+log/master%5E..master/path/to/a/file");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo", "/b/foo/"),
             breadcrumb("bar", "/b/foo/bar/"),
@@ -646,8 +644,8 @@
             breadcrumb("path", "/b/foo/bar/+log/master%5E..master/path"),
             breadcrumb("to", "/b/foo/bar/+log/master%5E..master/path/to"),
             breadcrumb("a", "/b/foo/bar/+log/master%5E..master/path/to/a"),
-            breadcrumb("file", "/b/foo/bar/+log/master%5E..master/path/to/a/file")),
-        view.getBreadcrumbs());
+            breadcrumb("file", "/b/foo/bar/+log/master%5E..master/path/to/a/file"))
+        .inOrder();
   }
 
   @Test
@@ -657,22 +655,22 @@
         .setRepositoryName("foo/bar")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.LOG, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(Revision.NULL, view.getRevision());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertTrue(HOST.getParameters().isEmpty());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.LOG);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(HOST.getParameters()).isEmpty();
 
-    assertEquals("/b/foo/bar/+log", view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+log");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo", "/b/foo/"),
             breadcrumb("bar", "/b/foo/bar/"),
-            breadcrumb("HEAD", "/b/foo/bar/+log")),
-        view.getBreadcrumbs());
+            breadcrumb("HEAD", "/b/foo/bar/+log"))
+        .inOrder();
   }
 
   @Test
@@ -685,16 +683,16 @@
         .setExtension(".tar.bz2")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.ARCHIVE, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertNull(view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
-    assertEquals("/b/foo/bar/+archive/master.tar.bz2", view.toUrl());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.ARCHIVE);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isNull();
+    assertThat(HOST.getParameters()).isEmpty();
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+archive/master.tar.bz2");
   }
 
   @Test
@@ -708,16 +706,16 @@
         .setExtension(".tar.bz2")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.ARCHIVE, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals("path/to/a/dir", view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
-    assertEquals("/b/foo/bar/+archive/master/path/to/a/dir.tar.bz2", view.toUrl());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.ARCHIVE);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isEqualTo("path/to/a/dir");
+    assertThat(HOST.getParameters()).isEmpty();
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+archive/master/path/to/a/dir.tar.bz2");
   }
 
   @Test
@@ -730,26 +728,26 @@
         .setPathPart("/dir/file")
         .build();
 
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.BLAME, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo/bar", view.getRepositoryName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals("dir/file", view.getPathPart());
-    assertTrue(HOST.getParameters().isEmpty());
-    assertEquals("/b/foo/bar/+blame/master/dir/file", view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.BLAME);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo/bar");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isEqualTo("dir/file");
+    assertThat(HOST.getParameters()).isEmpty();
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+blame/master/dir/file");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo", "/b/foo/"),
             breadcrumb("bar", "/b/foo/bar/"),
             breadcrumb("master", "/b/foo/bar/+/master"),
             breadcrumb(".", "/b/foo/bar/+/master/"),
             breadcrumb("dir", "/b/foo/bar/+/master/dir"),
-            breadcrumb("file", "/b/foo/bar/+blame/master/dir/file")),
-        view.getBreadcrumbs());
+            breadcrumb("file", "/b/foo/bar/+blame/master/dir/file"))
+        .inOrder();
   }
 
   @Test
@@ -768,24 +766,23 @@
         .build();
 
     // Fields returned by getters are not escaped.
-    assertEquals("/b", view.getServletPath());
-    assertEquals(Type.LOG, view.getType());
-    assertEquals("host", view.getHostName());
-    assertEquals("foo?bar", view.getRepositoryName());
-    assertEquals(id, view.getRevision().getId());
-    assertEquals("ba/d#name", view.getRevision().getName());
-    assertEquals(parent, view.getOldRevision().getId());
-    assertEquals("other\"na/me", view.getOldRevision().getName());
-    assertEquals("we ird/pa'th/name", view.getPathPart());
-    assertEquals(ImmutableListMultimap.<String, String> of("k e y", "val/ue"),
-        view.getParameters());
+    assertThat(view.getServletPath()).isEqualTo("/b");
+    assertThat(view.getType()).isEqualTo(Type.LOG);
+    assertThat(view.getHostName()).isEqualTo("host");
+    assertThat(view.getRepositoryName()).isEqualTo("foo?bar");
+    assertThat(view.getRevision().getId()).isEqualTo(id);
+    assertThat(view.getRevision().getName()).isEqualTo("ba/d#name");
+    assertThat(view.getOldRevision().getId()).isEqualTo(parent);
+    assertThat(view.getOldRevision().getName()).isEqualTo("other\"na/me");
+    assertThat(view.getPathPart()).isEqualTo("we ird/pa'th/name");
+    assertThat(view.getParameters())
+        .isEqualTo(ImmutableListMultimap.<String, String> of("k e y", "val/ue"));
 
     String qs = "?k+e+y=val%2Fue";
-    assertEquals(
-        "/b/foo%3Fbar/+log/other%22na/me..ba/d%23name/we%20ird/pa%27th/name" + qs + "#anc%23hor",
-        view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.toUrl()).isEqualTo(
+        "/b/foo%3Fbar/+log/other%22na/me..ba/d%23name/we%20ird/pa%27th/name" + qs + "#anc%23hor");
+    assertThat(view.getBreadcrumbs())
+        .containsExactly(
             // Names are not escaped (auto-escaped by Soy) but values are.
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo?bar", "/b/foo%3Fbar/"),
@@ -796,8 +793,8 @@
             breadcrumb("pa'th",
               "/b/foo%3Fbar/+log/other%22na/me..ba/d%23name/we%20ird/pa%27th" + qs),
             breadcrumb("name",
-              "/b/foo%3Fbar/+log/other%22na/me..ba/d%23name/we%20ird/pa%27th/name" + qs)),
-        view.getBreadcrumbs());
+              "/b/foo%3Fbar/+log/other%22na/me..ba/d%23name/we%20ird/pa%27th/name" + qs))
+        .inOrder();
   }
 
   @Test
@@ -810,9 +807,9 @@
         .setPathPart("/path/to/a/file")
         .build();
 
-    assertEquals("/b/foo/bar/+/master/path/to/a/file", view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+/master/path/to/a/file");
+    assertThat(view.getBreadcrumbs(ImmutableList.of(false, true, true)))
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo", "/b/foo/"),
             breadcrumb("bar", "/b/foo/bar/"),
@@ -821,10 +818,10 @@
             breadcrumb("path", "/b/foo/bar/+/master/path"),
             breadcrumb("to", "/b/foo/bar/+/master/path/to?autodive=0"),
             breadcrumb("a", "/b/foo/bar/+/master/path/to/a?autodive=0"),
-            breadcrumb("file", "/b/foo/bar/+/master/path/to/a/file")),
-        view.getBreadcrumbs(ImmutableList.of(false, true, true)));
-    assertEquals(
-        ImmutableList.of(
+            breadcrumb("file", "/b/foo/bar/+/master/path/to/a/file"))
+        .inOrder();
+    assertThat(view.getBreadcrumbs(ImmutableList.of(true, false, false)))
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo", "/b/foo/"),
             breadcrumb("bar", "/b/foo/bar/"),
@@ -833,8 +830,8 @@
             breadcrumb("path", "/b/foo/bar/+/master/path?autodive=0"),
             breadcrumb("to", "/b/foo/bar/+/master/path/to"),
             breadcrumb("a", "/b/foo/bar/+/master/path/to/a"),
-            breadcrumb("file", "/b/foo/bar/+/master/path/to/a/file")),
-        view.getBreadcrumbs(ImmutableList.of(true, false, false)));
+            breadcrumb("file", "/b/foo/bar/+/master/path/to/a/file"))
+        .inOrder();
   }
 
   @Test
@@ -847,15 +844,15 @@
         .setPathPart("")
         .build();
 
-    assertEquals("/b/foo/bar/+/master/", view.toUrl());
-    assertEquals(
-        ImmutableList.of(
+    assertThat(view.toUrl()).isEqualTo("/b/foo/bar/+/master/");
+    assertThat(view.getBreadcrumbs(ImmutableList.<Boolean> of()))
+        .containsExactly(
             breadcrumb("host", "/b/?format=HTML"),
             breadcrumb("foo", "/b/foo/"),
             breadcrumb("bar", "/b/foo/bar/"),
             breadcrumb("master", "/b/foo/bar/+/master"),
-            breadcrumb(".", "/b/foo/bar/+/master/")),
-        view.getBreadcrumbs(ImmutableList.<Boolean> of()));
+            breadcrumb(".", "/b/foo/bar/+/master/"))
+        .inOrder();
   }
 
   private static ImmutableMap<String, String> breadcrumb(String text, String url) {
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/GitwebRedirectFilterTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/GitwebRedirectFilterTest.java
index c50b54f..b8d4e82 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/GitwebRedirectFilterTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/GitwebRedirectFilterTest.java
@@ -14,11 +14,11 @@
 
 package com.google.gitiles;
 
+import static com.google.common.truth.Truth.assertThat;
 import static com.google.gitiles.FakeHttpServletRequest.SERVLET_PATH;
 import static com.google.gitiles.TestGitilesUrls.HOST_NAME;
 import static javax.servlet.http.HttpServletResponse.SC_GONE;
 import static javax.servlet.http.HttpServletResponse.SC_MOVED_PERMANENTLY;
-import static org.junit.Assert.assertEquals;
 
 import com.google.common.net.HttpHeaders;
 
@@ -51,14 +51,14 @@
   private void assertRedirectsTo(String expectedLocation, HttpServletRequest req) throws Exception {
     FakeHttpServletResponse res = new FakeHttpServletResponse();
     servlet.service(req, res);
-    assertEquals(SC_MOVED_PERMANENTLY, res.getStatus());
-    assertEquals(expectedLocation, res.getHeader(HttpHeaders.LOCATION));
+    assertThat(res.getStatus()).isEqualTo(SC_MOVED_PERMANENTLY);
+    assertThat(res.getHeader(HttpHeaders.LOCATION)).isEqualTo(expectedLocation);
   }
 
   private void assertGone(HttpServletRequest req) throws Exception {
     FakeHttpServletResponse res = new FakeHttpServletResponse();
     servlet.service(req, res);
-    assertEquals(SC_GONE, res.getStatus());
+    assertThat(res.getStatus()).isEqualTo(SC_GONE);
   }
 
   private static FakeHttpServletRequest newRequest(String qs) {
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/HostIndexServletTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/HostIndexServletTest.java
index 5f26f71..4bc26a2 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/HostIndexServletTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/HostIndexServletTest.java
@@ -14,11 +14,9 @@
 
 package com.google.gitiles;
 
+import static com.google.common.truth.Truth.assertThat;
 import static com.google.gitiles.TestGitilesUrls.URLS;
 import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertSame;
 
 import com.google.gson.reflect.TypeToken;
 import com.google.template.soy.data.SoyListData;
@@ -52,69 +50,69 @@
   @Test
   public void rootHtml() throws Exception {
     Map<String, ?> data = buildData("/");
-    assertEquals(URLS.getHostName(null), data.get("hostName"));
-    assertSame(NullData.INSTANCE, data.get("breadcrumbs"));
-    assertEquals("", data.get("prefix"));
+    assertThat(data).containsEntry("hostName", URLS.getHostName(null));
+    assertThat(data).containsEntry("breadcrumbs", NullData.INSTANCE);
+    assertThat(data).containsEntry("prefix", "");
 
     SoyListData repos = (SoyListData) data.get("repositories");
-    assertEquals(1, repos.length());
+    assertThat(repos).hasSize(1);
 
     SoyMapData ent = (SoyMapData) repos.get(0);
-    assertEquals(NAME, ent.get("name").toString());
-    assertEquals("/b/" + NAME + "/", ent.get("url").toString());
+    assertThat(ent.get("name").toString()).isEqualTo(NAME);
+    assertThat(ent.get("url").toString()).isEqualTo("/b/" + NAME + "/");
   }
 
   @Test
   public void fooSubdirHtml() throws Exception {
     Map<String, ?> data = buildData("/foo/");
-    assertEquals(URLS.getHostName(null) + "/foo", data.get("hostName"));
-    assertEquals("foo/", data.get("prefix"));
+    assertThat(data).containsEntry("hostName", URLS.getHostName(null) + "/foo");
+    assertThat(data).containsEntry("prefix", "foo/");
 
     SoyListData breadcrumbs = (SoyListData) data.get("breadcrumbs");
-    assertEquals(2, breadcrumbs.length());
+    assertThat(breadcrumbs.length()).isEqualTo(2);
 
     SoyListData repos = (SoyListData) data.get("repositories");
-    assertEquals(1, repos.length());
+    assertThat(repos.length()).isEqualTo(1);
 
     SoyMapData ent = (SoyMapData) repos.get(0);
-    assertEquals("bar/repo", ent.get("name").toString());
-    assertEquals("/b/" + NAME + "/", ent.get("url").toString());
+    assertThat(ent.get("name").toString()).isEqualTo("bar/repo");
+    assertThat(ent.get("url").toString()).isEqualTo("/b/" + NAME + "/");
   }
 
   @Test
   public void fooBarSubdirHtml() throws Exception {
     Map<String, ?> data = buildData("/foo/bar/");
-    assertEquals(URLS.getHostName(null) + "/foo/bar", data.get("hostName"));
-    assertEquals("foo/bar/", data.get("prefix"));
+    assertThat(data).containsEntry("hostName", URLS.getHostName(null) + "/foo/bar");
+    assertThat(data).containsEntry("prefix", "foo/bar/");
 
     SoyListData breadcrumbs = (SoyListData) data.get("breadcrumbs");
-    assertEquals(3, breadcrumbs.length());
+    assertThat(breadcrumbs.length()).isEqualTo(3);
 
     SoyListData repos = (SoyListData) data.get("repositories");
-    assertEquals(1, repos.length());
+    assertThat(repos.length()).isEqualTo(1);
 
     SoyMapData ent = (SoyMapData) repos.get(0);
-    assertEquals("repo", ent.get("name").toString());
-    assertEquals("/b/" + NAME + "/", ent.get("url").toString());
+    assertThat(ent.get("name").toString()).isEqualTo("repo");
+    assertThat(ent.get("url").toString()).isEqualTo("/b/" + NAME + "/");
   }
 
   @Test
   public void rootText() throws Exception {
     String name = repo.getRepository().getDescription().getRepositoryName();
     FakeHttpServletResponse res = buildText("/");
-    assertEquals(name + "\n", new String(res.getActualBody(), UTF_8));
+    assertThat(new String(res.getActualBody(), UTF_8)).isEqualTo(name + "\n");
   }
 
   @Test
   public void fooSubdirText() throws Exception {
     FakeHttpServletResponse res = buildText("/foo/");
-    assertEquals("bar/repo\n", new String(res.getActualBody(), UTF_8));
+    assertThat(new String(res.getActualBody(), UTF_8)).isEqualTo("bar/repo\n");
   }
 
   @Test
   public void fooBarSubdirText() throws Exception {
     FakeHttpServletResponse res = buildText("/foo/bar/");
-    assertEquals("repo\n", new String(res.getActualBody(), UTF_8));
+    assertThat(new String(res.getActualBody(), UTF_8)).isEqualTo("repo\n");
   }
 
   @Test
@@ -124,10 +122,10 @@
         "/",
         new TypeToken<Map<String, RepositoryDescription>>() {}.getType());
 
-    assertEquals(1, res.size());
+    assertThat(res).hasSize(1);
+    assertThat(res).containsKey(name);
     RepositoryDescription d = res.get(name);
-    assertNotNull(name + " exists", d);
-    assertEquals(name, d.name);
+    assertThat(d.name).isEqualTo(name);
   }
 
   @Test
@@ -136,10 +134,10 @@
         "/foo/",
         new TypeToken<Map<String, RepositoryDescription>>() {}.getType());
 
-    assertEquals(1, res.size());
+    assertThat(res).hasSize(1);
+    assertThat(res).containsKey("bar/repo");
     RepositoryDescription d = res.get("bar/repo");
-    assertNotNull("bar/repo exists", d);
-    assertEquals(repo.getRepository().getDescription().getRepositoryName(), d.name);
+    assertThat(d.name).isEqualTo(repo.getRepository().getDescription().getRepositoryName());
   }
 
   @Test
@@ -148,10 +146,10 @@
         "/foo/bar/",
         new TypeToken<Map<String, RepositoryDescription>>() {}.getType());
 
-    assertEquals(1, res.size());
+    assertThat(res).hasSize(1);
+    assertThat(res).containsKey("repo");
     RepositoryDescription d = res.get("repo");
-    assertNotNull("repo exists", d);
-    assertEquals(repo.getRepository().getDescription().getRepositoryName(), d.name);
+    assertThat(d.name).isEqualTo(repo.getRepository().getDescription().getRepositoryName());
   }
 
   @Test
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/IdentRevFilterTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/IdentRevFilterTest.java
index 0779552..43992d5 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/IdentRevFilterTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/IdentRevFilterTest.java
@@ -14,8 +14,7 @@
 
 package com.google.gitiles;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static com.google.common.truth.Truth.assertThat;
 
 import org.eclipse.jgit.junit.TestRepository;
 import org.eclipse.jgit.lib.PersonIdent;
@@ -37,55 +36,55 @@
   @Test
   public void matchesName() throws Exception {
     IdentRevFilter filter = IdentRevFilter.author("eSt");
-    assertTrue(filter.matchesPerson(new PersonIdent("eSt", "null@google.com")));
-    assertTrue(filter.matchesPerson(new PersonIdent("eStablish", "null@google.com")));
-    assertTrue(filter.matchesPerson(new PersonIdent("teSt", "null@google.com")));
-    assertTrue(filter.matchesPerson(new PersonIdent("teSting", "null@google.com")));
+    assertThat(filter.matchesPerson(new PersonIdent("eSt", "null@google.com"))).isTrue();
+    assertThat(filter.matchesPerson(new PersonIdent("eStablish", "null@google.com"))).isTrue();
+    assertThat(filter.matchesPerson(new PersonIdent("teSt", "null@google.com"))).isTrue();
+    assertThat(filter.matchesPerson(new PersonIdent("teSting", "null@google.com"))).isTrue();
   }
 
   @Test
   public void caseSensitiveName() throws Exception {
     IdentRevFilter filter = IdentRevFilter.author("eSt");
-    assertFalse(filter.matchesPerson(new PersonIdent("est", "null@google.com")));
-    assertFalse(filter.matchesPerson(new PersonIdent("Establish", "null@google.com")));
-    assertFalse(filter.matchesPerson(new PersonIdent("tESt", "null@google.com")));
-    assertFalse(filter.matchesPerson(new PersonIdent("tesTing", "null@google.com")));
+    assertThat(filter.matchesPerson(new PersonIdent("est", "null@google.com"))).isFalse();
+    assertThat(filter.matchesPerson(new PersonIdent("Establish", "null@google.com"))).isFalse();
+    assertThat(filter.matchesPerson(new PersonIdent("tESt", "null@google.com"))).isFalse();
+    assertThat(filter.matchesPerson(new PersonIdent("tesTing", "null@google.com"))).isFalse();
   }
 
   @Test
   public void matchesEmailLocalPart() throws Exception {
     IdentRevFilter filter = IdentRevFilter.author("eSt");
-    assertTrue(filter.matchesPerson(new PersonIdent("null", "eSt@google.com")));
-    assertTrue(filter.matchesPerson(new PersonIdent("null", "eStablish@google.com")));
-    assertTrue(filter.matchesPerson(new PersonIdent("null", "teSt@google.com")));
-    assertTrue(filter.matchesPerson(new PersonIdent("null", "teSting@google.com")));
+    assertThat(filter.matchesPerson(new PersonIdent("null", "eSt@google.com"))).isTrue();
+    assertThat(filter.matchesPerson(new PersonIdent("null", "eStablish@google.com"))).isTrue();
+    assertThat(filter.matchesPerson(new PersonIdent("null", "teSt@google.com"))).isTrue();
+    assertThat(filter.matchesPerson(new PersonIdent("null", "teSting@google.com"))).isTrue();
   }
 
   @Test
   public void caseSensitiveEmailLocalPart() throws Exception {
     IdentRevFilter filter = IdentRevFilter.author("eSt");
-    assertFalse(filter.matchesPerson(new PersonIdent("null", "est@google.com")));
-    assertFalse(filter.matchesPerson(new PersonIdent("null", "Establish@google.com")));
-    assertFalse(filter.matchesPerson(new PersonIdent("null", "tESt@google.com")));
-    assertFalse(filter.matchesPerson(new PersonIdent("null", "tesTing@google.com")));
+    assertThat(filter.matchesPerson(new PersonIdent("null", "est@google.com"))).isFalse();
+    assertThat(filter.matchesPerson(new PersonIdent("null", "Establish@google.com"))).isFalse();
+    assertThat(filter.matchesPerson(new PersonIdent("null", "tESt@google.com"))).isFalse();
+    assertThat(filter.matchesPerson(new PersonIdent("null", "tesTing@google.com"))).isFalse();
   }
 
   @Test
   public void matchesEmailDomain() throws Exception {
     // git log --author matches the email domain as well as the enail name.
     IdentRevFilter filter = IdentRevFilter.author("eSt");
-    assertTrue(filter.matchesPerson(new PersonIdent("null", "null@eSt.com")));
-    assertTrue(filter.matchesPerson(new PersonIdent("null", "null@eStablish.com")));
-    assertTrue(filter.matchesPerson(new PersonIdent("null", "null@teSt.com")));
-    assertTrue(filter.matchesPerson(new PersonIdent("null", "null@teSting.com")));
+    assertThat(filter.matchesPerson(new PersonIdent("null", "null@eSt.com"))).isTrue();
+    assertThat(filter.matchesPerson(new PersonIdent("null", "null@eStablish.com"))).isTrue();
+    assertThat(filter.matchesPerson(new PersonIdent("null", "null@teSt.com"))).isTrue();
+    assertThat(filter.matchesPerson(new PersonIdent("null", "null@teSting.com"))).isTrue();
   }
 
   @Test
   public void caseSensitiveEmailDomain() throws Exception {
     IdentRevFilter filter = IdentRevFilter.author("eSt");
-    assertFalse(filter.matchesPerson(new PersonIdent("null", "null@est.com")));
-    assertFalse(filter.matchesPerson(new PersonIdent("null", "null@Establish.com")));
-    assertFalse(filter.matchesPerson(new PersonIdent("null", "null@tESt.com")));
-    assertFalse(filter.matchesPerson(new PersonIdent("null", "null@tesTing.com")));
+    assertThat(filter.matchesPerson(new PersonIdent("null", "null@est.com"))).isFalse();
+    assertThat(filter.matchesPerson(new PersonIdent("null", "null@Establish.com"))).isFalse();
+    assertThat(filter.matchesPerson(new PersonIdent("null", "null@tESt.com"))).isFalse();
+    assertThat(filter.matchesPerson(new PersonIdent("null", "null@tesTing.com"))).isFalse();
   }
 }
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/LinkifierTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/LinkifierTest.java
index 4cca863..5497291 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/LinkifierTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/LinkifierTest.java
@@ -14,9 +14,8 @@
 
 package com.google.gitiles;
 
-import static org.junit.Assert.assertEquals;
+import static com.google.common.truth.Truth.assertThat;
 
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 
 import org.eclipse.jgit.lib.Config;
@@ -35,32 +34,36 @@
   public void linkifyMessageNoMatch() throws Exception {
     Config config = new Config();
     Linkifier l = new Linkifier(TestGitilesUrls.URLS, config);
-    assertEquals(ImmutableList.of(ImmutableMap.of("text", "some message text")),
-        l.linkify(FakeHttpServletRequest.newRequest(), "some message text"));
+    assertThat(l.linkify(FakeHttpServletRequest.newRequest(), "some message text"))
+        .containsExactly(ImmutableMap.of("text", "some message text"));
   }
 
   @Test
   public void linkifyMessageUrl() throws Exception {
     Config config = new Config();
     Linkifier l = new Linkifier(TestGitilesUrls.URLS, config);
-    assertEquals(ImmutableList.of(
-        ImmutableMap.of("text", "http://my/url", "url", "http://my/url")),
-        l.linkify(REQ, "http://my/url"));
-    assertEquals(ImmutableList.of(
-        ImmutableMap.of("text", "https://my/url", "url", "https://my/url")),
-        l.linkify(REQ, "https://my/url"));
-    assertEquals(ImmutableList.of(
-        ImmutableMap.of("text", "foo "),
-        ImmutableMap.of("text", "http://my/url", "url", "http://my/url"),
-        ImmutableMap.of("text", " bar")),
-        l.linkify(REQ, "foo http://my/url bar"));
-    assertEquals(ImmutableList.of(
-        ImmutableMap.of("text", "foo "),
-        ImmutableMap.of("text", "http://my/url", "url", "http://my/url"),
-        ImmutableMap.of("text", " bar "),
-        ImmutableMap.of("text", "http://my/other/url", "url", "http://my/other/url"),
-        ImmutableMap.of("text", " baz")),
-        l.linkify(REQ, "foo http://my/url bar http://my/other/url baz"));
+    assertThat(l.linkify(REQ, "http://my/url"))
+        .containsExactly(
+            ImmutableMap.of("text", "http://my/url", "url", "http://my/url"))
+        .inOrder();
+    assertThat(l.linkify(REQ, "https://my/url"))
+        .containsExactly(
+            ImmutableMap.of("text", "https://my/url", "url", "https://my/url"))
+        .inOrder();
+    assertThat(l.linkify(REQ, "foo http://my/url bar"))
+        .containsExactly(
+            ImmutableMap.of("text", "foo "),
+            ImmutableMap.of("text", "http://my/url", "url", "http://my/url"),
+            ImmutableMap.of("text", " bar"))
+        .inOrder();
+    assertThat(l.linkify(REQ, "foo http://my/url bar http://my/other/url baz"))
+        .containsExactly(
+            ImmutableMap.of("text", "foo "),
+            ImmutableMap.of("text", "http://my/url", "url", "http://my/url"),
+            ImmutableMap.of("text", " bar "),
+            ImmutableMap.of("text", "http://my/other/url", "url", "http://my/other/url"),
+            ImmutableMap.of("text", " baz"))
+        .inOrder();
   }
 
   @Test
@@ -82,33 +85,42 @@
         throw new UnsupportedOperationException();
       }
     }, config);
-    assertEquals(ImmutableList.of(ImmutableMap.of("text", "I0123456789")),
-        l.linkify(REQ, "I0123456789"));
-    assertEquals(ImmutableList.of(ImmutableMap.of("text", "Change-Id: I0123456789")),
-        l.linkify(REQ, "Change-Id: I0123456789"));
-    assertEquals(ImmutableList.of(ImmutableMap.of("text", "Change-Id: I0123456789 does not exist")),
-        l.linkify(REQ, "Change-Id: I0123456789 does not exist"));
+    assertThat(l.linkify(REQ, "I0123456789"))
+        .containsExactly(
+            ImmutableMap.of("text", "I0123456789"))
+        .inOrder();
+    assertThat(l.linkify(REQ, "Change-Id: I0123456789"))
+        .containsExactly(
+            ImmutableMap.of("text", "Change-Id: I0123456789"))
+        .inOrder();
+    assertThat(l.linkify(REQ, "Change-Id: I0123456789 does not exist"))
+        .containsExactly(
+            ImmutableMap.of("text", "Change-Id: I0123456789 does not exist"))
+        .inOrder();
   }
 
   @Test
   public void linkifyMessageChangeId() throws Exception {
     Config config = new Config();
     Linkifier l = new Linkifier(TestGitilesUrls.URLS, config);
-    assertEquals(ImmutableList.of(
-        ImmutableMap.of("text", "I0123456789",
-          "url", "http://test-host-review/foo/#/q/I0123456789,n,z")),
-        l.linkify(REQ, "I0123456789"));
-    assertEquals(ImmutableList.of(
-        ImmutableMap.of("text", "Change-Id: "),
-        ImmutableMap.of("text", "I0123456789",
-          "url", "http://test-host-review/foo/#/q/I0123456789,n,z")),
-        l.linkify(REQ, "Change-Id: I0123456789"));
-    assertEquals(ImmutableList.of(
-        ImmutableMap.of("text", "Change-Id: "),
-        ImmutableMap.of("text", "I0123456789",
-          "url", "http://test-host-review/foo/#/q/I0123456789,n,z"),
-        ImmutableMap.of("text", " exists")),
-        l.linkify(REQ, "Change-Id: I0123456789 exists"));
+    assertThat(l.linkify(REQ, "I0123456789"))
+        .containsExactly(
+            ImmutableMap.of("text", "I0123456789",
+              "url", "http://test-host-review/foo/#/q/I0123456789,n,z"))
+        .inOrder();
+    assertThat(l.linkify(REQ, "Change-Id: I0123456789"))
+        .containsExactly(
+            ImmutableMap.of("text", "Change-Id: "),
+            ImmutableMap.of("text", "I0123456789",
+              "url", "http://test-host-review/foo/#/q/I0123456789,n,z"))
+        .inOrder();
+    assertThat(l.linkify(REQ, "Change-Id: I0123456789 exists"))
+        .containsExactly(
+            ImmutableMap.of("text", "Change-Id: "),
+            ImmutableMap.of("text", "I0123456789",
+              "url", "http://test-host-review/foo/#/q/I0123456789,n,z"),
+            ImmutableMap.of("text", " exists"))
+        .inOrder();
   }
 
   @Test
@@ -119,38 +131,44 @@
     config.setString("commentlink", "featurelink", "match", "(Feature:\\s+)(\\d+)");
     config.setString("commentlink", "featurelink", "link", "http://features/$2");
     Linkifier l = new Linkifier(TestGitilesUrls.URLS, config);
-    assertEquals(ImmutableList.of(
-        ImmutableMap.of("text", "There is a new "),
-        ImmutableMap.of("text", "Feature: 103", "url", "http://features/103"),
-        ImmutableMap.of("text", ", which is similar to the reported "),
-        ImmutableMap.of("text", "bug 100", "url", "http://bugs/100")),
-        l.linkify(REQ, "There is a new Feature: 103, which is similar to the reported bug 100"));
+    assertThat(
+            l.linkify(REQ, "There is a new Feature: 103, which is similar to the reported bug 100"))
+        .containsExactly(
+            ImmutableMap.of("text", "There is a new "),
+            ImmutableMap.of("text", "Feature: 103", "url", "http://features/103"),
+            ImmutableMap.of("text", ", which is similar to the reported "),
+            ImmutableMap.of("text", "bug 100", "url", "http://bugs/100"))
+        .inOrder();
   }
 
   @Test
   public void linkifyMessageUrlAndChangeId() throws Exception {
     Config config = new Config();
     Linkifier l = new Linkifier(TestGitilesUrls.URLS, config);
-    assertEquals(ImmutableList.of(
-        ImmutableMap.of("text", "http://my/url/I0123456789", "url", "http://my/url/I0123456789"),
-        ImmutableMap.of("text", " is not change "),
-        ImmutableMap.of("text", "I0123456789",
-          "url", "http://test-host-review/foo/#/q/I0123456789,n,z")),
-        l.linkify(REQ, "http://my/url/I0123456789 is not change I0123456789"));
+    assertThat(l.linkify(REQ, "http://my/url/I0123456789 is not change I0123456789"))
+        .containsExactly(
+            ImmutableMap.of("text", "http://my/url/I0123456789",
+              "url", "http://my/url/I0123456789"),
+            ImmutableMap.of("text", " is not change "),
+            ImmutableMap.of("text", "I0123456789",
+              "url", "http://test-host-review/foo/#/q/I0123456789,n,z"))
+        .inOrder();
   }
 
   @Test
   public void linkifyAmpersand() throws Exception {
     Config config = new Config();
     Linkifier l = new Linkifier(TestGitilesUrls.URLS, config);
-    assertEquals(ImmutableList.of(
-        ImmutableMap.of("text", "http://my/url?a&b", "url", "http://my/url?a&b")),
-        l.linkify(REQ, "http://my/url?a&b"));
-    assertEquals(ImmutableList.of(
-        ImmutableMap.of("text", "http://weird/htmlified/?url",
-          "url", "http://weird/htmlified/?url"),
-        ImmutableMap.of("text", "&lt;p&rt;")),
-        l.linkify(REQ, "http://weird/htmlified/?url&lt;p&rt;"));
+    assertThat(l.linkify(REQ, "http://my/url?a&b"))
+        .containsExactly(
+            ImmutableMap.of("text", "http://my/url?a&b", "url", "http://my/url?a&b"))
+        .inOrder();
+    assertThat(l.linkify(REQ, "http://weird/htmlified/?url&lt;p&rt;"))
+        .containsExactly(
+            ImmutableMap.of("text", "http://weird/htmlified/?url",
+              "url", "http://weird/htmlified/?url"),
+            ImmutableMap.of("text", "&lt;p&rt;"))
+        .inOrder();
   }
 
   @Test
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/PaginatorTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/PaginatorTest.java
index e8af92e..2a08ab9 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/PaginatorTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/PaginatorTest.java
@@ -15,10 +15,8 @@
 package com.google.gitiles;
 
 import static com.google.common.base.Preconditions.checkArgument;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static com.google.common.truth.Truth.assertThat;
 
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Lists;
 
 import org.eclipse.jgit.internal.storage.dfs.DfsRepository;
@@ -58,11 +56,9 @@
     List<RevCommit> commits = linearCommits(1);
     walk.markStart(commits.get(0));
     Paginator p = new Paginator(walk, 10, null);
-    assertEquals(
-        ImmutableList.of(commits.get(0)),
-        ImmutableList.copyOf(p));
-    assertNull(p.getPreviousStart());
-    assertNull(p.getNextStart());
+    assertThat(p).containsExactly(commits.get(0));
+    assertThat(p.getPreviousStart()).isNull();
+    assertThat(p.getNextStart()).isNull();
   }
 
   @Test
@@ -70,14 +66,14 @@
     List<RevCommit> commits = linearCommits(3);
     walk.markStart(commits.get(2));
     Paginator p = new Paginator(walk, 10, null);
-    assertEquals(
-        ImmutableList.of(
-          commits.get(2),
-          commits.get(1),
-          commits.get(0)),
-        ImmutableList.copyOf(p));
-    assertNull(p.getPreviousStart());
-    assertNull(p.getNextStart());
+    assertThat(p)
+        .containsExactly(
+            commits.get(2),
+            commits.get(1),
+            commits.get(0))
+        .inOrder();
+    assertThat(p.getPreviousStart()).isNull();
+    assertThat(p.getNextStart()).isNull();
   }
 
   @Test
@@ -85,14 +81,14 @@
     List<RevCommit> commits = linearCommits(3);
     walk.markStart(commits.get(2));
     Paginator p = new Paginator(walk, 3, null);
-    assertEquals(
-        ImmutableList.of(
-          commits.get(2),
-          commits.get(1),
-          commits.get(0)),
-        ImmutableList.copyOf(p));
-    assertNull(p.getPreviousStart());
-    assertNull(p.getNextStart());
+    assertThat(p)
+        .containsExactly(
+            commits.get(2),
+            commits.get(1),
+            commits.get(0))
+        .inOrder();
+    assertThat(p.getPreviousStart()).isNull();
+    assertThat(p.getNextStart()).isNull();
   }
 
   @Test
@@ -100,14 +96,14 @@
     List<RevCommit> commits = linearCommits(5);
     walk.markStart(commits.get(4));
     Paginator p = new Paginator(walk, 3, null);
-    assertEquals(
-        ImmutableList.of(
-          commits.get(4),
-          commits.get(3),
-          commits.get(2)),
-        ImmutableList.copyOf(p));
-    assertNull(p.getPreviousStart());
-    assertEquals(commits.get(1), p.getNextStart());
+    assertThat(p)
+        .containsExactly(
+            commits.get(4),
+            commits.get(3),
+            commits.get(2))
+        .inOrder();
+    assertThat(p.getPreviousStart()).isNull();
+    assertThat(p.getNextStart()).isEqualTo(commits.get(1));
   }
 
   @Test
@@ -115,14 +111,14 @@
     List<RevCommit> commits = linearCommits(10);
     walk.markStart(commits.get(9));
     Paginator p = new Paginator(walk, 3, commits.get(9));
-    assertEquals(
-        ImmutableList.of(
-            commits.get(9),
-            commits.get(8),
-            commits.get(7)),
-        ImmutableList.copyOf(p));
-    assertNull(p.getPreviousStart());
-    assertEquals(commits.get(6), p.getNextStart());
+    assertThat(p)
+        .containsExactly(
+              commits.get(9),
+              commits.get(8),
+              commits.get(7))
+        .inOrder();
+    assertThat(p.getPreviousStart()).isNull();
+    assertThat(p.getNextStart()).isEqualTo(commits.get(6));
   }
 
   @Test
@@ -130,14 +126,14 @@
     List<RevCommit> commits = linearCommits(10);
     walk.markStart(commits.get(9));
     Paginator p = new Paginator(walk, 3, null);
-    assertEquals(
-        ImmutableList.of(
-            commits.get(9),
-            commits.get(8),
-            commits.get(7)),
-        ImmutableList.copyOf(p));
-    assertNull(p.getPreviousStart());
-    assertEquals(commits.get(6), p.getNextStart());
+    assertThat(p)
+        .containsExactly(
+              commits.get(9),
+              commits.get(8),
+              commits.get(7))
+        .inOrder();
+    assertThat(p.getPreviousStart()).isNull();
+    assertThat(p.getNextStart()).isEqualTo(commits.get(6));
   }
 
   @Test
@@ -145,14 +141,14 @@
     List<RevCommit> commits = linearCommits(10);
     walk.markStart(commits.get(9));
     Paginator p = new Paginator(walk, 3, commits.get(8));
-    assertEquals(
-        ImmutableList.of(
-            commits.get(8),
-            commits.get(7),
-            commits.get(6)),
-        ImmutableList.copyOf(p));
-    assertEquals(commits.get(9), p.getPreviousStart());
-    assertEquals(commits.get(5), p.getNextStart());
+    assertThat(p)
+        .containsExactly(
+              commits.get(8),
+              commits.get(7),
+              commits.get(6))
+        .inOrder();
+    assertThat(p.getPreviousStart()).isEqualTo(commits.get(9));
+    assertThat(p.getNextStart()).isEqualTo(commits.get(5));
   }
 
   @Test
@@ -160,14 +156,14 @@
     List<RevCommit> commits = linearCommits(10);
     walk.markStart(commits.get(9));
     Paginator p = new Paginator(walk, 3, commits.get(7));
-    assertEquals(
-        ImmutableList.of(
-            commits.get(7),
-            commits.get(6),
-            commits.get(5)),
-        ImmutableList.copyOf(p));
-    assertEquals(commits.get(9), p.getPreviousStart());
-    assertEquals(commits.get(4), p.getNextStart());
+    assertThat(p)
+        .containsExactly(
+              commits.get(7),
+              commits.get(6),
+              commits.get(5))
+        .inOrder();
+    assertThat(p.getPreviousStart()).isEqualTo(commits.get(9));
+    assertThat(p.getNextStart()).isEqualTo(commits.get(4));
   }
 
   @Test
@@ -175,14 +171,14 @@
     List<RevCommit> commits = linearCommits(10);
     walk.markStart(commits.get(9));
     Paginator p = new Paginator(walk, 3, commits.get(2));
-    assertEquals(
-        ImmutableList.of(
-            commits.get(2),
-            commits.get(1),
-            commits.get(0)),
-        ImmutableList.copyOf(p));
-    assertEquals(commits.get(5), p.getPreviousStart());
-    assertNull(p.getNextStart());
+    assertThat(p)
+        .containsExactly(
+              commits.get(2),
+              commits.get(1),
+              commits.get(0))
+        .inOrder();
+    assertThat(p.getPreviousStart()).isEqualTo(commits.get(5));
+    assertThat(p.getNextStart()).isNull();
   }
 
   @Test
@@ -190,13 +186,13 @@
     List<RevCommit> commits = linearCommits(10);
     walk.markStart(commits.get(9));
     Paginator p = new Paginator(walk, 3, commits.get(1));
-    assertEquals(
-        ImmutableList.of(
-            commits.get(1),
-            commits.get(0)),
-        ImmutableList.copyOf(p));
-    assertEquals(commits.get(4), p.getPreviousStart());
-    assertNull(p.getNextStart());
+    assertThat(p)
+        .containsExactly(
+              commits.get(1),
+              commits.get(0))
+        .inOrder();
+    assertThat(p.getPreviousStart()).isEqualTo(commits.get(4));
+    assertThat(p.getNextStart()).isNull();
   }
 
   @Test
@@ -204,13 +200,13 @@
     List<RevCommit> commits = linearCommits(10);
     walk.markStart(commits.get(9));
     Paginator p = new Paginator(walk, 5, commits.get(1));
-    assertEquals(
-        ImmutableList.of(
-            commits.get(1),
-            commits.get(0)),
-        ImmutableList.copyOf(p));
-    assertEquals(commits.get(6), p.getPreviousStart());
-    assertNull(p.getNextStart());
+    assertThat(p)
+        .containsExactly(
+              commits.get(1),
+              commits.get(0))
+        .inOrder();
+    assertThat(p.getPreviousStart()).isEqualTo(commits.get(6));
+    assertThat(p.getNextStart()).isNull();
   }
 
   private List<RevCommit> linearCommits(int n) throws Exception {
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/PathServletTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/PathServletTest.java
index c1ee384..4bc906a 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/PathServletTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/PathServletTest.java
@@ -14,8 +14,8 @@
 
 package com.google.gitiles;
 
+import static com.google.common.truth.Truth.assertThat;
 import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.junit.Assert.assertEquals;
 
 import com.google.common.io.BaseEncoding;
 import com.google.gitiles.TreeJsonData.Tree;
@@ -45,10 +45,10 @@
     repo.branch("master").commit().add("foo", "contents").create();
 
     Map<String, ?> data = buildData("/repo/+/master/");
-    assertEquals("TREE", data.get("type"));
+    assertThat(data).containsEntry("type", "TREE");
     List<Map<String, ?>> entries = getTreeEntries(data);
-    assertEquals(1, entries.size());
-    assertEquals("foo", entries.get(0).get("name"));
+    assertThat(entries).hasSize(1);
+    assertThat(entries.get(0).get("name")).isEqualTo("foo");
   }
 
   @Test
@@ -59,23 +59,23 @@
         .create();
 
     Map<String, ?> data = buildData("/repo/+/master/");
-    assertEquals("TREE", data.get("type"));
+    assertThat(data).containsEntry("type", "TREE");
     List<Map<String, ?>> entries = getTreeEntries(data);
-    assertEquals(2, entries.size());
-    assertEquals("baz", entries.get(0).get("name"));
-    assertEquals("foo/", entries.get(1).get("name"));
+    assertThat(entries).hasSize(2);
+    assertThat(entries.get(0).get("name")).isEqualTo("baz");
+    assertThat(entries.get(1).get("name")).isEqualTo("foo/");
 
     data = buildData("/repo/+/master/foo");
-    assertEquals("TREE", data.get("type"));
+    assertThat(data).containsEntry("type", "TREE");
     entries = getTreeEntries(data);
-    assertEquals(1, entries.size());
-    assertEquals("bar", entries.get(0).get("name"));
+    assertThat(entries).hasSize(1);
+    assertThat(entries.get(0).get("name")).isEqualTo("bar");
 
     data = buildData("/repo/+/master/foo/");
-    assertEquals("TREE", data.get("type"));
+    assertThat(data).containsEntry("type", "TREE");
     entries = getTreeEntries(data);
-    assertEquals(1, entries.size());
-    assertEquals("bar", entries.get(0).get("name"));
+    assertThat(entries).hasSize(1);
+    assertThat(entries.get(0).get("name")).isEqualTo("bar");
   }
 
   @Test
@@ -83,20 +83,20 @@
     repo.branch("master").commit().add("foo", "foo\ncontents\n").create();
 
     Map<String, ?> data = buildData("/repo/+/master/foo");
-    assertEquals("REGULAR_FILE", data.get("type"));
+    assertThat(data).containsEntry("type", "REGULAR_FILE");
 
     SoyListData lines = (SoyListData) getBlobData(data).get("lines");
-    assertEquals(2, lines.length());
+    assertThat(lines.length()).isEqualTo(2);
 
     SoyListData spans = lines.getListData(0);
-    assertEquals(1, spans.length());
-    assertEquals(StringData.forValue("pln"), spans.getMapData(0).get("classes"));
-    assertEquals(StringData.forValue("foo"), spans.getMapData(0).get("text"));
+    assertThat(spans.length()).isEqualTo(1);
+    assertThat(spans.getMapData(0).get("classes")).isEqualTo(StringData.forValue("pln"));
+    assertThat(spans.getMapData(0).get("text")).isEqualTo(StringData.forValue("foo"));
 
     spans = lines.getListData(1);
-    assertEquals(1, spans.length());
-    assertEquals(StringData.forValue("pln"), spans.getMapData(0).get("classes"));
-    assertEquals(StringData.forValue("contents"), spans.getMapData(0).get("text"));
+    assertThat(spans.length()).isEqualTo(1);
+    assertThat(spans.getMapData(0).get("classes")).isEqualTo(StringData.forValue("pln"));
+    assertThat(spans.getMapData(0).get("text")).isEqualTo(StringData.forValue("contents"));
   }
 
   @Test
@@ -112,8 +112,8 @@
       }).create();
 
     Map<String, ?> data = buildData("/repo/+/master/bar");
-    assertEquals("SYMLINK", data.get("type"));
-    assertEquals("foo", getBlobData(data).get("target"));
+    assertThat(data).containsEntry("type", "SYMLINK");
+    assertThat(getBlobData(data)).containsEntry("target", "foo");
   }
 
   @Test
@@ -132,19 +132,19 @@
         }).create();
 
     Map<String, ?> data = buildData("/repo/+/master/gitiles");
-    assertEquals("GITLINK", data.get("type"));
+    assertThat(data).containsEntry("type", "GITLINK");
 
     Map<String, ?> linkData = getBlobData(data);
-    assertEquals(gitilesSha, linkData.get("sha"));
-    assertEquals("https://gerrit.googlesource.com/gitiles", linkData.get("remoteUrl"));
-    assertEquals("https://gerrit.googlesource.com/gitiles", linkData.get("httpUrl"));
+    assertThat(linkData).containsEntry("sha", gitilesSha);
+    assertThat(linkData).containsEntry("remoteUrl", "https://gerrit.googlesource.com/gitiles");
+    assertThat(linkData).containsEntry("httpUrl", "https://gerrit.googlesource.com/gitiles");
   }
 
   @Test
   public void blobText() throws Exception {
     repo.branch("master").commit().add("foo", "contents").create();
     String text = buildBlob("/repo/+/master/foo", "100644");
-    assertEquals("contents", text);
+    assertThat(text).isEqualTo("contents");
   }
 
   @Test
@@ -159,7 +159,7 @@
           }
         }).create();
     String text = buildBlob("/repo/+/master/baz", "120000");
-    assertEquals("foo", text);
+    assertThat(text).isEqualTo("foo");
   }
 
   @Test
@@ -169,11 +169,11 @@
     repo.branch("master").commit().setTopLevelTree(tree).create();
 
     String expected = "040000 tree " + repo.get(tree, "foo").name() + "\tfoo\n";
-    assertEquals(expected, buildBlob("/repo/+/master/", "040000"));
+    assertThat(buildBlob("/repo/+/master/", "040000")).isEqualTo(expected);
 
     expected = "100644 blob " + blob.name() + "\tbar\n";
-    assertEquals(expected, buildBlob("/repo/+/master/foo", "040000"));
-    assertEquals(expected, buildBlob("/repo/+/master/foo/", "040000"));
+    assertThat(buildBlob("/repo/+/master/foo", "040000")).isEqualTo(expected);
+    assertThat(buildBlob("/repo/+/master/foo/", "040000")).isEqualTo(expected);
   }
 
   @Test
@@ -181,8 +181,8 @@
     RevBlob blob = repo.blob("contents");
     repo.branch("master").commit().add("foo\nbar\rbaz", blob).create();
 
-    assertEquals("100644 blob " + blob.name() + "\t\"foo\\nbar\\rbaz\"\n",
-        buildBlob("/repo/+/master/", "040000"));
+    assertThat(buildBlob("/repo/+/master/", "040000"))
+        .isEqualTo("100644 blob " + blob.name() + "\t\"foo\\nbar\\rbaz\"\n");
   }
 
   @Test
@@ -214,32 +214,32 @@
         .create());
 
     Tree tree = buildJson("/repo/+/master/", Tree.class);
-    assertEquals(c.getTree().name(), tree.id);
-    assertEquals(2, tree.entries.size());
-    assertEquals(0100644, tree.entries.get(0).mode);
-    assertEquals("blob", tree.entries.get(0).type);
-    assertEquals(repo.get(c.getTree(), "baz").name(), tree.entries.get(0).id);
-    assertEquals("baz", tree.entries.get(0).name);
-    assertEquals(040000, tree.entries.get(1).mode);
-    assertEquals("tree", tree.entries.get(1).type);
-    assertEquals(repo.get(c.getTree(), "foo").name(), tree.entries.get(1).id);
-    assertEquals("foo", tree.entries.get(1).name);
+    assertThat(tree.id).isEqualTo(c.getTree().name());
+    assertThat(tree.entries).hasSize(2);
+    assertThat(tree.entries.get(0).mode).isEqualTo(0100644);
+    assertThat(tree.entries.get(0).type).isEqualTo("blob");
+    assertThat(tree.entries.get(0).id).isEqualTo(repo.get(c.getTree(), "baz").name());
+    assertThat(tree.entries.get(0).name).isEqualTo("baz");
+    assertThat(tree.entries.get(1).mode).isEqualTo(040000);
+    assertThat(tree.entries.get(1).type).isEqualTo("tree");
+    assertThat(tree.entries.get(1).id).isEqualTo(repo.get(c.getTree(), "foo").name());
+    assertThat(tree.entries.get(1).name).isEqualTo("foo");
 
     tree = buildJson("/repo/+/master/foo", Tree.class);
-    assertEquals(repo.get(c.getTree(), "foo").name(), tree.id);
-    assertEquals(1, tree.entries.size());
-    assertEquals(0100644, tree.entries.get(0).mode);
-    assertEquals("blob", tree.entries.get(0).type);
-    assertEquals(repo.get(c.getTree(), "foo/bar").name(), tree.entries.get(0).id);
-    assertEquals("bar", tree.entries.get(0).name);
+    assertThat(tree.id).isEqualTo(repo.get(c.getTree(), "foo").name());
+    assertThat(tree.entries).hasSize(1);
+    assertThat(tree.entries.get(0).mode).isEqualTo(0100644);
+    assertThat(tree.entries.get(0).type).isEqualTo("blob");
+    assertThat(tree.entries.get(0).id).isEqualTo(repo.get(c.getTree(), "foo/bar").name());
+    assertThat(tree.entries.get(0).name).isEqualTo("bar");
 
     tree = buildJson("/repo/+/master/foo/", Tree.class);
-    assertEquals(repo.get(c.getTree(), "foo").name(), tree.id);
-    assertEquals(1, tree.entries.size());
-    assertEquals(0100644, tree.entries.get(0).mode);
-    assertEquals("blob", tree.entries.get(0).type);
-    assertEquals(repo.get(c.getTree(), "foo/bar").name(), tree.entries.get(0).id);
-    assertEquals("bar", tree.entries.get(0).name);
+    assertThat(tree.id).isEqualTo(repo.get(c.getTree(), "foo").name());
+    assertThat(tree.entries).hasSize(1);
+    assertThat(tree.entries.get(0).mode).isEqualTo(0100644);
+    assertThat(tree.entries.get(0).type).isEqualTo("blob");
+    assertThat(tree.entries.get(0).id).isEqualTo(repo.get(c.getTree(), "foo/bar").name());
+    assertThat(tree.entries.get(0).name).isEqualTo("bar");
   }
 
   private Map<String, ?> getBlobData(Map<String, ?> data) {
@@ -252,7 +252,7 @@
 
   private String buildBlob(String path, String expectedMode) throws Exception {
     FakeHttpServletResponse res = buildText(path);
-    assertEquals(expectedMode, res.getHeader(PathServlet.MODE_HEADER));
+    assertThat(res.getHeader(PathServlet.MODE_HEADER)).isEqualTo(expectedMode);
     String base64 = res.getActualBodyString();
     return new String(BaseEncoding.base64().decode(base64), UTF_8);
   }
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/PathsTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/PathsTest.java
index 11725ae..d96b7d8 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/PathsTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/PathsTest.java
@@ -14,9 +14,8 @@
 
 package com.google.gitiles;
 
+import static com.google.common.truth.Truth.assertThat;
 import static com.google.gitiles.PathUtil.simplifyPathUpToRoot;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -28,25 +27,25 @@
   @Test
   public void simplifyPathUpToRootSimplifiesPath() throws Exception {
     String root = "a/b/c";
-    assertNull(simplifyPathUpToRoot("/foo", root));
-    assertEquals("a", simplifyPathUpToRoot("../../", root));
-    assertEquals("a", simplifyPathUpToRoot(".././../", root));
-    assertEquals("a", simplifyPathUpToRoot("..//../", root));
-    assertEquals("a/d", simplifyPathUpToRoot("../../d", root));
-    assertEquals("", simplifyPathUpToRoot("../../..", root));
-    assertEquals("a/d/e", simplifyPathUpToRoot("../../d/e", root));
-    assertEquals("a/b", simplifyPathUpToRoot("../d/../e/../", root));
-    assertNull(simplifyPathUpToRoot("../../../../", root));
-    assertNull(simplifyPathUpToRoot("../../a/../../..", root));
+    assertThat(simplifyPathUpToRoot("/foo", root)).isNull();
+    assertThat(simplifyPathUpToRoot("../../", root)).isEqualTo("a");
+    assertThat(simplifyPathUpToRoot(".././../", root)).isEqualTo("a");
+    assertThat(simplifyPathUpToRoot("..//../", root)).isEqualTo("a");
+    assertThat(simplifyPathUpToRoot("../../d", root)).isEqualTo("a/d");
+    assertThat(simplifyPathUpToRoot("../../..", root)).isEqualTo("");
+    assertThat(simplifyPathUpToRoot("../../d/e", root)).isEqualTo("a/d/e");
+    assertThat(simplifyPathUpToRoot("../d/../e/../", root)).isEqualTo("a/b");
+    assertThat(simplifyPathUpToRoot("../../../../", root)).isNull();
+    assertThat(simplifyPathUpToRoot("../../a/../../..", root)).isNull();
   }
 
   @Test
   public void simplifyPathUpToNullRootDetectsNullRoot() throws Exception {
-    assertNull(simplifyPathUpToRoot("/foo", null));
-    assertNull(simplifyPathUpToRoot("../", null));
-    assertNull(simplifyPathUpToRoot("../../", null));
-    assertNull(simplifyPathUpToRoot(".././../", null));
-    assertEquals("a/b", simplifyPathUpToRoot("a/b", null));
-    assertEquals("a/c", simplifyPathUpToRoot("a/b/../c", null));
+    assertThat(simplifyPathUpToRoot("/foo", null)).isNull();
+    assertThat(simplifyPathUpToRoot("../", null)).isNull();
+    assertThat(simplifyPathUpToRoot("../../", null)).isNull();
+    assertThat(simplifyPathUpToRoot(".././../", null)).isNull();
+    assertThat(simplifyPathUpToRoot("a/b", null)).isEqualTo("a/b");
+    assertThat(simplifyPathUpToRoot("a/b/../c", null)).isEqualTo("a/c");
   }
 }
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/RefServletTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/RefServletTest.java
index 9dabbe5..7d7816c 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/RefServletTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/RefServletTest.java
@@ -14,10 +14,8 @@
 
 package com.google.gitiles;
 
+import static com.google.common.truth.Truth.assertThat;
 import static com.google.gitiles.TestGitilesUrls.URLS;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
@@ -55,13 +53,12 @@
   public void evilRefName() throws Exception {
     setUpSimpleRefs();
     String evilRefName = "refs/evil/<script>window.close();</script>/&foo";
-    assertTrue(Repository.isValidRefName(evilRefName));
+    assertThat(Repository.isValidRefName(evilRefName)).isTrue();
     repo.branch(evilRefName).commit().create();
 
     FakeHttpServletResponse res = buildText("/repo/+refs/evil");
-    assertEquals(
-        id(evilRefName) + " refs/evil/&lt;script&gt;window.close();&lt;/script&gt;/&amp;foo\n",
-        res.getActualBodyString());
+    assertThat(res.getActualBodyString()).isEqualTo(
+        id(evilRefName) + " refs/evil/&lt;script&gt;window.close();&lt;/script&gt;/&amp;foo\n");
   }
 
   @Test
@@ -69,14 +66,13 @@
     setUpSimpleRefs();
     FakeHttpServletResponse res = buildText("/repo/+refs");
 
-    assertEquals(
+    assertThat(res.getActualBodyString()).isEqualTo(
         id("HEAD") + " HEAD\n"
         + id("refs/heads/branch") + " refs/heads/branch\n"
         + id("refs/heads/master") + " refs/heads/master\n"
         + id("refs/tags/atag") + " refs/tags/atag\n"
         + peeled("refs/tags/atag") + " refs/tags/atag^{}\n"
-        + id("refs/tags/ctag") + " refs/tags/ctag\n",
-        res.getActualBodyString());
+        + id("refs/tags/ctag") + " refs/tags/ctag\n");
   }
 
   @Test
@@ -84,14 +80,13 @@
     setUpSimpleRefs();
     FakeHttpServletResponse res = buildText("/repo/+refs/");
 
-    assertEquals(
+    assertThat(res.getActualBodyString()).isEqualTo(
         id("HEAD") + " HEAD\n"
         + id("refs/heads/branch") + " refs/heads/branch\n"
         + id("refs/heads/master") + " refs/heads/master\n"
         + id("refs/tags/atag") + " refs/tags/atag\n"
         + peeled("refs/tags/atag") + " refs/tags/atag^{}\n"
-        + id("refs/tags/ctag") + " refs/tags/ctag\n",
-        res.getActualBodyString());
+        + id("refs/tags/ctag") + " refs/tags/ctag\n");
   }
 
   @Test
@@ -99,10 +94,9 @@
     setUpSimpleRefs();
     FakeHttpServletResponse res = buildText("/repo/+refs/heads");
 
-    assertEquals(
+    assertThat(res.getActualBodyString()).isEqualTo(
         id("refs/heads/branch") + " refs/heads/branch\n"
-        + id("refs/heads/master") + " refs/heads/master\n",
-        res.getActualBodyString());
+        + id("refs/heads/master") + " refs/heads/master\n");
   }
 
   @Test
@@ -110,10 +104,9 @@
     setUpSimpleRefs();
     FakeHttpServletResponse res = buildText("/repo/+refs/heads/");
 
-    assertEquals(
+    assertThat(res.getActualBodyString()).isEqualTo(
         id("refs/heads/branch") + " refs/heads/branch\n"
-        + id("refs/heads/master") + " refs/heads/master\n",
-        res.getActualBodyString());
+        + id("refs/heads/master") + " refs/heads/master\n");
   }
 
   @Test
@@ -122,7 +115,7 @@
     FakeHttpServletResponse res = buildText("/repo/+refs/HEAD");
 
     // /+refs/foo means refs/foo(/*), so this is empty.
-    assertEquals("", res.getActualBodyString());
+    assertThat(res.getActualBodyString()).isEqualTo("");
   }
 
   @Test
@@ -130,9 +123,8 @@
     setUpSimpleRefs();
     FakeHttpServletResponse res = buildText("/repo/+refs/heads/master");
 
-    assertEquals(
-        id("refs/heads/master") + " refs/heads/master\n",
-        res.getActualBodyString());
+    assertThat(res.getActualBodyString()).isEqualTo(
+        id("refs/heads/master") + " refs/heads/master\n");
   }
 
   @Test
@@ -140,10 +132,9 @@
     setUpSimpleRefs();
     FakeHttpServletResponse res = buildText("/repo/+refs/tags/atag");
 
-    assertEquals(
+    assertThat(res.getActualBodyString()).isEqualTo(
         id("refs/tags/atag") + " refs/tags/atag\n"
-        + peeled("refs/tags/atag") + " refs/tags/atag^{}\n",
-        res.getActualBodyString());
+        + peeled("refs/tags/atag") + " refs/tags/atag^{}\n");
   }
 
   @Test
@@ -151,38 +142,39 @@
     setUpSimpleRefs();
     Map<String, RefJsonData> result = buildRefJson("/repo/+refs");
     List<String> keys = ImmutableList.copyOf(result.keySet());
-    assertEquals(ImmutableList.of(
-          "HEAD",
-          "refs/heads/branch",
-          "refs/heads/master",
-          "refs/tags/atag",
-          "refs/tags/ctag"),
-        keys);
+    assertThat(keys)
+        .containsExactly(
+            "HEAD",
+            "refs/heads/branch",
+            "refs/heads/master",
+            "refs/tags/atag",
+            "refs/tags/ctag")
+        .inOrder();
 
     RefJsonData head = result.get(keys.get(0));
-    assertEquals(id("HEAD"), head.value);
-    assertNull(head.peeled);
-    assertEquals("refs/heads/master", head.target);
+    assertThat(head.value).isEqualTo(id("HEAD"));
+    assertThat(head.peeled).isNull();
+    assertThat(head.target).isEqualTo("refs/heads/master");
 
     RefJsonData branch = result.get(keys.get(1));
-    assertEquals(id("refs/heads/branch"), branch.value);
-    assertNull(branch.peeled);
-    assertNull(branch.target);
+    assertThat(branch.value).isEqualTo(id("refs/heads/branch"));
+    assertThat(branch.peeled).isNull();
+    assertThat(branch.target).isNull();
 
     RefJsonData master = result.get(keys.get(2));
-    assertEquals(id("refs/heads/master"), master.value);
-    assertNull(master.peeled);
-    assertNull(master.target);
+    assertThat(master.value).isEqualTo(id("refs/heads/master"));
+    assertThat(master.peeled).isNull();
+    assertThat(master.target).isNull();
 
     RefJsonData atag = result.get(keys.get(3));
-    assertEquals(id("refs/tags/atag"), atag.value);
-    assertEquals(peeled("refs/tags/atag"), atag.peeled);
-    assertNull(atag.target);
+    assertThat(atag.value).isEqualTo(id("refs/tags/atag"));
+    assertThat(atag.peeled).isEqualTo(peeled("refs/tags/atag"));
+    assertThat(atag.target).isNull();
 
     RefJsonData ctag = result.get(keys.get(4));
-    assertEquals(id("refs/tags/ctag"), ctag.value);
-    assertNull(ctag.peeled);
-    assertNull(ctag.target);
+    assertThat(ctag.value).isEqualTo(id("refs/tags/ctag"));
+    assertThat(ctag.peeled).isNull();
+    assertThat(ctag.target).isNull();
   }
 
   @Test
@@ -190,20 +182,21 @@
     setUpSimpleRefs();
     Map<String, RefJsonData> result = buildRefJson("/repo/+refs/heads");
     List<String> keys = ImmutableList.copyOf(result.keySet());
-    assertEquals(ImmutableList.of(
-          "branch",
-          "master"),
-        keys);
+    assertThat(keys)
+        .containsExactly(
+            "branch",
+            "master")
+        .inOrder();
 
     RefJsonData branch = result.get(keys.get(0));
-    assertEquals(id("refs/heads/branch"), branch.value);
-    assertNull(branch.peeled);
-    assertNull(branch.target);
+    assertThat(branch.value).isEqualTo(id("refs/heads/branch"));
+    assertThat(branch.peeled).isNull();
+    assertThat(branch.target).isNull();
 
     RefJsonData master = result.get(keys.get(1));
-    assertEquals(id("refs/heads/master"), master.value);
-    assertNull(master.peeled);
-    assertNull(master.target);
+    assertThat(master.value).isEqualTo(id("refs/heads/master"));
+    assertThat(master.peeled).isNull();
+    assertThat(master.target).isNull();
   }
 
   private Map<String, RefJsonData> buildRefJson(String path) throws Exception {
@@ -214,8 +207,8 @@
 
   @Test
   public void emptySoy() throws Exception {
-    assertEquals(ImmutableList.of(), buildBranchesSoyData());
-    assertEquals(ImmutableList.of(), buildTagsSoyData());
+    assertThat(buildBranchesSoyData()).isEmpty();
+    assertThat(buildTagsSoyData()).isEmpty();
   }
 
   @Test
@@ -225,15 +218,15 @@
     repo.branch("refs/tags/baz").commit().create();
     repo.branch("refs/nope/quux").commit().create();
 
-    assertEquals(
-        ImmutableList.of(
+    assertThat(buildBranchesSoyData())
+        .containsExactly(
             ref("/b/test/+/bar", "bar"),
-            ref("/b/test/+/foo", "foo")),
-        buildBranchesSoyData());
-    assertEquals(
-        ImmutableList.of(
-            ref("/b/test/+/baz", "baz")),
-        buildTagsSoyData());
+            ref("/b/test/+/foo", "foo"))
+        .inOrder();
+    assertThat(buildTagsSoyData())
+        .containsExactly(
+            ref("/b/test/+/baz", "baz"))
+        .inOrder();
   }
 
   @Test
@@ -242,17 +235,17 @@
     repo.branch("refs/heads/bar").commit().create();
     repo.branch("refs/tags/foo").commit().create();
 
-    assertEquals(
-        ImmutableList.of(
+    assertThat(buildBranchesSoyData())
+        .containsExactly(
             ref("/b/test/+/bar", "bar"),
-            ref("/b/test/+/refs/heads/foo", "foo")),
-        buildBranchesSoyData());
-    assertEquals(
-        ImmutableList.of(
+            ref("/b/test/+/refs/heads/foo", "foo"))
+        .inOrder();
+    assertThat(buildTagsSoyData())
+        .containsExactly(
             // refs/tags/ is searched before refs/heads/, so this does not
             // appear ambiguous.
-            ref("/b/test/+/foo", "foo")),
-        buildTagsSoyData());
+            ref("/b/test/+/foo", "foo"))
+        .inOrder();
   }
 
   @Test
@@ -261,14 +254,14 @@
     repo.branch("refs/heads/foo").commit().create();
     repo.branch("refs/tags/foo").commit().create();
 
-    assertEquals(
-        ImmutableList.of(
-            ref("/b/test/+/refs/heads/foo", "foo")),
-        buildBranchesSoyData());
-    assertEquals(
-        ImmutableList.of(
-            ref("/b/test/+/refs/tags/foo", "foo")),
-        buildTagsSoyData());
+    assertThat(buildBranchesSoyData())
+        .containsExactly(
+            ref("/b/test/+/refs/heads/foo", "foo"))
+        .inOrder();
+    assertThat(buildTagsSoyData())
+        .containsExactly(
+            ref("/b/test/+/refs/tags/foo", "foo"))
+        .inOrder();
   }
 
   @Test
@@ -276,11 +269,11 @@
     repo.branch("refs/heads/foo").commit().create();
     repo.branch("refs/heads/refs/heads/foo").commit().create();
 
-    assertEquals(
-        ImmutableList.of(
+    assertThat(buildBranchesSoyData())
+        .containsExactly(
             ref("/b/test/+/foo", "foo"),
-            ref("/b/test/+/refs/heads/refs/heads/foo", "refs/heads/foo")),
-        buildBranchesSoyData());
+            ref("/b/test/+/refs/heads/refs/heads/foo", "refs/heads/foo"))
+        .inOrder();
   }
 
   private HttpServletRequest buildSoyRequest() {
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/RevisionParserTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/RevisionParserTest.java
index 9271133..c5f2871 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/RevisionParserTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/RevisionParserTest.java
@@ -14,11 +14,10 @@
 
 package com.google.gitiles;
 
+import static com.google.common.truth.Truth.assertThat;
 import static org.eclipse.jgit.lib.Constants.OBJ_BLOB;
 import static org.eclipse.jgit.lib.Constants.OBJ_COMMIT;
 import static org.eclipse.jgit.lib.Constants.OBJ_TAG;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
 
 import com.google.common.cache.CacheBuilder;
 import com.google.gitiles.RevisionParser.Result;
@@ -54,12 +53,12 @@
   @Test
   public void parseRef() throws Exception {
     RevCommit master = repo.branch("refs/heads/master").commit().create();
-    assertEquals(new Result(Revision.peeled("master", master)),
-        parser.parse("master"));
-    assertEquals(new Result(Revision.peeled("refs/heads/master", master)),
-        parser.parse("refs/heads/master"));
-    assertNull(parser.parse("refs//heads//master"));
-    assertNull(parser.parse("refs heads master"));
+    assertThat(parser.parse("master"))
+        .isEqualTo(new Result(Revision.peeled("master", master)));
+    assertThat(parser.parse("refs/heads/master"))
+        .isEqualTo(new Result(Revision.peeled("refs/heads/master", master)));
+    assertThat(parser.parse("refs//heads//master")).isNull();
+    assertThat(parser.parse("refs heads master")).isNull();
   }
 
   @Test
@@ -71,23 +70,27 @@
         .parent(parent1)
         .parent(parent2)
         .create();
-    assertEquals(new Result(Revision.peeled("master", merge)), parser.parse("master"));
-    assertEquals(new Result(Revision.peeled("master^", parent1)), parser.parse("master^"));
-    assertEquals(new Result(Revision.peeled("master~1", parent1)), parser.parse("master~1"));
-    assertEquals(new Result(Revision.peeled("master^2", parent2)), parser.parse("master^2"));
-    assertNull(parser.parse("master^3"));
-    assertEquals(new Result(Revision.peeled("master~2", root)), parser.parse("master~2"));
+    assertThat(parser.parse("master")).isEqualTo(new Result(Revision.peeled("master", merge)));
+    assertThat(parser.parse("master^")).isEqualTo(new Result(Revision.peeled("master^", parent1)));
+    assertThat(parser.parse("master~1"))
+        .isEqualTo(new Result(Revision.peeled("master~1", parent1)));
+    assertThat(parser.parse("master^2"))
+        .isEqualTo(new Result(Revision.peeled("master^2", parent2)));
+    assertThat(parser.parse("master^3")).isNull();
+    assertThat(parser.parse("master~2")).isEqualTo(new Result(Revision.peeled("master~2", root)));
   }
 
   @Test
   public void parseCommitShaVisibleFromHead() throws Exception {
     RevCommit parent = repo.commit().create();
     RevCommit commit = repo.branch("master").commit().parent(parent).create();
-    assertEquals(new Result(Revision.peeled(commit.name(), commit)), parser.parse(commit.name()));
-    assertEquals(new Result(Revision.peeled(parent.name(), parent)), parser.parse(parent.name()));
+    assertThat(parser.parse(commit.name()))
+        .isEqualTo(new Result(Revision.peeled(commit.name(), commit)));
+    assertThat(parser.parse(parent.name()))
+        .isEqualTo(new Result(Revision.peeled(parent.name(), parent)));
 
     String abbrev = commit.name().substring(0, 6);
-    assertEquals(new Result(Revision.peeled(abbrev, commit)), parser.parse(abbrev));
+    assertThat(parser.parse(abbrev)).isEqualTo(new Result(Revision.peeled(abbrev, commit)));
   }
 
   @Test
@@ -97,8 +100,10 @@
     repo.branch("master").commit().create();
     repo.update("refs/tags/tag", repo.tag("tag", commit));
 
-    assertEquals(new Result(Revision.peeled(commit.name(), commit)), parser.parse(commit.name()));
-    assertEquals(new Result(Revision.peeled(parent.name(), parent)), parser.parse(parent.name()));
+    assertThat(parser.parse(commit.name()))
+        .isEqualTo(new Result(Revision.peeled(commit.name(), commit)));
+    assertThat(parser.parse(parent.name()))
+        .isEqualTo(new Result(Revision.peeled(parent.name(), parent)));
   }
 
   @Test
@@ -109,8 +114,10 @@
     repo.update("refs/tags/tag", repo.tag("tag", repo.commit().create()));
     repo.update("refs/meta/config", commit);
 
-    assertEquals(new Result(Revision.peeled(commit.name(), commit)), parser.parse(commit.name()));
-    assertEquals(new Result(Revision.peeled(parent.name(), parent)), parser.parse(parent.name()));
+    assertThat(parser.parse(commit.name()))
+        .isEqualTo(new Result(Revision.peeled(commit.name(), commit)));
+    assertThat(parser.parse(parent.name()))
+        .isEqualTo(new Result(Revision.peeled(parent.name(), parent)));
   }
 
   @Test
@@ -121,19 +128,21 @@
     repo.update("refs/changes/01/0001", commit);
 
     // Matches exactly.
-    assertEquals(new Result(Revision.peeled(commit.name(), commit)), parser.parse(commit.name()));
+    assertThat(parser.parse(commit.name()))
+        .isEqualTo(new Result(Revision.peeled(commit.name(), commit)));
     // refs/changes/* is excluded from ancestry search.
-    assertNull(parser.parse(parent.name()));
+    assertThat(parser.parse(parent.name())).isNull();
   }
 
   @Test
   public void parseNonVisibleCommitSha() throws Exception {
     RevCommit other = repo.commit().create();
     repo.branch("master").commit().create();
-    assertNull(parser.parse(other.name()));
+    assertThat(parser.parse(other.name())).isNull();
 
     repo.branch("other").update(other);
-    assertEquals(new Result(Revision.peeled(other.name(), other)), parser.parse(other.name()));
+    assertThat(parser.parse(other.name()))
+        .isEqualTo(new Result(Revision.peeled(other.name(), other)));
   }
 
   @Test
@@ -142,51 +151,44 @@
     RevCommit commit = repo.branch("master").commit().parent(parent).create();
     RevCommit other = repo.branch("other").commit().create();
 
-    assertEquals(
+    assertThat(parser.parse("master^..master")).isEqualTo(
         new Result(
             Revision.peeled("master", commit),
             Revision.peeled("master^", parent),
-            ""),
-        parser.parse("master^..master"));
-    assertEquals(
+            ""));
+    assertThat(parser.parse("master^..master/")).isEqualTo(
         new Result(
             Revision.peeled("master", commit),
             Revision.peeled("master^", parent),
-            "/"),
-        parser.parse("master^..master/"));
-    assertEquals(
+            "/"));
+    assertThat(parser.parse("master^..master/path/to/a/file")).isEqualTo(
         new Result(
             Revision.peeled("master", commit),
             Revision.peeled("master^", parent),
-            "/path/to/a/file"),
-        parser.parse("master^..master/path/to/a/file"));
-    assertEquals(
+            "/path/to/a/file"));
+    assertThat(parser.parse("master^..master/path/to/a/..file")).isEqualTo(
         new Result(
             Revision.peeled("master", commit),
             Revision.peeled("master^", parent),
-            "/path/to/a/..file"),
-        parser.parse("master^..master/path/to/a/..file"));
-    assertEquals(
+            "/path/to/a/..file"));
+    assertThat(parser.parse("refs/heads/master^..refs/heads/master")).isEqualTo(
         new Result(
             Revision.peeled("refs/heads/master", commit),
             Revision.peeled("refs/heads/master^", parent),
-            ""),
-      parser.parse("refs/heads/master^..refs/heads/master"));
-    assertEquals(
+            ""));
+    assertThat(parser.parse("master~1..master")).isEqualTo(
         new Result(
             Revision.peeled("master", commit),
             Revision.peeled("master~1", parent),
-            ""),
-        parser.parse("master~1..master"));
+            ""));
     // TODO(dborowitz): 2a2362fbb in JGit causes master~2 to resolve to master
     // rather than null. Uncomment when upstream regression is fixed.
-    //assertNull(parser.parse("master~2..master"));
-    assertEquals(
+    //assertThat(parser.parse("master~2..master")).isNull();
+    assertThat(parser.parse("other..master")).isEqualTo(
         new Result(
             Revision.peeled("master", commit),
             Revision.peeled("other", other),
-            ""),
-        parser.parse("other..master"));
+            ""));
   }
 
   @Test
@@ -194,60 +196,53 @@
     RevCommit parent = repo.commit().create();
     RevCommit commit = repo.branch("master").commit().parent(parent).create();
 
-    assertEquals(
+    assertThat(parser.parse("master^!")).isEqualTo(
         new Result(
             Revision.peeled("master", commit),
             Revision.peeled("master^", parent),
-            ""),
-        parser.parse("master^!"));
-    assertEquals(
+            ""));
+    assertThat(parser.parse("master^^!")).isEqualTo(
         new Result(
             Revision.peeled("master^", parent),
             Revision.NULL,
-            ""),
-        parser.parse("master^^!"));
-    assertEquals(
+            ""));
+    assertThat(parser.parse(parent.name() + "^!")).isEqualTo(
         new Result(
             Revision.peeled(parent.name(), parent),
             Revision.NULL,
-            ""),
-        parser.parse(parent.name() + "^!"));
+            ""));
 
     repo.update("refs/tags/tag", repo.tag("tag", commit));
-    assertEquals(
+    assertThat(parser.parse("tag^!")).isEqualTo(
         new Result(
             Revision.peeled("tag", commit),
             Revision.peeled("tag^", parent),
-            ""),
-        parser.parse("tag^!"));
-    assertEquals(
+            ""));
+    assertThat(parser.parse("tag^^!")).isEqualTo(
         new Result(
             Revision.peeled("tag^", parent),
             Revision.NULL,
-            ""),
-        parser.parse("tag^^!"));
+            ""));
   }
 
   @Test
   public void nonVisibleDiffShas() throws Exception {
     RevCommit other = repo.commit().create();
     RevCommit master = repo.branch("master").commit().create();
-    assertNull(parser.parse("other..master"));
-    assertNull(parser.parse("master..other"));
+    assertThat(parser.parse("other..master")).isNull();
+    assertThat(parser.parse("master..other")).isNull();
 
     repo.branch("other").update(other);
-    assertEquals(
+    assertThat(parser.parse("other..master")).isEqualTo(
         new Result(
             Revision.peeled("master", master),
             Revision.peeled("other", other),
-            ""),
-        parser.parse("other..master"));
-    assertEquals(
+            ""));
+    assertThat(parser.parse("master..other")).isEqualTo(
         new Result(
             Revision.peeled("other", other),
             Revision.peeled("master", master),
-            ""),
-        parser.parse("master..other"));
+            ""));
   }
 
   @Test
@@ -257,18 +252,16 @@
     RevTag masterTagTag = repo.update("refs/tags/master-tag-tag",
         repo.tag("master-tag-tag", master));
 
-    assertEquals(new Result(
-            new Revision("master-tag", masterTag, OBJ_TAG, master, OBJ_COMMIT)),
-        parser.parse("master-tag"));
-    assertEquals(new Result(
-            new Revision("master-tag-tag", masterTagTag, OBJ_TAG, master, OBJ_COMMIT)),
-        parser.parse("master-tag-tag"));
+    assertThat(parser.parse("master-tag")).isEqualTo(
+        new Result(new Revision("master-tag", masterTag, OBJ_TAG, master, OBJ_COMMIT)));
+    assertThat(parser.parse("master-tag-tag")).isEqualTo(
+        new Result(new Revision("master-tag-tag", masterTagTag, OBJ_TAG, master, OBJ_COMMIT)));
 
     RevBlob blob = repo.update("refs/tags/blob", repo.blob("blob"));
     RevTag blobTag = repo.update("refs/tags/blob-tag", repo.tag("blob-tag", blob));
-    assertEquals(new Result(Revision.peeled("blob", blob)), parser.parse("blob"));
-    assertEquals(new Result(new Revision("blob-tag", blobTag, OBJ_TAG, blob, OBJ_BLOB)),
-        parser.parse("blob-tag"));
+    assertThat(parser.parse("blob")).isEqualTo(new Result(Revision.peeled("blob", blob)));
+    assertThat(parser.parse("blob-tag"))
+        .isEqualTo(new Result(new Revision("blob-tag", blobTag, OBJ_TAG, blob, OBJ_BLOB)));
   }
 
   @Test
@@ -276,23 +269,23 @@
     RevBlob blob = repo.blob("blob contents");
     RevCommit master = repo.branch("master").commit().add("blob", blob).create();
 
-    assertEquals(master, repo.getRepository().resolve("master^{}"));
-    assertNull(parser.parse("master^{}"));
+    assertThat(repo.getRepository().resolve("master^{}")).isEqualTo(master);
+    assertThat(parser.parse("master^{}")).isNull();
 
-    assertEquals(master, repo.getRepository().resolve("master^{commit}"));
-    assertNull(parser.parse("master^{commit}"));
+    assertThat(repo.getRepository().resolve("master^{commit}")).isEqualTo(master);
+    assertThat(parser.parse("master^{commit}")).isNull();
 
-    assertEquals(blob, repo.getRepository().resolve("master:blob"));
-    assertNull(parser.parse("master:blob"));
+    assertThat(repo.getRepository().resolve("master:blob")).isEqualTo(blob);
+    assertThat(parser.parse("master:blob")).isNull();
 
     // TestRepository has no simple way of setting the reflog.
-    //assertEquals(null, repo.getRepository().resolve("master@{0}"));
-    assertNull(parser.parse("master@{0}"));
+    //assertThat(repo.getRepository().resolve("master@{0}")).isEqualTo(null);
+    assertThat(parser.parse("master@{0}")).isNull();
   }
 
   @Test
   public void parseMissingSha() throws Exception {
-    assertNull(parser.parse("deadbeef"));
-    assertNull(parser.parse("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"));
+    assertThat(parser.parse("deadbeef")).isNull();
+    assertThat(parser.parse("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef")).isNull();
   }
 }
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/ServletTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/ServletTest.java
index 993f1d2..14aeb63 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/ServletTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/ServletTest.java
@@ -14,10 +14,10 @@
 
 package com.google.gitiles;
 
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
 import static javax.servlet.http.HttpServletResponse.SC_NOT_FOUND;
 import static javax.servlet.http.HttpServletResponse.SC_OK;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
 
 import com.google.common.net.HttpHeaders;
 import com.google.gson.Gson;
@@ -53,7 +53,7 @@
     }
     FakeHttpServletResponse res = new FakeHttpServletResponse();
     servlet.service(req, res);
-    assertEquals(expectedStatus, res.getStatus());
+    assertThat(res.getStatus()).isEqualTo(expectedStatus);
     return res;
   }
 
@@ -63,9 +63,9 @@
 
   protected String buildHtml(String path, boolean assertHasETag) throws Exception {
     FakeHttpServletResponse res = build(path);
-    assertEquals("text/html", res.getHeader(HttpHeaders.CONTENT_TYPE));
+    assertThat(res.getHeader(HttpHeaders.CONTENT_TYPE)).isEqualTo("text/html");
     if (assertHasETag) {
-      assertNotNull("has ETag", res.getHeader(HttpHeaders.ETAG));
+      assertWithMessage("missing ETag").that(res.getHeader(HttpHeaders.ETAG)).isNotNull();
     }
     return res.getActualBodyString();
   }
@@ -86,16 +86,16 @@
 
   protected FakeHttpServletResponse buildText(String path) throws Exception {
     FakeHttpServletResponse res = buildResponse(path, "format=text", SC_OK);
-    assertEquals("text/plain", res.getHeader(HttpHeaders.CONTENT_TYPE));
+    assertThat(res.getHeader(HttpHeaders.CONTENT_TYPE)).isEqualTo("text/plain");
     return res;
   }
 
   private String buildJsonRaw(String path) throws Exception {
     FakeHttpServletResponse res = buildResponse(path, "format=json", SC_OK);
-    assertEquals("application/json", res.getHeader(HttpHeaders.CONTENT_TYPE));
+    assertThat(res.getHeader(HttpHeaders.CONTENT_TYPE)).isEqualTo("application/json");
     String body = res.getActualBodyString();
     String magic = ")]}'\n";
-    assertEquals(magic, body.substring(0, magic.length()));
+    assertThat(body).startsWith(magic);
     return body.substring(magic.length());
   }
 
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/TestViewFilter.java b/gitiles-servlet/src/test/java/com/google/gitiles/TestViewFilter.java
index e6a4768..bb3d732 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/TestViewFilter.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/TestViewFilter.java
@@ -15,10 +15,10 @@
 package com.google.gitiles;
 
 import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.truth.Truth.assertThat;
 import static com.google.gitiles.GitilesFilter.REPO_PATH_REGEX;
 import static com.google.gitiles.GitilesFilter.REPO_REGEX;
 import static com.google.gitiles.GitilesFilter.ROOT_REGEX;
-import static org.junit.Assert.assertEquals;
 
 import com.google.common.collect.ImmutableList;
 
@@ -82,8 +82,8 @@
     if (servlet.view != null) {
       ViewFilter.setView(req, servlet.view);
       if (servlet.view.getRepositoryName() != null) {
-        assertEquals(repo.getRepository().getDescription().getRepositoryName(),
-            servlet.view.getRepositoryName());
+        assertThat(servlet.view.getRepositoryName())
+            .isEqualTo(repo.getRepository().getDescription().getRepositoryName());
       }
     }
     return new Result(servlet.view, req, res);
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/TimeCacheTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/TimeCacheTest.java
index 8317363..bc4e553 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/TimeCacheTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/TimeCacheTest.java
@@ -14,7 +14,7 @@
 
 package com.google.gitiles;
 
-import static org.junit.Assert.assertEquals;
+import static com.google.common.truth.Truth.assertThat;
 
 import org.eclipse.jgit.internal.storage.dfs.DfsRepository;
 import org.eclipse.jgit.internal.storage.dfs.DfsRepositoryDescription;
@@ -66,8 +66,8 @@
   public void commitTime() throws Exception {
     RevCommit root = repo.commit().create();
     RevCommit master = repo.commit().parent(root).create();
-    assertEquals(start + 1, getTime(root));
-    assertEquals(start + 2, getTime(master));
+    assertThat(getTime(root)).isEqualTo(start + 1);
+    assertThat(getTime(master)).isEqualTo(start + 2);
   }
 
   @Test
@@ -75,8 +75,8 @@
     RevCommit commit = repo.commit().create();
     repo.tick(1);
     RevTag tag = repo.tag("tag", commit);
-    assertEquals(start + 1, getTime(commit));
-    assertEquals(start + 2, getTime(tag));
+    assertThat(getTime(commit)).isEqualTo(start + 1);
+    assertThat(getTime(tag)).isEqualTo(start + 2);
   }
 
   @Test
@@ -87,8 +87,8 @@
     RevTag blobTag = repo.tag("blob", blob);
     repo.tick(1);
     RevTag treeTag = repo.tag("tree", tree);
-    assertEquals(start + 1, getTime(blobTag));
-    assertEquals(start + 2, getTime(treeTag));
+    assertThat(getTime(blobTag)).isEqualTo(start + 1);
+    assertThat(getTime(treeTag)).isEqualTo(start + 2);
   }
 
   @Test
@@ -97,16 +97,16 @@
     RevTag tag = repo.tag("tag", repo.commit().create());
     repo.tick(-1);
     RevTag tagTag = repo.tag("tagtag", tag);
-    assertEquals(start + 3, getTime(tag));
-    assertEquals(start + 2, getTime(tagTag));
+    assertThat(getTime(tag)).isEqualTo(start + 3);
+    assertThat(getTime(tagTag)).isEqualTo(start + 2);
   }
 
   @Test
   public void treeAndBlobTime() throws Exception {
     RevBlob blob = repo.blob("contents");
     RevTree tree = repo.tree(repo.file("foo", blob));
-    assertEquals(Long.MIN_VALUE, getTime(blob));
-    assertEquals(Long.MIN_VALUE, getTime(tree));
+    assertThat(getTime(blob)).isEqualTo(Long.MIN_VALUE);
+    assertThat(getTime(tree)).isEqualTo(Long.MIN_VALUE);
   }
 
   @Test
@@ -121,8 +121,8 @@
       id = ins.insert(builder);
       ins.flush();
     }
-    assertEquals(start + 1, getTime(commit));
-    assertEquals(start + 1, getTime(id));
+    assertThat(getTime(commit)).isEqualTo(start + 1);
+    assertThat(getTime(id)).isEqualTo(start + 1);
   }
 
   @Test
@@ -141,8 +141,8 @@
       tagTagId = ins.insert(builder);
       ins.flush();
     }
-    assertEquals(start + 1, getTime(commit));
-    assertEquals(start + 2, getTime(tag));
-    assertEquals(start + 2, getTime(tagTagId));
+    assertThat(getTime(commit)).isEqualTo(start + 1);
+    assertThat(getTime(tag)).isEqualTo(start + 2);
+    assertThat(getTime(tagTagId)).isEqualTo(start + 2);
   }
 }
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/TreeSoyDataTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/TreeSoyDataTest.java
index 85e327b..bbf5d37 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/TreeSoyDataTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/TreeSoyDataTest.java
@@ -14,10 +14,9 @@
 
 package com.google.gitiles;
 
+import static com.google.common.truth.Truth.assertThat;
 import static com.google.gitiles.TreeSoyData.getTargetDisplayName;
 import static com.google.gitiles.TreeSoyData.resolveTargetUrl;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
 
 import com.google.common.base.Strings;
 
@@ -31,16 +30,16 @@
 public class TreeSoyDataTest {
   @Test
   public void getTargetDisplayNameReturnsDisplayName() throws Exception {
-    assertEquals("foo", getTargetDisplayName("foo"));
-    assertEquals("foo/bar", getTargetDisplayName("foo/bar"));
-    assertEquals("a/a/a/a/a/a/a/a/a/a/bar",
-        getTargetDisplayName(Strings.repeat("a/", 10) + "bar"));
-    assertEquals("a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/bar",
-        getTargetDisplayName(Strings.repeat("a/", 34) + "bar"));
-    assertEquals(".../bar", getTargetDisplayName(Strings.repeat("a/", 35) + "bar"));
-    assertEquals(".../bar", getTargetDisplayName(Strings.repeat("a/", 100) + "bar"));
-    assertEquals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-        getTargetDisplayName(Strings.repeat("a", 80)));
+    assertThat(getTargetDisplayName("foo")).isEqualTo("foo");
+    assertThat(getTargetDisplayName("foo/bar")).isEqualTo("foo/bar");
+    assertThat(getTargetDisplayName(Strings.repeat("a/", 10) + "bar")).isEqualTo(
+        "a/a/a/a/a/a/a/a/a/a/bar");
+    assertThat(getTargetDisplayName(Strings.repeat("a/", 34) + "bar")).isEqualTo(
+        "a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/a/bar");
+    assertThat(getTargetDisplayName(Strings.repeat("a/", 35) + "bar")).isEqualTo(".../bar");
+    assertThat(getTargetDisplayName(Strings.repeat("a/", 100) + "bar")).isEqualTo(".../bar");
+    assertThat(getTargetDisplayName(Strings.repeat("a", 80))).isEqualTo(
+        "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
   }
 
   @Test
@@ -53,15 +52,15 @@
         .setRevision(Revision.unpeeled("m", id))
         .setPathPart("a/b/c")
         .build();
-    assertNull(resolveTargetUrl(view, "/foo"));
-    assertEquals("/x/repo/+/m/a", resolveTargetUrl(view, "../../"));
-    assertEquals("/x/repo/+/m/a", resolveTargetUrl(view, ".././../"));
-    assertEquals("/x/repo/+/m/a", resolveTargetUrl(view, "..//../"));
-    assertEquals("/x/repo/+/m/a/d", resolveTargetUrl(view, "../../d"));
-    assertEquals("/x/repo/+/m/", resolveTargetUrl(view, "../../.."));
-    assertEquals("/x/repo/+/m/a/d/e", resolveTargetUrl(view, "../../d/e"));
-    assertEquals("/x/repo/+/m/a/b", resolveTargetUrl(view, "../d/../e/../"));
-    assertNull(resolveTargetUrl(view, "../../../../"));
-    assertNull(resolveTargetUrl(view, "../../a/../../.."));
+    assertThat(resolveTargetUrl(view, "/foo")).isNull();
+    assertThat(resolveTargetUrl(view, "../../")).isEqualTo("/x/repo/+/m/a");
+    assertThat(resolveTargetUrl(view, ".././../")).isEqualTo("/x/repo/+/m/a");
+    assertThat(resolveTargetUrl(view, "..//../")).isEqualTo("/x/repo/+/m/a");
+    assertThat(resolveTargetUrl(view, "../../d")).isEqualTo("/x/repo/+/m/a/d");
+    assertThat(resolveTargetUrl(view, "../../..")).isEqualTo("/x/repo/+/m/");
+    assertThat(resolveTargetUrl(view, "../../d/e")).isEqualTo("/x/repo/+/m/a/d/e");
+    assertThat(resolveTargetUrl(view, "../d/../e/../")).isEqualTo("/x/repo/+/m/a/b");
+    assertThat(resolveTargetUrl(view, "../../../../")).isNull();
+    assertThat(resolveTargetUrl(view, "../../a/../../..")).isNull();
   }
 }
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/ViewFilterTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/ViewFilterTest.java
index a3ae81a..87350f8 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/ViewFilterTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/ViewFilterTest.java
@@ -14,9 +14,8 @@
 
 package com.google.gitiles;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
 
 import com.google.common.net.HttpHeaders;
 import com.google.gitiles.GitilesView.Type;
@@ -48,10 +47,10 @@
 
   @Test
   public void noCommand() throws Exception {
-    assertEquals(Type.HOST_INDEX, getView("/").getType());
-    assertEquals(Type.REPOSITORY_INDEX, getView("/repo").getType());
-    assertNull(getView("/repo/+"));
-    assertNull(getView("/repo/+/"));
+    assertThat(getView("/").getType()).isEqualTo(Type.HOST_INDEX);
+    assertThat(getView("/repo").getType()).isEqualTo(Type.REPOSITORY_INDEX);
+    assertThat(getView("/repo/+")).isNull();
+    assertThat(getView("/repo/+/")).isNull();
   }
 
   @Test
@@ -62,38 +61,38 @@
     String hexBranch = hex.substring(0, 10);
     repo.branch(hexBranch).commit().create();
 
-    assertEquals(Type.REVISION, getView("/repo/+/master").getType());
-    assertEquals(Type.REVISION, getView("/repo/+/" + hexBranch).getType());
-    assertEquals(Type.REVISION, getView("/repo/+/" + hex).getType());
-    assertEquals(Type.REVISION, getView("/repo/+/" + hex.substring(0, 7)).getType());
-    assertEquals(Type.PATH, getView("/repo/+/master/").getType());
-    assertEquals(Type.PATH, getView("/repo/+/" + hex + "/").getType());
-    assertEquals(Type.PATH, getView("/repo/+/" + hex + "/index.c").getType());
-    assertEquals(Type.DOC, getView("/repo/+/" + hex + "/index.md").getType());
-    assertEquals(Type.DIFF, getView("/repo/+/master^..master").getType());
-    assertEquals(Type.DIFF, getView("/repo/+/master^..master/").getType());
-    assertEquals(Type.DIFF, getView("/repo/+/" + parent.name() + ".." + hex + "/").getType());
+    assertThat(getView("/repo/+/master").getType()).isEqualTo(Type.REVISION);
+    assertThat(getView("/repo/+/" + hexBranch).getType()).isEqualTo(Type.REVISION);
+    assertThat(getView("/repo/+/" + hex).getType()).isEqualTo(Type.REVISION);
+    assertThat(getView("/repo/+/" + hex.substring(0, 7)).getType()).isEqualTo(Type.REVISION);
+    assertThat(getView("/repo/+/master/").getType()).isEqualTo(Type.PATH);
+    assertThat(getView("/repo/+/" + hex + "/").getType()).isEqualTo(Type.PATH);
+    assertThat(getView("/repo/+/" + hex + "/index.c").getType()).isEqualTo(Type.PATH);
+    assertThat(getView("/repo/+/" + hex + "/index.md").getType()).isEqualTo(Type.DOC);
+    assertThat(getView("/repo/+/master^..master").getType()).isEqualTo(Type.DIFF);
+    assertThat(getView("/repo/+/master^..master/").getType()).isEqualTo(Type.DIFF);
+    assertThat(getView("/repo/+/" + parent.name() + ".." + hex + "/").getType()).isEqualTo(Type.DIFF);
   }
 
   @Test
   public void hostIndex() throws Exception {
     GitilesView view = getView("/");
-    assertEquals(Type.HOST_INDEX, view.getType());
-    assertEquals("test-host", view.getHostName());
-    assertNull(view.getRepositoryName());
-    assertEquals(Revision.NULL, view.getRevision());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertNull(view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.HOST_INDEX);
+    assertThat(view.getHostName()).isEqualTo("test-host");
+    assertThat(view.getRepositoryName()).isNull();
+    assertThat(view.getRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isNull();
   }
 
   @Test
   public void repositoryIndex() throws Exception {
     GitilesView view = getView("/repo");
-    assertEquals(Type.REPOSITORY_INDEX, view.getType());
-    assertEquals("repo", view.getRepositoryName());
-    assertEquals(Revision.NULL, view.getRevision());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertNull(view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.REPOSITORY_INDEX);
+    assertThat(view.getRepositoryName()).isEqualTo("repo");
+    assertThat(view.getRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isNull();
   }
 
   @Test
@@ -101,61 +100,61 @@
     GitilesView view;
 
     view = getView("/repo/+refs");
-    assertEquals(Type.REFS, view.getType());
-    assertEquals("repo", view.getRepositoryName());
-    assertEquals(Revision.NULL, view.getRevision());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals("", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.REFS);
+    assertThat(view.getRepositoryName()).isEqualTo("repo");
+    assertThat(view.getRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isEqualTo("");
 
     view = getView("/repo/+refs/");
-    assertEquals(Type.REFS, view.getType());
-    assertEquals("repo", view.getRepositoryName());
-    assertEquals(Revision.NULL, view.getRevision());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals("", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.REFS);
+    assertThat(view.getRepositoryName()).isEqualTo("repo");
+    assertThat(view.getRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isEqualTo("");
 
     view = getView("/repo/+refs/heads");
-    assertEquals(Type.REFS, view.getType());
-    assertEquals("repo", view.getRepositoryName());
-    assertEquals(Revision.NULL, view.getRevision());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals("heads", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.REFS);
+    assertThat(view.getRepositoryName()).isEqualTo("repo");
+    assertThat(view.getRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isEqualTo("heads");
 
     view = getView("/repo/+refs/heads/");
-    assertEquals(Type.REFS, view.getType());
-    assertEquals("repo", view.getRepositoryName());
-    assertEquals(Revision.NULL, view.getRevision());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals("heads", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.REFS);
+    assertThat(view.getRepositoryName()).isEqualTo("repo");
+    assertThat(view.getRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isEqualTo("heads");
 
     view = getView("/repo/+refs/heads/master");
-    assertEquals(Type.REFS, view.getType());
-    assertEquals("repo", view.getRepositoryName());
-    assertEquals(Revision.NULL, view.getRevision());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals("heads/master", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.REFS);
+    assertThat(view.getRepositoryName()).isEqualTo("repo");
+    assertThat(view.getRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isEqualTo("heads/master");
   }
 
   @Test
   public void describe() throws Exception {
     GitilesView view;
 
-    assertNull(getView("/repo/+describe"));
-    assertNull(getView("/repo/+describe/"));
+    assertThat(getView("/repo/+describe")).isNull();
+    assertThat(getView("/repo/+describe/")).isNull();
 
     view = getView("/repo/+describe/deadbeef");
-    assertEquals(Type.DESCRIBE, view.getType());
-    assertEquals("repo", view.getRepositoryName());
-    assertEquals(Revision.NULL, view.getRevision());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals("deadbeef", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.DESCRIBE);
+    assertThat(view.getRepositoryName()).isEqualTo("repo");
+    assertThat(view.getRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isEqualTo("deadbeef");
 
     view = getView("/repo/+describe/refs/heads/master~3^~2");
-    assertEquals(Type.DESCRIBE, view.getType());
-    assertEquals("repo", view.getRepositoryName());
-    assertEquals(Revision.NULL, view.getRevision());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals("refs/heads/master~3^~2", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.DESCRIBE);
+    assertThat(view.getRepositoryName()).isEqualTo("repo");
+    assertThat(view.getRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isEqualTo("refs/heads/master~3^~2");
   }
 
   @Test
@@ -165,30 +164,30 @@
     GitilesView view;
 
     view = getView("/repo/+show/master");
-    assertEquals(Type.REVISION, view.getType());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertNull(view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.REVISION);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getPathPart()).isNull();
 
     view = getView("/repo/+show/heads/master");
-    assertEquals(Type.REVISION, view.getType());
-    assertEquals("heads/master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertNull(view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.REVISION);
+    assertThat(view.getRevision().getName()).isEqualTo("heads/master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getPathPart()).isNull();
 
     view = getView("/repo/+show/refs/heads/master");
-    assertEquals(Type.REVISION, view.getType());
-    assertEquals("refs/heads/master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertNull(view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.REVISION);
+    assertThat(view.getRevision().getName()).isEqualTo("refs/heads/master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getPathPart()).isNull();
 
     view = getView("/repo/+show/stable");
-    assertEquals(Type.REVISION, view.getType());
-    assertEquals("stable", view.getRevision().getName());
-    assertEquals(stable, view.getRevision().getId());
-    assertNull(view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.REVISION);
+    assertThat(view.getRevision().getName()).isEqualTo("stable");
+    assertThat(view.getRevision().getId()).isEqualTo(stable);
+    assertThat(view.getPathPart()).isNull();
 
-    assertNull(getView("/repo/+show/stable..master"));
+    assertThat(getView("/repo/+show/stable..master")).isNull();
   }
 
   @Test
@@ -198,34 +197,34 @@
     GitilesView view;
 
     view = getView("/repo/+show/name");
-    assertEquals(Type.REVISION, view.getType());
-    assertEquals("name", view.getRevision().getName());
-    assertEquals(tag, view.getRevision().getId());
-    assertNull(view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.REVISION);
+    assertThat(view.getRevision().getName()).isEqualTo("name");
+    assertThat(view.getRevision().getId()).isEqualTo(tag);
+    assertThat(view.getPathPart()).isNull();
 
     view = getView("/repo/+show/heads/name");
-    assertEquals(Type.REVISION, view.getType());
-    assertEquals("heads/name", view.getRevision().getName());
-    assertEquals(branch, view.getRevision().getId());
-    assertNull(view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.REVISION);
+    assertThat(view.getRevision().getName()).isEqualTo("heads/name");
+    assertThat(view.getRevision().getId()).isEqualTo(branch);
+    assertThat(view.getPathPart()).isNull();
 
     view = getView("/repo/+show/refs/heads/name");
-    assertEquals(Type.REVISION, view.getType());
-    assertEquals("refs/heads/name", view.getRevision().getName());
-    assertEquals(branch, view.getRevision().getId());
-    assertNull(view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.REVISION);
+    assertThat(view.getRevision().getName()).isEqualTo("refs/heads/name");
+    assertThat(view.getRevision().getId()).isEqualTo(branch);
+    assertThat(view.getPathPart()).isNull();
 
     view = getView("/repo/+show/tags/name");
-    assertEquals(Type.REVISION, view.getType());
-    assertEquals("tags/name", view.getRevision().getName());
-    assertEquals(tag, view.getRevision().getId());
-    assertNull(view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.REVISION);
+    assertThat(view.getRevision().getName()).isEqualTo("tags/name");
+    assertThat(view.getRevision().getId()).isEqualTo(tag);
+    assertThat(view.getPathPart()).isNull();
 
     view = getView("/repo/+show/refs/tags/name");
-    assertEquals(Type.REVISION, view.getType());
-    assertEquals("refs/tags/name", view.getRevision().getName());
-    assertEquals(tag, view.getRevision().getId());
-    assertNull(view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.REVISION);
+    assertThat(view.getRevision().getName()).isEqualTo("refs/tags/name");
+    assertThat(view.getRevision().getId()).isEqualTo(tag);
+    assertThat(view.getPathPart()).isNull();
   }
 
   @Test
@@ -235,26 +234,26 @@
     GitilesView view;
 
     view = getView("/repo/+show/master/");
-    assertEquals(Type.PATH, view.getType());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals("", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.PATH);
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getPathPart()).isEqualTo("");
 
     view = getView("/repo/+show/master/foo");
-    assertEquals(Type.PATH, view.getType());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals("foo", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.PATH);
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getPathPart()).isEqualTo("foo");
 
     view = getView("/repo/+show/master/foo/");
-    assertEquals(Type.PATH, view.getType());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals("foo", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.PATH);
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getPathPart()).isEqualTo("foo");
 
     view = getView("/repo/+show/master/foo/bar");
-    assertEquals(Type.PATH, view.getType());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals("foo/bar", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.PATH);
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getPathPart()).isEqualTo("foo/bar");
 
-    assertNull(getView("/repo/+show/stable..master/foo"));
+    assertThat(getView("/repo/+show/stable..master/foo")).isNull();
   }
 
   @Test
@@ -264,38 +263,38 @@
     GitilesView view;
 
     view = getView("/repo/+doc/master/");
-    assertEquals(Type.DOC, view.getType());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals("", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.DOC);
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getPathPart()).isEqualTo("");
 
     view = getView("/repo/+doc/master/index.md");
-    assertEquals(Type.DOC, view.getType());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals("index.md", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.DOC);
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getPathPart()).isEqualTo("index.md");
 
     view = getView("/repo/+doc/master/foo/");
-    assertEquals(Type.DOC, view.getType());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals("foo", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.DOC);
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getPathPart()).isEqualTo("foo");
 
     view = getView("/repo/+doc/master/foo/bar.md");
-    assertEquals(Type.DOC, view.getType());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals("foo/bar.md", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.DOC);
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getPathPart()).isEqualTo("foo/bar.md");
 
-    assertNull(getView("/repo/+doc/stable..master/foo"));
+    assertThat(getView("/repo/+doc/stable..master/foo")).isNull();
   }
 
   @Test
   public void multipleSlashes() throws Exception {
     repo.branch("refs/heads/master").commit().create();
-    assertEquals(Type.HOST_INDEX, getView("//").getType());
-    assertEquals(Type.REPOSITORY_INDEX, getView("//repo").getType());
-    assertEquals(Type.REPOSITORY_INDEX, getView("//repo//").getType());
-    assertNull(getView("/repo/+//master"));
-    assertNull(getView("/repo/+/refs//heads//master"));
-    assertNull(getView("/repo/+//master//"));
-    assertNull(getView("/repo/+//master/foo//bar"));
+    assertThat(getView("//").getType()).isEqualTo(Type.HOST_INDEX);
+    assertThat(getView("//repo").getType()).isEqualTo(Type.REPOSITORY_INDEX);
+    assertThat(getView("//repo//").getType()).isEqualTo(Type.REPOSITORY_INDEX);
+    assertThat(getView("/repo/+//master")).isNull();
+    assertThat(getView("/repo/+/refs//heads//master")).isNull();
+    assertThat(getView("/repo/+//master//")).isNull();
+    assertThat(getView("/repo/+//master/foo//bar")).isNull();
   }
 
   @Test
@@ -305,47 +304,47 @@
     GitilesView view;
 
     view = getView("/repo/+diff/master^..master");
-    assertEquals(Type.DIFF, view.getType());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals("master^", view.getOldRevision().getName());
-    assertEquals(parent, view.getOldRevision().getId());
-    assertEquals("", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.DIFF);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getOldRevision().getName()).isEqualTo("master^");
+    assertThat(view.getOldRevision().getId()).isEqualTo(parent);
+    assertThat(view.getPathPart()).isEqualTo("");
 
     view = getView("/repo/+diff/master^..master/");
-    assertEquals(Type.DIFF, view.getType());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals("master^", view.getOldRevision().getName());
-    assertEquals(parent, view.getOldRevision().getId());
-    assertEquals("", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.DIFF);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getOldRevision().getName()).isEqualTo("master^");
+    assertThat(view.getOldRevision().getId()).isEqualTo(parent);
+    assertThat(view.getPathPart()).isEqualTo("");
 
     view = getView("/repo/+diff/master^..master/foo");
-    assertEquals(Type.DIFF, view.getType());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals("master^", view.getOldRevision().getName());
-    assertEquals(parent, view.getOldRevision().getId());
-    assertEquals("foo", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.DIFF);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getOldRevision().getName()).isEqualTo("master^");
+    assertThat(view.getOldRevision().getId()).isEqualTo(parent);
+    assertThat(view.getPathPart()).isEqualTo("foo");
 
     view = getView("/repo/+diff/refs/heads/master^..refs/heads/master");
-    assertEquals(Type.DIFF, view.getType());
-    assertEquals("refs/heads/master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals("refs/heads/master^", view.getOldRevision().getName());
-    assertEquals(parent, view.getOldRevision().getId());
-    assertEquals("", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.DIFF);
+    assertThat(view.getRevision().getName()).isEqualTo("refs/heads/master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getOldRevision().getName()).isEqualTo("refs/heads/master^");
+    assertThat(view.getOldRevision().getId()).isEqualTo(parent);
+    assertThat(view.getPathPart()).isEqualTo("");
   }
 
   @Test
   public void diffAgainstEmptyCommit() throws Exception {
     RevCommit master = repo.branch("refs/heads/master").commit().create();
     GitilesView view = getView("/repo/+diff/master^!");
-    assertEquals(Type.DIFF, view.getType());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals("", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.DIFF);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isEqualTo("");
   }
 
   @Test
@@ -355,67 +354,67 @@
     GitilesView view;
 
     view = getView("/repo/+log");
-    assertEquals(Type.LOG, view.getType());
-    assertEquals(Revision.NULL, view.getRevision());
-    assertNull(view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.LOG);
+    assertThat(view.getRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isNull();
 
     view = getView("/repo/+log/");
-    assertEquals(Type.LOG, view.getType());
-    assertEquals(Revision.NULL, view.getRevision());
-    assertNull(view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.LOG);
+    assertThat(view.getRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isNull();
 
     view = getView("/repo/+log/master");
-    assertEquals(Type.LOG, view.getType());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals("", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.LOG);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isEqualTo("");
 
     view = getView("/repo/+log/master/");
-    assertEquals(Type.LOG, view.getType());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals("", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.LOG);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isEqualTo("");
 
     view = getView("/repo/+log/master/foo");
-    assertEquals(Type.LOG, view.getType());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals("foo", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.LOG);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isEqualTo("foo");
 
     view = getView("/repo/+log/master^..master");
-    assertEquals(Type.LOG, view.getType());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals("master^", view.getOldRevision().getName());
-    assertEquals(parent, view.getOldRevision().getId());
-    assertEquals("", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.LOG);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getOldRevision().getName()).isEqualTo("master^");
+    assertThat(view.getOldRevision().getId()).isEqualTo(parent);
+    assertThat(view.getPathPart()).isEqualTo("");
 
     view = getView("/repo/+log/master^..master/");
-    assertEquals(Type.LOG, view.getType());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals("master^", view.getOldRevision().getName());
-    assertEquals(parent, view.getOldRevision().getId());
-    assertEquals("", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.LOG);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getOldRevision().getName()).isEqualTo("master^");
+    assertThat(view.getOldRevision().getId()).isEqualTo(parent);
+    assertThat(view.getPathPart()).isEqualTo("");
 
     view = getView("/repo/+log/master^..master/foo");
-    assertEquals(Type.LOG, view.getType());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals("master^", view.getOldRevision().getName());
-    assertEquals(parent, view.getOldRevision().getId());
-    assertEquals("foo", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.LOG);
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getOldRevision().getName()).isEqualTo("master^");
+    assertThat(view.getOldRevision().getId()).isEqualTo(parent);
+    assertThat(view.getPathPart()).isEqualTo("foo");
 
     view = getView("/repo/+log/refs/heads/master^..refs/heads/master");
-    assertEquals(Type.LOG, view.getType());
-    assertEquals("refs/heads/master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals("refs/heads/master^", view.getOldRevision().getName());
-    assertEquals(parent, view.getOldRevision().getId());
-    assertEquals("", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.LOG);
+    assertThat(view.getRevision().getName()).isEqualTo("refs/heads/master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getOldRevision().getName()).isEqualTo("refs/heads/master^");
+    assertThat(view.getOldRevision().getId()).isEqualTo(parent);
+    assertThat(view.getPathPart()).isEqualTo("");
   }
 
   @Test
@@ -424,40 +423,40 @@
     repo.branch("refs/heads/branch").commit().create();
     GitilesView view;
 
-    assertNull(getView("/repo/+archive"));
-    assertNull(getView("/repo/+archive/"));
-    assertNull(getView("/repo/+archive/master..branch"));
-    assertNull(getView("/repo/+archive/master.foo"));
-    assertNull(getView("/repo/+archive/master.zip"));
-    assertNull(getView("/repo/+archive/master/.tar.gz"));
-    assertNull(getView("/repo/+archive/master/foo/.tar.gz"));
+    assertThat(getView("/repo/+archive")).isNull();
+    assertThat(getView("/repo/+archive/")).isNull();
+    assertThat(getView("/repo/+archive/master..branch")).isNull();
+    assertThat(getView("/repo/+archive/master.foo")).isNull();
+    assertThat(getView("/repo/+archive/master.zip")).isNull();
+    assertThat(getView("/repo/+archive/master/.tar.gz")).isNull();
+    assertThat(getView("/repo/+archive/master/foo/.tar.gz")).isNull();
 
     view = getView("/repo/+archive/master.tar.gz");
-    assertEquals(Type.ARCHIVE, view.getType());
-    assertEquals("repo", view.getRepositoryName());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals(".tar.gz", view.getExtension());
-    assertNull(view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.ARCHIVE);
+    assertThat(view.getRepositoryName()).isEqualTo("repo");
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getExtension()).isEqualTo(".tar.gz");
+    assertThat(view.getPathPart()).isNull();
 
     view = getView("/repo/+archive/master.tar.bz2");
-    assertEquals(Type.ARCHIVE, view.getType());
-    assertEquals("repo", view.getRepositoryName());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals(".tar.bz2", view.getExtension());
-    assertNull(view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.ARCHIVE);
+    assertThat(view.getRepositoryName()).isEqualTo("repo");
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getExtension()).isEqualTo(".tar.bz2");
+    assertThat(view.getPathPart()).isNull();
 
     view = getView("/repo/+archive/master/foo/bar.tar.gz");
-    assertEquals(Type.ARCHIVE, view.getType());
-    assertEquals("repo", view.getRepositoryName());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals(".tar.gz", view.getExtension());
-    assertEquals("foo/bar", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.ARCHIVE);
+    assertThat(view.getRepositoryName()).isEqualTo("repo");
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getExtension()).isEqualTo(".tar.gz");
+    assertThat(view.getPathPart()).isEqualTo("foo/bar");
   }
 
   @Test
@@ -466,18 +465,18 @@
     repo.branch("refs/heads/branch").commit().create();
     GitilesView view;
 
-    assertNull(getView("/repo/+blame"));
-    assertNull(getView("/repo/+blame/"));
-    assertNull(getView("/repo/+blame/master"));
-    assertNull(getView("/repo/+blame/master..branch"));
+    assertThat(getView("/repo/+blame")).isNull();
+    assertThat(getView("/repo/+blame/")).isNull();
+    assertThat(getView("/repo/+blame/master")).isNull();
+    assertThat(getView("/repo/+blame/master..branch")).isNull();
 
     view = getView("/repo/+blame/master/foo/bar");
-    assertEquals(Type.BLAME, view.getType());
-    assertEquals("repo", view.getRepositoryName());
-    assertEquals("master", view.getRevision().getName());
-    assertEquals(master, view.getRevision().getId());
-    assertEquals(Revision.NULL, view.getOldRevision());
-    assertEquals("foo/bar", view.getPathPart());
+    assertThat(view.getType()).isEqualTo(Type.BLAME);
+    assertThat(view.getRepositoryName()).isEqualTo("repo");
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getRevision().getId()).isEqualTo(master);
+    assertThat(view.getOldRevision()).isEqualTo(Revision.NULL);
+    assertThat(view.getPathPart()).isEqualTo("foo/bar");
   }
 
   @Test
@@ -486,31 +485,31 @@
     RevCommit master = repo.branch("refs/heads/master").commit().parent(parent).create();
     GitilesView view;
 
-    assertEquals("/b/repo/+/master", getView("/repo/+/master").toUrl());
-    assertEquals("/b/repo/+/" + master.name(), getView("/repo/+/" + master.name()).toUrl());
-    assertEquals("/b/repo/+/" + parent.name(), getRedirectUrl("/repo/+/master~"));
-    assertEquals("/b/repo/+/" + parent.name(), getRedirectUrl("/repo/+/master^"));
+    assertThat(getView("/repo/+/master").toUrl()).isEqualTo("/b/repo/+/master");
+    assertThat(getView("/repo/+/" + master.name()).toUrl()).isEqualTo("/b/repo/+/" + master.name());
+    assertThat(getRedirectUrl("/repo/+/master~")).isEqualTo("/b/repo/+/" + parent.name());
+    assertThat(getRedirectUrl("/repo/+/master^")).isEqualTo("/b/repo/+/" + parent.name());
 
     view = getView("/repo/+log/master~..master/");
-    assertEquals("master", view.getRevision().getName());
-    assertEquals("master~", view.getOldRevision().getName());
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getOldRevision().getName()).isEqualTo("master~");
 
     view = getView("/repo/+log/master^!/");
-    assertEquals("master", view.getRevision().getName());
-    assertEquals("master^", view.getOldRevision().getName());
+    assertThat(view.getRevision().getName()).isEqualTo("master");
+    assertThat(view.getOldRevision().getName()).isEqualTo("master^");
   }
 
   private String getRedirectUrl(String pathAndQuery) throws ServletException, IOException {
     TestViewFilter.Result result = TestViewFilter.service(repo, pathAndQuery);
-    assertEquals(302, result.getResponse().getStatus());
+    assertThat(result.getResponse().getStatus()).isEqualTo(302);
     return result.getResponse().getHeader(HttpHeaders.LOCATION);
   }
 
   private GitilesView getView(String pathAndQuery) throws ServletException, IOException {
     TestViewFilter.Result result = TestViewFilter.service(repo, pathAndQuery);
     FakeHttpServletResponse resp = result.getResponse();
-    assertTrue("expected non-redirect status, got " + resp.getStatus(),
-        resp.getStatus() < 300 || resp.getStatus() >= 400);
+    assertWithMessage("expected non-redirect status, got " + resp.getStatus())
+        .that(resp.getStatus() < 300 || resp.getStatus() >= 400).isTrue();
     return result.getView();
   }
 }
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/blame/BlameServletTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/blame/BlameServletTest.java
index 064b822..a86ae83 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/blame/BlameServletTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/blame/BlameServletTest.java
@@ -14,7 +14,7 @@
 
 package com.google.gitiles.blame;
 
-import static org.junit.Assert.assertEquals;
+import static com.google.common.truth.Truth.assertThat;
 
 import com.google.common.collect.Iterables;
 import com.google.gitiles.CommitJsonData.Ident;
@@ -47,27 +47,27 @@
     RevCommit c2 = repo.update("master", repo.commit().tick(10).parent(c1).add("foo", contents2));
 
     Map<String, List<RegionJsonData>> result = getBlameJson("/repo/+blame/" + c2.name() + "/foo");
-    assertEquals("regions", Iterables.getOnlyElement(result.keySet()));
+    assertThat(Iterables.getOnlyElement(result.keySet())).isEqualTo("regions");
     List<RegionJsonData> regions = result.get("regions");
-    assertEquals(2, regions.size());
+    assertThat(regions.size()).isEqualTo(2);
 
     RegionJsonData r1 = regions.get(0);
-    assertEquals(1, r1.start);
-    assertEquals(1, r1.count);
-    assertEquals("foo", r1.path);
-    assertEquals(c1.name(), r1.commit);
-    assertEquals("J. Author", r1.author.name);
-    assertEquals("jauthor@example.com", r1.author.email);
-    assertEquals("2009-03-13 17:29:48 -0330", r1.author.time);
+    assertThat(r1.start).isEqualTo(1);
+    assertThat(r1.count).isEqualTo(1);
+    assertThat(r1.path).isEqualTo("foo");
+    assertThat(r1.commit).isEqualTo(c1.name());
+    assertThat(r1.author.name).isEqualTo("J. Author");
+    assertThat(r1.author.email).isEqualTo("jauthor@example.com");
+    assertThat(r1.author.time).isEqualTo("2009-03-13 17:29:48 -0330");
 
     RegionJsonData r2 = regions.get(1);
-    assertEquals(2, r2.start);
-    assertEquals(1, r2.count);
-    assertEquals("foo", r2.path);
-    assertEquals(c2.name(), r2.commit);
-    assertEquals("J. Author", r2.author.name);
-    assertEquals("jauthor@example.com", r2.author.email);
-    assertEquals("2009-03-13 17:29:58 -0330", r2.author.time);
+    assertThat(r2.start).isEqualTo(2);
+    assertThat(r2.count).isEqualTo(1);
+    assertThat(r2.path).isEqualTo("foo");
+    assertThat(r2.commit).isEqualTo(c2.name());
+    assertThat(r2.author.name).isEqualTo("J. Author");
+    assertThat(r2.author.email).isEqualTo("jauthor@example.com");
+    assertThat(r2.author.time).isEqualTo("2009-03-13 17:29:58 -0330");
   }
 
   private Map<String, List<RegionJsonData>> getBlameJson(String path) throws Exception {
diff --git a/gitiles-servlet/src/test/java/com/google/gitiles/doc/DocServletTest.java b/gitiles-servlet/src/test/java/com/google/gitiles/doc/DocServletTest.java
index a53949c..a2a0a2e 100644
--- a/gitiles-servlet/src/test/java/com/google/gitiles/doc/DocServletTest.java
+++ b/gitiles-servlet/src/test/java/com/google/gitiles/doc/DocServletTest.java
@@ -14,8 +14,7 @@
 
 package com.google.gitiles.doc;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static com.google.common.truth.Truth.assertThat;
 
 import com.google.gitiles.ServletTest;
 
@@ -39,9 +38,9 @@
         .create();
 
     String html = buildHtml("/repo/+doc/master/README.md");
-    assertTrue(html.contains("<title>" + title + "</title>"));
-    assertTrue(html.contains(title + "</h1>"));
-    assertTrue(html.contains("<a href=\"" + url + "\">Markdown</a>"));
+    assertThat(html).contains("<title>" + title + "</title>");
+    assertThat(html).contains(title + "</h1>");
+    assertThat(html).contains("<a href=\"" + url + "\">Markdown</a>");
   }
 
   @Test
@@ -56,15 +55,15 @@
         .create();
 
     String html = buildHtml("/repo/+doc/master/README.md");
-    assertTrue(html.contains("<title>Site Title - page</title>"));
+    assertThat(html).contains("<title>Site Title - page</title>");
 
-    assertTrue(html.contains("<h1>Site Title</h1>"));
-    assertTrue(html.contains("<h2>page</h2>"));
-    assertTrue(html.contains("<li><a href=\"index.md\">Home</a></li>"));
-    assertTrue(html.contains("<li><a href=\"README.md\">README</a></li>"));
-    assertTrue(html.contains("<h1>"
+    assertThat(html).contains("<h1>Site Title</h1>");
+    assertThat(html).contains("<h2>page</h2>");
+    assertThat(html).contains("<li><a href=\"index.md\">Home</a></li>");
+    assertThat(html).contains("<li><a href=\"README.md\">README</a></li>");
+    assertThat(html).contains("<h1>"
         + "<a class=\"h\" name=\"page\" href=\"#page\"><span></span></a>"
-        + "page</h1>"));
+        + "page</h1>");
   }
 
   @Test
@@ -79,11 +78,11 @@
         .create();
 
     String html = buildHtml("/repo/+doc/master/");
-    assertTrue(html.contains("B. Ad</h1>"));
-    assertTrue(html.contains("Non-HTML is fine."));
+    assertThat(html).contains("B. Ad</h1>");
+    assertThat(html).contains("Non-HTML is fine.");
 
-    assertFalse(html.contains("window.alert"));
-    assertFalse(html.contains("<script>"));
+    assertThat(html).doesNotContain("window.alert");
+    assertThat(html).doesNotContain("<script>");
   }
 
   @Test
@@ -94,12 +93,12 @@
       .add("index.md", markdown)
       .create();
     String html = buildHtml("/repo/+doc/master/");
-    assertTrue(html.contains("<h1>"
+    assertThat(html).contains("<h1>"
         + "<a class=\"h\" name=\"debug\" href=\"#debug\"><span></span></a>"
-        + "Section</h1>"));
-    assertTrue(html.contains("<h1>"
+        + "Section</h1>");
+    assertThat(html).contains("<h1>"
         + "<a class=\"h\" name=\"old-school\" href=\"#old-school\"><span></span></a>"
-        + "Other</h1>"));
+        + "Other</h1>");
   }
 
   @Test
@@ -110,7 +109,7 @@
         .create();
 
     String html = buildHtml("/repo/+doc/master/index.md");
-    assertTrue(html.contains("Incomplete &lt;html is literal."));
+    assertThat(html).contains("Incomplete &lt;html is literal.");
   }
 
   @Test
@@ -120,7 +119,7 @@
         .create();
 
     String html = buildHtml("/repo/+doc/master/A/B/README.md");
-    assertTrue(html.contains("<a href=\"/b/repo/+show/master/C\">c</a>"));
+    assertThat(html).contains("<a href=\"/b/repo/+show/master/C\">c</a>");
   }
 
   @Test
@@ -130,7 +129,7 @@
         .create();
 
     String html = buildHtml("/repo/+doc/master/README.md");
-    assertTrue(html.contains("<a href=\"/b/repo/+show/master/x\">c</a>"));
+    assertThat(html).contains("<a href=\"/b/repo/+show/master/x\">c</a>");
   }
 
 }
diff --git a/lib/BUCK b/lib/BUCK
index 45696c4..e042822 100644
--- a/lib/BUCK
+++ b/lib/BUCK
@@ -84,3 +84,14 @@
   sha1 = '0aaaa85845fb5c59da00193f06b8e5278d8bf3f8',
   unsign = True,
 )
+
+maven_jar(
+  name = 'truth',
+  id = 'com.google.truth:truth:0.27',
+  sha1 = 'bd17774d2dc0fffa884d42c07d2537e86c67acd6',
+  license = 'DO_NOT_DISTRIBUTE',
+  exported_deps = [
+    ':guava',
+    '//lib/junit:junit',
+  ],
+)