Migrate off the legacy (stateful, JUnit-specific) ExpectFailure API to the modern (lambda-based) API.

RELNOTES=n/a
PiperOrigin-RevId: 733335585

Author: cpovirk

core/pom.xml

@@ -128,11 +128,32 @@
       </plugin>
       <plugin>
         <artifactId>maven-surefire-plugin</artifactId>
-        <configuration>
-          <excludes>
-            <exclude>**/*GwtTest.java</exclude>
-          </excludes>
-        </configuration>
+        <executions>
+          <execution>
+            <id>default-test</id>
+            <configuration>
+              <excludes>
+                <exclude>**/ActualValueInferenceTest.java</exclude>
+                <exclude>**/*GwtTest.java</exclude>
+              </excludes>
+              <systemPropertyVariables>
+                <!-- Avoid automatically generating "value of" lines based on bytecode: We use one set of tests across multiple environments in our testing inside Google, and most of those environments (e.g., Android, J2CL) don't support "value of" lines. Thus, our tests are simplest if we disable "value of" lines altogether. -->
+                <com.google.common.truth.disable_infer_description>true</com.google.common.truth.disable_infer_description>
+              </systemPropertyVariables>
+            </configuration>
+          </execution>
+          <execution>
+            <id>actualvalueinference-test</id>
+            <configuration>
+              <includes>
+                <include>**/ActualValueInferenceTest.java</include>
+              </includes>
+            </configuration>
+            <goals>
+              <goal>test</goal>
+            </goals>
+          </execution>
+        </executions>
       </plugin>
       <plugin>
         <groupId>org.codehaus.mojo</groupId>

core/src/test/java/com/google/common/truth/BaseSubjectTestCase.java

