Migrate tests to Truth.

RELNOTES: None.

PiperOrigin-RevId: 157378037

1 files changed, 53 insertions, 63 deletions

diff --git a/src/test/java/com/google/devtools/build/lib/pkgcache/TargetPatternEvaluatorTest.java b/src/test/java/com/google/devtools/build/lib/pkgcache/TargetPatternEvaluatorTest.java
index da003add73..7f7376c5f3 100644
--- a/src/test/java/com/google/devtools/build/lib/pkgcache/TargetPatternEvaluatorTest.java
+++ b/src/test/java/com/google/devtools/build/lib/pkgcache/TargetPatternEvaluatorTest.java
@@ -15,10 +15,6 @@ package com.google.devtools.build.lib.pkgcache;
 
 import static com.google.common.truth.Truth.assertThat;
 import static com.google.devtools.build.lib.pkgcache.FilteringPolicies.FILTER_TESTS;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 import com.google.common.collect.ImmutableList;
@@ -36,15 +32,13 @@ import com.google.devtools.build.lib.util.Pair;
 import com.google.devtools.build.lib.vfs.ModifiedFileSet;
 import com.google.devtools.build.lib.vfs.Path;
 import com.google.devtools.build.lib.vfs.PathFragment;
-
+import java.util.Arrays;
+import java.util.Set;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
-import java.util.Arrays;
-import java.util.Set;
-
 /** Tests for {@link TargetPatternEvaluator}. */
 @RunWith(JUnit4.class)
 public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTest {
@@ -170,7 +164,7 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
       throws TargetParsingException, InterruptedException {
     ResolvedTargets<Target> result =
         parseTargetPatternList(parser, parsingListener, Arrays.asList(patterns), true);
-    assertTrue(result.hasError());
+    assertThat(result.hasError()).isTrue();
     return targetsToLabels(result.getTargets());
   }
 
@@ -188,7 +182,7 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
   }
 
   private static Set<Target> getFailFast(ResolvedTargets<Target> result) {
-    assertFalse(result.hasError());
+    assertThat(result.hasError()).isFalse();
     return result.getTargets();
   }
 
@@ -198,7 +192,7 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
       parser.parseTargetPattern(parsingListener, target, false);
       fail("target='" + target + "', expected error: " + expectedError);
     } catch (TargetParsingException e) {
-      assertThat(e.getMessage()).contains(expectedError);
+      assertThat(e).hasMessageThat().contains(expectedError);
     }
   }
 
@@ -224,14 +218,13 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
 
   @Test
   public void testParsingStandardLabel() throws Exception {
-    assertEquals("//foo:foo1",
-        parseIndividualTarget("//foo:foo1").toString());
+    assertThat(parseIndividualTarget("//foo:foo1").toString()).isEqualTo("//foo:foo1");
   }
 
   @Test
   public void testAbsolutePatternEndsWithSlashAll() throws Exception {
     scratch.file("foo/all/BUILD", "cc_library(name = 'all')");
-    assertEquals("//foo/all:all", parseIndividualTarget("//foo/all").toString());
+    assertThat(parseIndividualTarget("//foo/all").toString()).isEqualTo("//foo/all:all");
     assertNoEvents();
   }
 
@@ -249,8 +242,8 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
   }
 
   private void assertWildcardConflict(String label, String suffix) throws Exception {
-    assertEquals(label, parseIndividualTarget(label).toString());
-    assertSame(1, eventCollector.count());
+    assertThat(parseIndividualTarget(label).toString()).isEqualTo(label);
+    assertThat(eventCollector.count()).isSameAs(1);
     assertContainsEvent(String.format("The target pattern '%s' is ambiguous: '%s' is both "
         + "a wildcard, and the name of an existing cc_library rule; "
         + "using the latter interpretation", label, suffix));
@@ -262,13 +255,13 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
       parseIndividualTarget("//missing:foo1");
       fail("TargetParsingException expected");
     } catch (TargetParsingException e) {
-      assertThat(e.getMessage()).startsWith("no such package");
+      assertThat(e).hasMessageThat().startsWith("no such package");
     }
   }
 
   @Test
   public void testParsingStandardLabelWithRelativeParser() throws Exception {
-    assertEquals("//foo:foo1", parseIndividualTargetRelative("//foo:foo1").toString());
+    assertThat(parseIndividualTargetRelative("//foo:foo1").toString()).isEqualTo("//foo:foo1");
   }
 
   @Test
