Truthify graph tests.

We'd already been using Truth a lot, so many of the examples here are just to use `assertThat(x).isTrue()` instead of `assertTrue(x)` (or similarly for "false" assertions). It's reasonable to debate whether that's an improvement. I will say that I've been surprised multiple times recently by `assertFalse` assertions, similar to how it's unfortunate to have `if (!some.very().long(EXPRESSION).afterWhich(youHaveForgottenAboutTheNegation)`, so I'm more a fan of using Truth there than I used to be.

The possibility of using Truth more came to my attention during cl/810738337 because of the `Optional` assertions in `GraphsTest` (and `ValueGraphTest`), where Truth provides clearer value.

I noticed that `containsExactlySanityCheck` was doing [the kind of thing we discourage](google/truth#268), in which it calls methods like `hasSize` and `contains` with the apparently intention of testing our implementations of `size()` and `contains(...)`, rather than verifying that some _earlier_ step had produced the right answer. I've migrated it to direct calls to `Collection` methods. Arguably the best approach would be to have one such test and then to use Truth's usual methods (with their superior failure messages) for "normal" tests.

Finally, in `TraverserTest`, I suspect that we were copying to an `ImmutableList` in order to be sure that we got a good failure message even in the absence of an implementation of `Traverser.toString()`. I verified that we do get a good message even without the copy because [Truth has our backs](https://github.com/google/truth/blob/22a4601c3c6b79b285740d37e82ec8dc56d2344d/core/src/main/java/com/google/common/truth/IterableSubject.java#L107-L119):

```
unexpected (1): b
---
expected      : [a]
but was       : [a, b]
```
RELNOTES=n/a
PiperOrigin-RevId: 813317064

Author: cpovirk

android/guava-tests/test/com/google/common/graph/AbstractNetworkTest.java

@@ -25,9 +25,7 @@
 import static com.google.common.truth.Truth.assertThat;
 import static com.google.common.truth.TruthJUnit.assume;
 import static java.util.concurrent.Executors.newFixedThreadPool;
-import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThrows;
-import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 import com.google.common.collect.ImmutableList;
@@ -187,8 +185,9 @@ static <N, E> void validateNetwork(Network<N, E> network) {
       for (N incidentNode : network.incidentNodes(edge)) {
         assertThat(network.nodes()).contains(incidentNode);
         for (E adjacentEdge : network.incidentEdges(incidentNode)) {
-          assertTrue(
-              edge.equals(adjacentEdge) || network.adjacentEdges(edge).contains(adjacentEdge));
+          assertThat(
+                  edge.equals(adjacentEdge) || network.adjacentEdges(edge).contains(adjacentEdge))
+              .isTrue();
         }
       }
     }
@@ -263,12 +262,14 @@ static <N, E> void validateNetwork(Network<N, E> network) {
       }
 
       for (N adjacentNode : sanityCheckSet(network.adjacentNodes(node))) {
-        assertTrue(
-            network.predecessors(node).contains(adjacentNode)
-                || network.successors(node).contains(adjacentNode));
-        assertTrue(
-            !network.edgesConnecting(node, adjacentNode).isEmpty()
-                || !network.edgesConnecting(adjacentNode, node).isEmpty());
+        assertThat(
+                network.predecessors(node).contains(adjacentNode)
+                    || network.successors(node).contains(adjacentNode))
+            .isTrue();
+        assertThat(
+                !network.edgesConnecting(node, adjacentNode).isEmpty()
+                    || !network.edgesConnecting(adjacentNode, node).isEmpty())
+            .isTrue();
       }
 
       for (N predecessor : sanityCheckSet(network.predecessors(node))) {
@@ -282,9 +283,10 @@ static <N, E> void validateNetwork(Network<N, E> network) {
       }
 
       for (E incidentEdge : sanityCheckSet(network.incidentEdges(node))) {
-        assertTrue(
-            network.inEdges(node).contains(incidentEdge)
-                || network.outEdges(node).contains(incidentEdge));
+        assertThat(
+                network.inEdges(node).contains(incidentEdge)
+                    || network.outEdges(node).contains(incidentEdge))
+            .isTrue();
         assertThat(network.edges()).contains(incidentEdge);
         assertThat(network.incidentNodes(incidentEdge)).contains(node);
       }
@@ -623,7 +625,7 @@ public void successors_nodeNotInGraph() {
   public void addNode_newNode() {
     assume().that(graphIsMutable()).isTrue();
 
-    assertTrue(networkAsMutableNetwork.addNode(N1));
+    assertThat(networkAsMutableNetwork.addNode(N1)).isTrue();
     assertThat(networkAsMutableNetwork.nodes()).contains(N1);
   }
 
@@ -633,7 +635,7 @@ public void addNode_existingNode() {
 
     addNode(N1);
     ImmutableSet<Integer> nodes = ImmutableSet.copyOf(networkAsMutableNetwork.nodes());
-    assertFalse(networkAsMutableNetwork.addNode(N1));
+    assertThat(networkAsMutableNetwork.addNode(N1)).isFalse();
     assertThat(networkAsMutableNetwork.nodes()).containsExactlyElementsIn(nodes);
   }
 
@@ -643,8 +645,8 @@ public void removeNode_existingNode() {
 
     addEdge(N1, N2, E12);
     addEdge(N4, N1, E41);
-    assertTrue(networkAsMutableNetwork.removeNode(N1));
-    assertFalse(networkAsMutableNetwork.removeNode(N1));
+    assertThat(networkAsMutableNetwork.removeNode(N1)).isTrue();
+    assertThat(networkAsMutableNetwork.removeNode(N1)).isFalse();
     assertThat(networkAsMutableNetwork.nodes()).containsExactly(N2, N4);
     assertThat(networkAsMutableNetwork.edges()).doesNotContain(E12);
     assertThat(networkAsMutableNetwork.edges()).doesNotContain(E41);
@@ -678,7 +680,7 @@ public void removeNode_nodeNotPresent() {
 
     addNode(N1);
     ImmutableSet<Integer> nodes = ImmutableSet.copyOf(networkAsMutableNetwork.nodes());
-    assertFalse(networkAsMutableNetwork.removeNode(NODE_NOT_IN_GRAPH));
+    assertThat(networkAsMutableNetwork.removeNode(NODE_NOT_IN_GRAPH)).isFalse();
     assertThat(networkAsMutableNetwork.nodes()).containsExactlyElementsIn(nodes);
   }
 
@@ -736,8 +738,8 @@ public void removeEdge_existingEdge() {
     assume().that(graphIsMutable()).isTrue();
 
     addEdge(N1, N2, E12);
-    assertTrue(networkAsMutableNetwork.removeEdge(E12));
-    assertFalse(networkAsMutableNetwork.removeEdge(E12));
+    assertThat(networkAsMutableNetwork.removeEdge(E12)).isTrue();
+    assertThat(networkAsMutableNetwork.removeEdge(E12)).isFalse();
     assertThat(networkAsMutableNetwork.edges()).doesNotContain(E12);
     assertThat(networkAsMutableNetwork.edgesConnecting(N1, N2)).isEmpty();
   }
@@ -750,7 +752,7 @@ public void removeEdge_oneOfMany() {
     addEdge(N1, N3, E13);
     addEdge(N1, N4, E14);
     assertThat(networkAsMutableNetwork.edges()).containsExactly(E12, E13, E14);
-    assertTrue(networkAsMutableNetwork.removeEdge(E13));
+    assertThat(networkAsMutableNetwork.removeEdge(E13)).isTrue();
     assertThat(networkAsMutableNetwork.edges()).containsExactly(E12, E14);
   }
 
@@ -760,7 +762,7 @@ public void removeEdge_edgeNotPresent() {
 
     addEdge(N1, N2, E12);
     ImmutableSet<String> edges = ImmutableSet.copyOf(networkAsMutableNetwork.edges());
-    assertFalse(networkAsMutableNetwork.removeEdge(EDGE_NOT_IN_GRAPH));
+    assertThat(networkAsMutableNetwork.removeEdge(EDGE_NOT_IN_GRAPH)).isFalse();
     assertThat(networkAsMutableNetwork.edges()).containsExactlyElementsIn(edges);
   }
 
@@ -772,7 +774,7 @@ public void removeEdge_queryAfterRemoval() {
     @SuppressWarnings("unused")
     EndpointPair<Integer> unused =
         networkAsMutableNetwork.incidentNodes(E12); // ensure cache (if any) is populated
-    assertTrue(networkAsMutableNetwork.removeEdge(E12));
+    assertThat(networkAsMutableNetwork.removeEdge(E12)).isTrue();
     assertEdgeNotInGraphErrorMessage(
         assertThrows(
             IllegalArgumentException.class, () -> networkAsMutableNetwork.incidentNodes(E12)));
@@ -785,7 +787,7 @@ public void removeEdge_parallelEdge() {
 
     addEdge(N1, N2, E12);
     addEdge(N1, N2, E12_A);
-    assertTrue(networkAsMutableNetwork.removeEdge(E12_A));
+    assertThat(networkAsMutableNetwork.removeEdge(E12_A)).isTrue();
     assertThat(network.edgesConnecting(N1, N2)).containsExactly(E12);
   }
 
@@ -798,10 +800,10 @@ public void removeEdge_parallelSelfLoopEdge() {
     addEdge(N1, N1, E11);
     addEdge(N1, N1, E11_A);
     addEdge(N1, N2, E12);
-    assertTrue(networkAsMutableNetwork.removeEdge(E11_A));
+    assertThat(networkAsMutableNetwork.removeEdge(E11_A)).isTrue();
     assertThat(network.edgesConnecting(N1, N1)).containsExactly(E11);
     assertThat(network.edgesConnecting(N1, N2)).containsExactly(E12);
-    assertTrue(networkAsMutableNetwork.removeEdge(E11));
+    assertThat(networkAsMutableNetwork.removeEdge(E11)).isTrue();
     assertThat(network.edgesConnecting(N1, N1)).isEmpty();
     assertThat(network.edgesConnecting(N1, N2)).containsExactly(E12);
   }

android/guava-tests/test/com/google/common/graph/AbstractStandardDirectedGraphTest.java

@@ -20,7 +20,6 @@
 import static com.google.common.truth.Truth.assertThat;
 import static com.google.common.truth.TruthJUnit.assume;
 import static org.junit.Assert.assertThrows;
-import static org.junit.Assert.assertTrue;
 
 import java.util.Set;
 import org.jspecify.annotations.NullUnmarked;
@@ -362,9 +361,9 @@ public void putEdge_nodesNotInGraph() {
     assume().that(graphIsMutable()).isTrue();
 
     graphAsMutableGraph.addNode(N1);
-    assertTrue(graphAsMutableGraph.putEdge(N1, N5));
-    assertTrue(graphAsMutableGraph.putEdge(N4, N1));
-    assertTrue(graphAsMutableGraph.putEdge(N2, N3));
+    assertThat(graphAsMutableGraph.putEdge(N1, N5)).isTrue();
+    assertThat(graphAsMutableGraph.putEdge(N4, N1)).isTrue();
+    assertThat(graphAsMutableGraph.putEdge(N2, N3)).isTrue();
     assertThat(graph.nodes()).containsExactly(N1, N5, N4, N2, N3).inOrder();
     assertThat(graph.successors(N1)).containsExactly(N5);
     assertThat(graph.successors(N2)).containsExactly(N3);

android/guava-tests/test/com/google/common/graph/AbstractStandardDirectedNetworkTest.java

@@ -21,7 +21,6 @@
 import static com.google.common.truth.Truth.assertThat;
 import static com.google.common.truth.TruthJUnit.assume;
 import static org.junit.Assert.assertThrows;
-import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 import com.google.common.collect.ImmutableSet;
@@ -509,8 +508,8 @@ public void addEdge_parallelEdge_allowsParallelEdges() {
     assume().that(graphIsMutable()).isTrue();
     assume().that(network.allowsParallelEdges()).isTrue();
 
-    assertTrue(networkAsMutableNetwork.addEdge(N1, N2, E12));
-    assertTrue(networkAsMutableNetwork.addEdge(N1, N2, E12_A));
+    assertThat(networkAsMutableNetwork.addEdge(N1, N2, E12)).isTrue();
+    assertThat(networkAsMutableNetwork.addEdge(N1, N2, E12_A)).isTrue();
     assertThat(network.edgesConnecting(N1, N2)).containsExactly(E12, E12_A);
   }
 
@@ -547,9 +546,9 @@ public void addEdge_nodesNotInGraph() {
     assume().that(graphIsMutable()).isTrue();
 
     networkAsMutableNetwork.addNode(N1);
-    assertTrue(networkAsMutableNetwork.addEdge(N1, N5, E15));
-    assertTrue(networkAsMutableNetwork.addEdge(N4, N1, E41));
-    assertTrue(networkAsMutableNetwork.addEdge(N2, N3, E23));
+    assertThat(networkAsMutableNetwork.addEdge(N1, N5, E15)).isTrue();
+    assertThat(networkAsMutableNetwork.addEdge(N4, N1, E41)).isTrue();
+    assertThat(networkAsMutableNetwork.addEdge(N2, N3, E23)).isTrue();
     assertThat(network.nodes()).containsExactly(N1, N5, N4, N2, N3);
     assertThat(network.edges()).containsExactly(E15, E41, E23);
     assertThat(network.edgesConnecting(N1, N5)).containsExactly(E15);
@@ -621,8 +620,8 @@ public void addEdge_parallelSelfLoopEdge_allowsParallelEdges() {
     assume().that(network.allowsSelfLoops()).isTrue();
     assume().that(network.allowsParallelEdges()).isTrue();
 
-    assertTrue(networkAsMutableNetwork.addEdge(N1, N1, E11));
-    assertTrue(networkAsMutableNetwork.addEdge(N1, N1, E11_A));
+    assertThat(networkAsMutableNetwork.addEdge(N1, N1, E11)).isTrue();
+    assertThat(networkAsMutableNetwork.addEdge(N1, N1, E11_A)).isTrue();
     assertThat(network.edgesConnecting(N1, N1)).containsExactly(E11, E11_A);
   }
 

android/guava-tests/test/com/google/common/graph/AbstractStandardUndirectedGraphTest.java

@@ -19,7 +19,6 @@
 import static com.google.common.truth.Truth.assertThat;
 import static com.google.common.truth.TruthJUnit.assume;
 import static org.junit.Assert.assertThrows;
-import static org.junit.Assert.assertTrue;
 
 import com.google.common.testing.EqualsTester;
 import java.util.Set;
@@ -348,9 +347,9 @@ public void putEdge_nodesNotInGraph() {
     assume().that(graphIsMutable()).isTrue();
 
     graphAsMutableGraph.addNode(N1);
-    assertTrue(graphAsMutableGraph.putEdge(N1, N5));
-    assertTrue(graphAsMutableGraph.putEdge(N4, N1));
-    assertTrue(graphAsMutableGraph.putEdge(N2, N3));
+    assertThat(graphAsMutableGraph.putEdge(N1, N5)).isTrue();
+    assertThat(graphAsMutableGraph.putEdge(N4, N1)).isTrue();
+    assertThat(graphAsMutableGraph.putEdge(N2, N3)).isTrue();
     assertThat(graph.nodes()).containsExactly(N1, N5, N4, N2, N3).inOrder();
     assertThat(graph.adjacentNodes(N1)).containsExactly(N4, N5);
     assertThat(graph.adjacentNodes(N2)).containsExactly(N3);

android/guava-tests/test/com/google/common/graph/AbstractStandardUndirectedNetworkTest.java

@@ -20,7 +20,6 @@
 import static com.google.common.truth.Truth.assertThat;
 import static com.google.common.truth.TruthJUnit.assume;
 import static org.junit.Assert.assertThrows;
-import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 import com.google.common.collect.ImmutableSet;
@@ -427,9 +426,9 @@ public void addEdge_parallelEdge_allowsParallelEdges() {
     assume().that(graphIsMutable()).isTrue();
     assume().that(network.allowsParallelEdges()).isTrue();
 
-    assertTrue(networkAsMutableNetwork.addEdge(N1, N2, E12));
-    assertTrue(networkAsMutableNetwork.addEdge(N2, N1, E21));
-    assertTrue(networkAsMutableNetwork.addEdge(N1, N2, E12_A));
+    assertThat(networkAsMutableNetwork.addEdge(N1, N2, E12)).isTrue();
+    assertThat(networkAsMutableNetwork.addEdge(N2, N1, E21)).isTrue();
+    assertThat(networkAsMutableNetwork.addEdge(N1, N2, E12_A)).isTrue();
     assertThat(network.edgesConnecting(N1, N2)).containsExactly(E12, E12_A, E21);
   }
 
@@ -466,9 +465,9 @@ public void addEdge_nodesNotInGraph() {
     assume().that(graphIsMutable()).isTrue();
 
     networkAsMutableNetwork.addNode(N1);
-    assertTrue(networkAsMutableNetwork.addEdge(N1, N5, E15));
-    assertTrue(networkAsMutableNetwork.addEdge(N4, N1, E41));
-    assertTrue(networkAsMutableNetwork.addEdge(N2, N3, E23));
+    assertThat(networkAsMutableNetwork.addEdge(N1, N5, E15)).isTrue();
+    assertThat(networkAsMutableNetwork.addEdge(N4, N1, E41)).isTrue();
+    assertThat(networkAsMutableNetwork.addEdge(N2, N3, E23)).isTrue();
     assertThat(network.nodes()).containsExactly(N1, N5, N4, N2, N3);
     assertThat(network.edges()).containsExactly(E15, E41, E23);
     assertThat(network.edgesConnecting(N1, N5)).containsExactly(E15);
@@ -539,8 +538,8 @@ public void addEdge_parallelSelfLoopEdge_allowsParallelEdges() {
     assume().that(network.allowsSelfLoops()).isTrue();
     assume().that(network.allowsParallelEdges()).isTrue();
 
-    assertTrue(networkAsMutableNetwork.addEdge(N1, N1, E11));
-    assertTrue(networkAsMutableNetwork.addEdge(N1, N1, E11_A));
+    assertThat(networkAsMutableNetwork.addEdge(N1, N1, E11)).isTrue();
+    assertThat(networkAsMutableNetwork.addEdge(N1, N1, E11_A)).isTrue();
     assertThat(network.edgesConnecting(N1, N1)).containsExactly(E11, E11_A);
   }
 

android/guava-tests/test/com/google/common/graph/EndpointPairTest.java

@@ -235,11 +235,13 @@ public void endpointPair_directed_contains() {
     assertThat(edges).doesNotContain(EndpointPair.ordered(N3, N4)); // nodes not in graph
   }
 
+  // We are testing our implementations of methods on Collection.
+  @SuppressWarnings({"CollectionSizeTruth", "CollectionContainsTruth"})
   private static void containsExactlySanityCheck(Collection<?> collection, Object... varargs) {
-    assertThat(collection).hasSize(varargs.length);
+    assertThat(collection.size()).isEqualTo(varargs.length);
     for (Object obj : varargs) {
-      assertThat(collection).contains(obj);
+      assertThat(collection.contains(obj)).isTrue();
     }
-    assertThat(collection).containsExactly(varargs);
+    assertThat(ImmutableList.copyOf(collection.iterator())).containsExactlyElementsIn(varargs);
   }
 }

android/guava-tests/test/com/google/common/graph/ImmutableNetworkTest.java

@@ -34,7 +34,6 @@ public void immutableNetwork() {
     mutableNetwork.addNode("A");
     ImmutableNetwork<String, Integer> immutableNetwork = ImmutableNetwork.copyOf(mutableNetwork);
 
-    assertThat(immutableNetwork.asGraph()).isInstanceOf(ImmutableGraph.class);
     assertThat(immutableNetwork).isNotInstanceOf(MutableNetwork.class);
     assertThat(immutableNetwork).isEqualTo(mutableNetwork);
 

android/guava-tests/test/com/google/common/graph/ImmutableValueGraphTest.java

@@ -35,7 +35,6 @@ public void immutableValueGraph() {
     ImmutableValueGraph<String, Integer> immutableValueGraph =
         ImmutableValueGraph.copyOf(mutableValueGraph);
 
-    assertThat(immutableValueGraph.asGraph()).isInstanceOf(ImmutableGraph.class);
     assertThat(immutableValueGraph).isNotInstanceOf(MutableValueGraph.class);
     assertThat(immutableValueGraph).isEqualTo(mutableValueGraph);
 

android/guava-tests/test/com/google/common/graph/TraverserTest.java

@@ -24,7 +24,6 @@
 import static org.junit.Assert.assertThrows;
 
 import com.google.common.collect.HashMultiset;
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMultimap;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Multiset;
@@ -1213,7 +1212,7 @@ private static ImmutableGraph<Character> createSingleRootGraph() {
   }
 
   private static void assertEqualCharNodes(Iterable<Character> result, String expectedCharacters) {
-    assertThat(ImmutableList.copyOf(result))
+    assertThat(result)
         .containsExactlyElementsIn(Chars.asList(expectedCharacters.toCharArray()))
         .inOrder();
   }