@@ -19,19 +19,15 @@
 
 /** Base class for truth subject tests to extend. */
 abstract class BaseSubjectTestCase extends PlatformBaseSubjectTestCase {
-  final void assertFailureKeys(String... keys) {
-    assertThatFailure().factKeys().containsExactlyElementsIn(keys).inOrder();
+  static void assertFailureKeys(AssertionError e, String... keys) {
+    assertThat(e).factKeys().containsExactlyElementsIn(keys).inOrder();
   }
 
-  final void assertFailureValue(String key, String value) {
-    assertThatFailure().factValue(key).isEqualTo(value);
+  static void assertFailureValue(AssertionError e, String key, String value) {
+    assertThat(e).factValue(key).isEqualTo(value);
   }
 
-  final void assertFailureValueIndexed(String key, int index, String value) {
-    assertThatFailure().factValue(key, index).isEqualTo(value);
-  }
-
-  final TruthFailureSubject assertThatFailure() {
-    return assertThat(expectFailure.getFailure());
+  static void assertFailureValueIndexed(AssertionError e, String key, int index, String value) {
+    assertThat(e).factValue(key, index).isEqualTo(value);
   }
 }

core/src/test/java/com/google/common/truth/BigDecimalSubjectTest.java

@@ -15,6 +15,7 @@
  */
 package com.google.common.truth;
 
+import static com.google.common.truth.ExpectFailure.expectFailure;
 import static com.google.common.truth.Truth.assertThat;
 import static java.math.BigDecimal.TEN;
 
@@ -47,28 +48,32 @@ public void isEquivalentAccordingToCompareTo() {
   public void isEqualToIgnoringScale_bigDecimal() {
     assertThat(TEN).isEqualToIgnoringScale(TEN);
     assertThat(TEN).isEqualToIgnoringScale(new BigDecimal(10));
-    expectFailureWhenTestingThat(TEN).isEqualToIgnoringScale(new BigDecimal(3));
-    assertFailureKeys("expected", "but was", "(scale is ignored)");
-    assertFailureValue("expected", "3");
-    assertFailureValue("but was", "10");
+    AssertionError e =
+        expectFailure(
+            whenTesting -> whenTesting.that(TEN).isEqualToIgnoringScale(new BigDecimal(3)));
+    assertFailureKeys(e, "expected", "but was", "(scale is ignored)");
+    assertFailureValue(e, "expected", "3");
+    assertFailureValue(e, "but was", "10");
   }
 
   @Test
   public void isEqualToIgnoringScale_int() {
     assertThat(TEN).isEqualToIgnoringScale(10);
-    expectFailureWhenTestingThat(TEN).isEqualToIgnoringScale(3);
-    assertFailureKeys("expected", "but was", "(scale is ignored)");
-    assertFailureValue("expected", "3");
-    assertFailureValue("but was", "10");
+    AssertionError e =
+        expectFailure(whenTesting -> whenTesting.that(TEN).isEqualToIgnoringScale(3));
+    assertFailureKeys(e, "expected", "but was", "(scale is ignored)");
+    assertFailureValue(e, "expected", "3");
+    assertFailureValue(e, "but was", "10");
   }
 
   @Test
   public void isEqualToIgnoringScale_long() {
     assertThat(TEN).isEqualToIgnoringScale(10L);
-    expectFailureWhenTestingThat(TEN).isEqualToIgnoringScale(3L);
-    assertFailureKeys("expected", "but was", "(scale is ignored)");
-    assertFailureValue("expected", "3");
-    assertFailureValue("but was", "10");
+    AssertionError e =
+        expectFailure(whenTesting -> whenTesting.that(TEN).isEqualToIgnoringScale(3L));
+    assertFailureKeys(e, "expected", "but was", "(scale is ignored)");
+    assertFailureValue(e, "expected", "3");
+    assertFailureValue(e, "but was", "10");
   }
 
   @Test
@@ -77,10 +82,11 @@ public void isEqualToIgnoringScale_string() {
     assertThat(TEN).isEqualToIgnoringScale("10.");
     assertThat(TEN).isEqualToIgnoringScale("10.0");
     assertThat(TEN).isEqualToIgnoringScale("10.00");
-    expectFailureWhenTestingThat(TEN).isEqualToIgnoringScale("3");
-    assertFailureKeys("expected", "but was", "(scale is ignored)");
-    assertFailureValue("expected", "3");
-    assertFailureValue("but was", "10");
+    AssertionError e =
+        expectFailure(whenTesting -> whenTesting.that(TEN).isEqualToIgnoringScale("3"));
+    assertFailureKeys(e, "expected", "but was", "(scale is ignored)");
+    assertFailureValue(e, "expected", "3");
+    assertFailureValue(e, "but was", "10");
   }
 
   @Test
@@ -90,13 +96,10 @@ public void isEqualToIgnoringScale_stringWithDecimals() {
     assertThat(tenFour).isEqualToIgnoringScale("10.4");
     assertThat(tenFour).isEqualToIgnoringScale("10.40");
     assertThat(tenFour).isEqualToIgnoringScale("10.400");
-    expectFailureWhenTestingThat(tenFour).isEqualToIgnoringScale("3.4");
-    assertFailureKeys("expected", "but was", "(scale is ignored)");
-    assertFailureValue("expected", "3.4");
-    assertFailureValue("but was", "10.4");
-  }
-
-  private BigDecimalSubject expectFailureWhenTestingThat(BigDecimal actual) {
-    return expectFailure.whenTesting().that(actual);
+    AssertionError e =
+        expectFailure(whenTesting -> whenTesting.that(tenFour).isEqualToIgnoringScale("3.4"));
+    assertFailureKeys(e, "expected", "but was", "(scale is ignored)");
+    assertFailureValue(e, "expected", "3.4");
+    assertFailureValue(e, "but was", "10.4");
   }
 }

core/src/test/java/com/google/common/truth/BooleanSubjectTest.java

@@ -15,6 +15,7 @@
  */
 package com.google.common.truth;
 
+import static com.google.common.truth.ExpectFailure.expectFailure;
 import static com.google.common.truth.Truth.assertThat;
 
 import org.junit.Test;
@@ -36,24 +37,24 @@ public void isTrue() {
 
   @Test
   public void nullIsTrueFailing() {
-    expectFailureWhenTestingThat(null).isTrue();
-    assertFailureKeys("expected", "but was");
-    assertFailureValue("expected", "true");
-    assertFailureValue("but was", "null");
+    AssertionError e = expectFailure(whenTesting -> whenTesting.that((Boolean) null).isTrue());
+    assertFailureKeys(e, "expected", "but was");
+    assertFailureValue(e, "expected", "true");
+    assertFailureValue(e, "but was", "null");
   }
 
   @Test
   public void nullIsFalseFailing() {
-    expectFailureWhenTestingThat(null).isFalse();
-    assertFailureKeys("expected", "but was");
-    assertFailureValue("expected", "false");
-    assertFailureValue("but was", "null");
+    AssertionError e = expectFailure(whenTesting -> whenTesting.that((Boolean) null).isFalse());
+    assertFailureKeys(e, "expected", "but was");
+    assertFailureValue(e, "expected", "false");
+    assertFailureValue(e, "but was", "null");
   }
 
   @Test
   public void isTrueFailing() {
-    expectFailureWhenTestingThat(false).isTrue();
-    assertFailureKeys("expected to be true");
+    AssertionError e = expectFailure(whenTesting -> whenTesting.that(false).isTrue());
+    assertFailureKeys(e, "expected to be true");
   }
 
   @Test
@@ -63,11 +64,7 @@ public void isFalse() {
 
   @Test
   public void isFalseFailing() {
-    expectFailureWhenTestingThat(true).isFalse();
-    assertFailureKeys("expected to be false");
-  }
-
-  private BooleanSubject expectFailureWhenTestingThat(Boolean actual) {
-    return expectFailure.whenTesting().that(actual);
+    AssertionError e = expectFailure(whenTesting -> whenTesting.that(true).isFalse());
+    assertFailureKeys(e, "expected to be false");
   }
 }