@@ -277,19 +270,18 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
       parseIndividualTarget("//foo:missing");
       fail("TargetParsingException expected");
     } catch (TargetParsingException e) {
-      assertThat(e.getMessage()).startsWith("no such target");
+      assertThat(e).hasMessageThat().startsWith("no such target");
     }
   }
 
   @Test
   public void testParsingStandardLabelShorthand() throws Exception {
-    assertEquals("//foo:foo1",
-                 parseIndividualTarget("foo:foo1").toString());
+    assertThat(parseIndividualTarget("foo:foo1").toString()).isEqualTo("//foo:foo1");
   }
 
   @Test
   public void testParsingStandardLabelShorthandRelative() throws Exception {
-    assertEquals("//foo:foo1", parseIndividualTargetRelative(":foo1").toString());
+    assertThat(parseIndividualTargetRelative(":foo1").toString()).isEqualTo("//foo:foo1");
   }
 
   @Test
@@ -477,8 +469,10 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
   public void testDefaultPackage() throws Exception {
     scratch.file("experimental/BUILD",
                 "cc_library(name = 'experimental', srcs = [ 'experimental.cc' ])");
-    assertEquals("//experimental:experimental", parseIndividualTarget("//experimental").toString());
-    assertEquals("//experimental:experimental", parseIndividualTarget("experimental").toString());
+    assertThat(parseIndividualTarget("//experimental").toString())
+        .isEqualTo("//experimental:experimental");
+    assertThat(parseIndividualTarget("experimental").toString())
+        .isEqualTo("//experimental:experimental");
     assertNoEvents();
   }
 
@@ -491,28 +485,26 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
     scratch.file("sub/dir/BUILD", "exports_files(['dir2'])");
     scratch.file("sub/dir/dir/BUILD", "exports_files(['dir'])");
     // sub/dir/dir is a package
-    assertEquals("//sub/dir/dir:dir", parseIndividualTarget("sub/dir/dir").toString());
+    assertThat(parseIndividualTarget("sub/dir/dir").toString()).isEqualTo("//sub/dir/dir:dir");
     // sub/dir is a package but not sub/dir/dir2
-    assertEquals("//sub/dir:dir2", parseIndividualTarget("sub/dir/dir2").toString());
+    assertThat(parseIndividualTarget("sub/dir/dir2").toString()).isEqualTo("//sub/dir:dir2");
     // sub is a package but not sub/dir2
-    assertEquals("//sub:dir2/dir2", parseIndividualTarget("sub/dir2/dir2").toString());
+    assertThat(parseIndividualTarget("sub/dir2/dir2").toString()).isEqualTo("//sub:dir2/dir2");
   }
 
   @Test
   public void testFindsLongestPlausiblePackageName() throws Exception {
-    assertEquals("//foo/bar:baz",
-                 parseIndividualTarget("foo/bar/baz").toString());
-    assertEquals("//foo/bar:baz/bang",
-                 parseIndividualTarget("foo/bar/baz/bang").toString());
-    assertEquals("//foo:baz/bang",
-        parseIndividualTarget("foo/baz/bang").toString());
+    assertThat(parseIndividualTarget("foo/bar/baz").toString()).isEqualTo("//foo/bar:baz");
+    assertThat(parseIndividualTarget("foo/bar/baz/bang").toString())
+        .isEqualTo("//foo/bar:baz/bang");
+    assertThat(parseIndividualTarget("foo/baz/bang").toString()).isEqualTo("//foo:baz/bang");
   }
 
   @Test
   public void testParsesIterableOfLabels() throws Exception {
     Set<Label> labels = Sets.newHashSet(Label.parseAbsolute("//foo/bar:bar1"),
         Label.parseAbsolute("//foo:foo1"));
-    assertEquals(labels, parseList("//foo/bar:bar1", "//foo:foo1"));
+    assertThat(parseList("//foo/bar:bar1", "//foo:foo1")).isEqualTo(labels);
     parsingListener.assertEmpty();
   }
 
@@ -520,24 +512,23 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
   public void testParseAbsoluteWithRelativeParser() throws Exception {
     Set<Label> labels = Sets.newHashSet(Label.parseAbsolute("//foo/bar:bar1"),
         Label.parseAbsolute("//foo:foo1"));
-    assertEquals(labels, parseListRelative("//foo/bar:bar1", "//foo:foo1"));
+    assertThat(parseListRelative("//foo/bar:bar1", "//foo:foo1")).isEqualTo(labels);
     parsingListener.assertEmpty();
   }
 
   @Test
   public void testMultisegmentLabelsWithNoSlashSlash() throws Exception {
-    assertEquals("//foo/bar:wiz/bang",
-        parseIndividualTarget("foo/bar:wiz/bang").toString());
-    assertEquals("//foo/bar:wiz/all",
-        parseIndividualTarget("foo/bar:wiz/all").toString());
+    assertThat(parseIndividualTarget("foo/bar:wiz/bang").toString())
+        .isEqualTo("//foo/bar:wiz/bang");
+    assertThat(parseIndividualTarget("foo/bar:wiz/all").toString()).isEqualTo("//foo/bar:wiz/all");
   }
 
   @Test
   public void testMultisegmentLabelsWithNoSlashSlashRelative() throws Exception {
-    assertEquals("//foo/bar:wiz/bang",
-        parseIndividualTargetRelative("bar:wiz/bang").toString());
-    assertEquals("//foo/bar:wiz/all",
-        parseIndividualTargetRelative("bar:wiz/all").toString());
+    assertThat(parseIndividualTargetRelative("bar:wiz/bang").toString())
+        .isEqualTo("//foo/bar:wiz/bang");
+    assertThat(parseIndividualTargetRelative("bar:wiz/all").toString())
+        .isEqualTo("//foo/bar:wiz/all");
   }
 
   /** Regression test for a bug. */
@@ -546,8 +537,7 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
     scratch.file("x/y/BUILD", "cc_library(name='y')");
     scratch.file("x/z/BUILD", "cc_library(name='z')");
     setDeletedPackages(Sets.newHashSet(PackageIdentifier.createInMainRepo("x/y")));
-    assertEquals(Sets.newHashSet(Label.parseAbsolute("//x/z")),
-        parseList("x/..."));
+    assertThat(parseList("x/...")).isEqualTo(Sets.newHashSet(Label.parseAbsolute("//x/z")));
   }
 
   @Test
@@ -557,8 +547,9 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
     setDeletedPackages(Sets.newHashSet(PackageIdentifier.createInMainRepo("x/y")));
 
     parser.updateOffset(PathFragment.create("x"));
-    assertEquals(Sets.newHashSet(Label.parseAbsolute("//x/z")),
-        targetsToLabels(getFailFast(parser.parseTargetPattern(parsingListener, "...", false))));
+    assertThat(
+            targetsToLabels(getFailFast(parser.parseTargetPattern(parsingListener, "...", false))))
+        .isEqualTo(Sets.newHashSet(Label.parseAbsolute("//x/z")));
   }
 
   @Test
@@ -566,15 +557,15 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
     scratch.file("x/y/BUILD", "cc_library(name='y')");
     scratch.file("x/z/BUILD", "cc_library(name='z')");
 
-    assertEquals(Sets.newHashSet(Label.parseAbsolute("//x/y"), Label.parseAbsolute("//x/z")),
-        parseList("x/..."));
+    assertThat(parseList("x/...")).containsExactly(
+        Label.parseAbsolute("//x/y"), Label.parseAbsolute("//x/z"));
 
     setDeletedPackages(Sets.newHashSet(PackageIdentifier.createInMainRepo("x/y")));
-    assertEquals(Sets.newHashSet(Label.parseAbsolute("//x/z")), parseList("x/..."));
+    assertThat(parseList("x/...")).containsExactly(Label.parseAbsolute("//x/z"));
 
     setDeletedPackages(ImmutableSet.<PackageIdentifier>of());
-    assertEquals(Sets.newHashSet(Label.parseAbsolute("//x/y"), Label.parseAbsolute("//x/z")),
-        parseList("x/..."));
+    assertThat(parseList("x/...")).containsExactly(
+        Label.parseAbsolute("//x/y"), Label.parseAbsolute("//x/z"));
   }
 
   @Test
@@ -784,10 +775,10 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
 
   @Test
   public void testSetOffset() throws Exception {
-    assertEquals("//foo:foo1", parseIndividualTarget("foo:foo1").toString());
+    assertThat(parseIndividualTarget("foo:foo1").toString()).isEqualTo("//foo:foo1");
 
     parser.updateOffset(PathFragment.create("foo"));
-    assertEquals("//foo:foo1", parseIndividualTarget(":foo1").toString());
+    assertThat(parseIndividualTarget(":foo1").toString()).isEqualTo("//foo:foo1");
   }
 
   @Test
@@ -847,7 +838,7 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
     assertThat(result.first)
         .containsExactlyElementsIn(
             Sets.newHashSet(Label.parseAbsolute("//x/y:a"), Label.parseAbsolute("//x/y:b")));
-    assertFalse(result.second);
+    assertThat(result.second).isFalse();
   }
 
   @Test
@@ -883,7 +874,7 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
 
     // Even though there was a loading error in the package, parsing the target pattern was
     // successful.
-    assertFalse(result.second);
+    assertThat(result.second).isFalse();
   }
 
   @Test
@@ -901,7 +892,7 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
           /*keepGoing=*/false);
       fail();
     } catch (TargetParsingException e) {
-      assertThat(e.getMessage()).contains("no such target");
+      assertThat(e).hasMessageThat().contains("no such target");
     }
   }
 
@@ -910,13 +901,12 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
     ResolvedTargets<Target> result = parseTargetPatternList(parser, parsingListener,
         Arrays.asList("//foo/bar/BUILD"), false);
 
-    assertFalse(result.hasError());
+    assertThat(result.hasError()).isFalse();
     assertThat(result.getTargets()).hasSize(1);
 
     Label label = Iterables.getOnlyElement(result.getTargets()).getLabel();
-    assertEquals("BUILD", label.getName());
-    assertEquals("foo/bar", label.getPackageName());
-
+    assertThat(label.getName()).isEqualTo("BUILD");
+    assertThat(label.getPackageName()).isEqualTo("foo/bar");
   }
 
   /**
@@ -933,9 +923,9 @@ public class TargetPatternEvaluatorTest extends AbstractTargetPatternEvaluatorTe
         "genrule(name='c', outs=['c.out'])");
 
     Pair<Set<Label>, Boolean> result = parseListKeepGoing("//loading:y");
-    assertEquals(Label.parseAbsolute("//loading:y"), Iterables.getOnlyElement(result.first));
+    assertThat(result.first).containsExactly(Label.parseAbsolute("//loading:y"));
     assertContainsEvent("missing value for mandatory attribute");
-    assertFalse(result.second);
+    assertThat(result.second).isFalse();
   }
 
   private void assertKeepGoing(Set<Label> expectedLabels, String expectedEvent, String... toParse)