Refer to the actual value as "the actual value," not as "the subject."

(#203)

I considered instead using phrases like "the string," we [sometimes already do](https://github.com/google/truth/blob/0337b58cf7ca53d89d9badb56d7467c8576f8aa4/core/src/main/java/com/google/common/truth/StringSubject.java#L99). But I worried that that wasn't always immediately clear about whether we're talking about the actual value or some parameter of the assertion method (which is an expected value or similar). Not that I cared about this _enough_ to go back and change existing occurrences....

This CL probably covers all remaining occurrences in core Truth. I haven't looked at our extensions or our tests.

RELNOTES=n/a
PiperOrigin-RevId: 766689205

Author: cpovirk

core/src/main/java/com/google/common/truth/BigDecimalSubject.java

@@ -23,7 +23,7 @@
 import org.jspecify.annotations.Nullable;
 
 /**
- * Propositions for {@link BigDecimal} typed subjects.
+ * Propositions for {@link BigDecimal} values.
  *
  * @author Kurt Alfred Kluever
  */
@@ -36,7 +36,7 @@ private BigDecimalSubject(FailureMetadata metadata, @Nullable BigDecimal actual)
   }
 
   /**
-   * Fails if the subject's value is not equal to the value of the given {@link BigDecimal}. (i.e.,
+   * Fails if the actual value is not equal to the value of the given {@link BigDecimal}. (i.e.,
    * fails if {@code actual.comparesTo(expected) != 0}).
    *
    * <p><b>Note:</b> The scale of the BigDecimal is ignored. If you want to compare the values and
@@ -47,8 +47,8 @@ public void isEqualToIgnoringScale(BigDecimal expected) {
   }
 
   /**
-   * Fails if the subject's value is not equal to the value of the {@link BigDecimal} created from
-   * the expected string (i.e., fails if {@code actual.comparesTo(new BigDecimal(expected)) != 0}).
+   * Fails if the actual value is not equal to the value of the {@link BigDecimal} created from the
+   * expected string (i.e., fails if {@code actual.comparesTo(new BigDecimal(expected)) != 0}).
    *
    * <p><b>Note:</b> The scale of the BigDecimal is ignored. If you want to compare the values and
    * the scales, use {@link #isEqualTo(Object)}.
@@ -58,8 +58,8 @@ public void isEqualToIgnoringScale(String expected) {
   }
 
   /**
-   * Fails if the subject's value is not equal to the value of the {@link BigDecimal} created from
-   * the expected {@code long} (i.e., fails if {@code actual.comparesTo(new BigDecimal(expected)) !=
+   * Fails if the actual value is not equal to the value of the {@link BigDecimal} created from the
+   * expected {@code long} (i.e., fails if {@code actual.comparesTo(new BigDecimal(expected)) !=
    * 0}).
    *
    * <p><b>Note:</b> The scale of the BigDecimal is ignored. If you want to compare the values and
@@ -70,7 +70,7 @@ public void isEqualToIgnoringScale(long expected) {
   }
 
   /**
-   * Fails if the subject's value and scale is not equal to the given {@link BigDecimal}.
+   * Fails if the actual value and scale is not equal to the given {@link BigDecimal}.
    *
    * <p><b>Note:</b> If you only want to compare the values of the BigDecimals and not their scales,
    * use {@link #isEqualToIgnoringScale(BigDecimal)} instead.
@@ -81,7 +81,7 @@ public void isEqualTo(@Nullable Object expected) {
   }
 
   /**
-   * Fails if the subject is not equivalent to the given value according to {@link
+   * Fails if the actual value is not equivalent to the given value according to {@link
    * Comparable#compareTo}, (i.e., fails if {@code a.comparesTo(b) != 0}). This method behaves
    * identically to (the more clearly named) {@link #isEqualToIgnoringScale(BigDecimal)}.
    *

core/src/main/java/com/google/common/truth/BooleanSubject.java

@@ -20,7 +20,7 @@
 import org.jspecify.annotations.Nullable;
 
 /**
- * Propositions for boolean subjects.
+ * Propositions for boolean values.
  *
  * @author Christian Gruber ([email protected])
  */
@@ -32,7 +32,7 @@ private BooleanSubject(FailureMetadata metadata, @Nullable Boolean actual) {
     this.actual = actual;
   }
 
-  /** Fails if the subject is false or {@code null}. */
+  /** Fails if the actual value is false or {@code null}. */
   public void isTrue() {
     if (actual == null) {
       isEqualTo(true); // fails
@@ -41,7 +41,7 @@ public void isTrue() {
     }
   }
 
-  /** Fails if the subject is true or {@code null}. */
+  /** Fails if the actual value is true or {@code null}. */
   public void isFalse() {
     if (actual == null) {
       isEqualTo(false); // fails

core/src/main/java/com/google/common/truth/ClassSubject.java

@@ -21,7 +21,7 @@
 import org.jspecify.annotations.Nullable;
 
 /**
- * Propositions for {@link Class} subjects.
+ * Propositions for {@link Class} values.
  *
  * @author Kurt Alfred Kluever
  */

core/src/main/java/com/google/common/truth/ComparableSubject.java

@@ -21,7 +21,7 @@
 import org.jspecify.annotations.Nullable;
 
 /**
- * Propositions for {@link Comparable} typed subjects.
+ * Propositions for {@link Comparable} values.
  *
  * @author Kurt Alfred Kluever
  * @param <T> the type of the object being tested by this {@code ComparableSubject}
@@ -52,22 +52,22 @@ private ComparableSubject(FailureMetadata metadata, @Nullable Object actual) {
     this.actual = actual;
   }
 
-  /** Checks that the subject is in {@code range}. */
+  /** Checks that the actual value is in {@code range}. */
   public final void isIn(Range<T> range) {
     if (!range.contains(actualAsT())) {
       failWithActual("expected to be in range", range);
     }
   }
 
-  /** Checks that the subject is <i>not</i> in {@code range}. */
+  /** Checks that the actual value is <i>not</i> in {@code range}. */
   public final void isNotIn(Range<T> range) {
     if (range.contains(actualAsT())) {
       failWithActual("expected not to be in range", range);
     }
   }
 
   /**
-   * Checks that the subject is equivalent to {@code other} according to {@link
+   * Checks that the actual value is equivalent to {@code other} according to {@link
    * Comparable#compareTo}, (i.e., checks that {@code a.comparesTo(b) == 0}).
    *
    * <p><b>Note:</b> Do not use this method for checking object equality. Instead, use {@link
@@ -80,9 +80,9 @@ public void isEquivalentAccordingToCompareTo(@Nullable T expected) {
   }
 
   /**
-   * Checks that the subject is greater than {@code other}.
+   * Checks that the actual value is greater than {@code other}.
    *
-   * <p>To check that the subject is greater than <i>or equal to</i> {@code other}, use {@link
+   * <p>To check that the actual value is greater than <i>or equal to</i> {@code other}, use {@link
    * #isAtLeast}.
    */
   public final void isGreaterThan(@Nullable T other) {
@@ -92,9 +92,9 @@ public final void isGreaterThan(@Nullable T other) {
   }
 
   /**
-   * Checks that the subject is less than {@code other}.
+   * Checks that the actual value is less than {@code other}.
    *
-   * <p>To check that the subject is less than <i>or equal to</i> {@code other}, use {@link
+   * <p>To check that the actual value is less than <i>or equal to</i> {@code other}, use {@link
    * #isAtMost}.
    */
   public final void isLessThan(@Nullable T other) {
@@ -104,9 +104,9 @@ public final void isLessThan(@Nullable T other) {
   }
 
   /**
-   * Checks that the subject is less than or equal to {@code other}.
+   * Checks that the actual value is less than or equal to {@code other}.
    *
-   * <p>To check that the subject is <i>strictly</i> less than {@code other}, use {@link
+   * <p>To check that the actual value is <i>strictly</i> less than {@code other}, use {@link
    * #isLessThan}.
    */
   public final void isAtMost(@Nullable T other) {
@@ -116,9 +116,9 @@ public final void isAtMost(@Nullable T other) {
   }
 
   /**
-   * Checks that the subject is greater than or equal to {@code other}.
+   * Checks that the actual value is greater than or equal to {@code other}.
    *
-   * <p>To check that the subject is <i>strictly</i> greater than {@code other}, use {@link
+   * <p>To check that the actual value is <i>strictly</i> greater than {@code other}, use {@link
    * #isGreaterThan}.
    */
   public final void isAtLeast(@Nullable T other) {

core/src/main/java/com/google/common/truth/DoubleSubject.java

@@ -27,7 +27,7 @@
 import org.jspecify.annotations.Nullable;
 
 /**
- * Propositions for {@link Double} subjects.
+ * Propositions for {@link Double} values.
  *
  * @author Kurt Alfred Kluever
  */
@@ -40,18 +40,18 @@ private DoubleSubject(FailureMetadata metadata, @Nullable Double actual) {
   }
 
   /**
-   * A partially specified check about an approximate relationship to a {@code double} subject using
-   * a tolerance.
+   * A partially specified check about an approximate relationship to a {@code double} value using a
+   * tolerance.
    */
   public abstract static class TolerantDoubleComparison {
 
     // Prevent subclassing outside of this class
     private TolerantDoubleComparison() {}
 
     /**
-     * Fails if the subject was expected to be within the tolerance of the given value but was not
-     * <i>or</i> if it was expected <i>not</i> to be within the tolerance but was. The subject and
-     * tolerance are specified earlier in the fluent call chain.
+     * Fails if the actual value was expected to be within the tolerance of the given value but was
+     * not <i>or</i> if it was expected <i>not</i> to be within the tolerance but was. The actual
+     * value and tolerance are specified earlier in the fluent call chain.
      */
     public abstract void of(double expected);
 
@@ -79,13 +79,13 @@ public int hashCode() {
   }
 
   /**
-   * Prepares for a check that the subject is a finite number within the given tolerance of an
+   * Prepares for a check that the actual value is a finite number within the given tolerance of an
    * expected value that will be provided in the next call in the fluent chain.
    *
-   * <p>The check will fail if either the subject or the object is {@link Double#POSITIVE_INFINITY},
-   * {@link Double#NEGATIVE_INFINITY}, or {@link Double#NaN}. To check for those values, use {@link
-   * #isPositiveInfinity}, {@link #isNegativeInfinity}, {@link #isNaN}, or (with more generality)
-   * {@link #isEqualTo}.
+   * <p>The check will fail if either the actual value or the expected value is {@link
+   * Double#POSITIVE_INFINITY}, {@link Double#NEGATIVE_INFINITY}, or {@link Double#NaN}. To check
+   * for those values, use {@link #isPositiveInfinity}, {@link #isNegativeInfinity}, {@link #isNaN},
+   * or (with more generality) {@link #isEqualTo}.
    *
    * <p>The check will pass if both values are zero, even if one is {@code 0.0} and the other is
    * {@code -0.0}. Use {@link #isEqualTo} to assert that a value is exactly {@code 0.0} or that it
@@ -96,9 +96,9 @@ public int hashCode() {
    * and {@code -0.0}). See the documentation on {@link #isEqualTo} for advice on when exact
    * equality assertions are appropriate.
    *
-   * @param tolerance an inclusive upper bound on the difference between the subject and object
-   *     allowed by the check, which must be a non-negative finite value, i.e. not {@link
-   *     Double#NaN}, {@link Double#POSITIVE_INFINITY}, or negative, including {@code -0.0}
+   * @param tolerance an inclusive upper bound on the difference between the actual value and
+   *     expected value allowed by the check, which must be a non-negative finite value, i.e. not
+   *     {@link Double#NaN}, {@link Double#POSITIVE_INFINITY}, or negative, including {@code -0.0}
    */
   public TolerantDoubleComparison isWithin(double tolerance) {
     return new TolerantDoubleComparison() {
@@ -120,12 +120,12 @@ public void of(double expected) {
   }
 
   /**
-   * Prepares for a check that the subject is a finite number not within the given tolerance of an
-   * expected value that will be provided in the next call in the fluent chain.
+   * Prepares for a check that the actual value is a finite number not within the given tolerance of
+   * an expected value that will be provided in the next call in the fluent chain.
    *
-   * <p>The check will fail if either the subject or the object is {@link Double#POSITIVE_INFINITY},
-   * {@link Double#NEGATIVE_INFINITY}, or {@link Double#NaN}. See {@link #isFinite}, {@link
-   * #isNotNaN}, or {@link #isNotEqualTo} for checks with other behaviours.
+   * <p>The check will fail if either the actual value or the expected value is {@link
+   * Double#POSITIVE_INFINITY}, {@link Double#NEGATIVE_INFINITY}, or {@link Double#NaN}. See {@link
+   * #isFinite}, {@link #isNotNaN}, or {@link #isNotEqualTo} for checks with other behaviours.
    *
    * <p>The check will fail if both values are zero, even if one is {@code 0.0} and the other is
    * {@code -0.0}. Use {@link #isNotEqualTo} for a test which fails for a value of exactly zero with
@@ -135,9 +135,9 @@ public void of(double expected) {
    * but sometimes {@link #isNotEqualTo} is preferable (note the different behaviours around
    * non-finite values and {@code -0.0}).
    *
-   * @param tolerance an exclusive lower bound on the difference between the subject and object
-   *     allowed by the check, which must be a non-negative finite value, i.e. not {@code
-   *     Double.NaN}, {@code Double.POSITIVE_INFINITY}, or negative, including {@code -0.0}
+   * @param tolerance an exclusive lower bound on the difference between the actual value and
+   *     expected value allowed by the check, which must be a non-negative finite value, i.e. not
+   *     {@code Double.NaN}, {@code Double.POSITIVE_INFINITY}, or negative, including {@code -0.0}
    */
   public TolerantDoubleComparison isNotWithin(double tolerance) {
     return new TolerantDoubleComparison() {
@@ -159,7 +159,7 @@ public void of(double expected) {
   }
 
   /**
-   * Asserts that the subject is exactly equal to the given value, with equality defined as by
+   * Asserts that the actual value is exactly equal to the given value, with equality defined as by
    * {@code Double#equals}. This method is <i>not</i> recommended when the code under test is doing
    * any kind of arithmetic: use {@link #isWithin} with a suitable tolerance in that case. (Remember
    * that the exact result of floating point arithmetic is sensitive to apparently trivial changes
@@ -179,9 +179,9 @@ public void isEqualTo(@Nullable Object other) {
   }
 
   /**
-   * Asserts that the subject is not exactly equal to the given value, with equality defined as by
-   * {@code Double#equals}. See {@link #isEqualTo} for advice on when exact equality is recommended.
-   * Use {@link #isNotWithin} for an assertion with a tolerance.
+   * Asserts that the actual value is not exactly equal to the given value, with equality defined as
+   * by {@code Double#equals}. See {@link #isEqualTo} for advice on when exact equality is
+   * recommended. Use {@link #isNotWithin} for an assertion with a tolerance.
    *
    * <p><b>Note:</b> The assertion {@code isNotEqualTo(0.0)} passes for {@code -0.0}, and vice
    * versa. For an assertion that fails for either {@code 0.0} or {@code -0.0}, use {@link
@@ -201,15 +201,15 @@ public void isEquivalentAccordingToCompareTo(@Nullable Double other) {
     super.isEquivalentAccordingToCompareTo(other);
   }
 
-  /** Asserts that the subject is zero (i.e. it is either {@code 0.0} or {@code -0.0}). */
+  /** Asserts that the actual value is zero (i.e. it is either {@code 0.0} or {@code -0.0}). */
   public void isZero() {
     if (actual == null || actual != 0.0) {
       failWithActual(simpleFact("expected zero"));
     }
   }
 
   /**
-   * Asserts that the subject is a non-null value other than zero (i.e. it is not {@code 0.0},
+   * Asserts that the actual value is a non-null value other than zero (i.e. it is not {@code 0.0},
    * {@code -0.0} or {@code null}).
    */
   public void isNonZero() {
@@ -220,23 +220,23 @@ public void isNonZero() {
     }
   }
 
-  /** Asserts that the subject is {@link Double#POSITIVE_INFINITY}. */
+  /** Asserts that the actual value is {@link Double#POSITIVE_INFINITY}. */
   public void isPositiveInfinity() {
     isEqualTo(Double.POSITIVE_INFINITY);
   }
 
-  /** Asserts that the subject is {@link Double#NEGATIVE_INFINITY}. */
+  /** Asserts that the actual value is {@link Double#NEGATIVE_INFINITY}. */
   public void isNegativeInfinity() {
     isEqualTo(Double.NEGATIVE_INFINITY);
   }
 
-  /** Asserts that the subject is {@link Double#NaN}. */
+  /** Asserts that the actual value is {@link Double#NaN}. */
   public void isNaN() {
     isEqualTo(NaN);
   }
 
   /**
-   * Asserts that the subject is finite, i.e. not {@link Double#POSITIVE_INFINITY}, {@link
+   * Asserts that the actual value is finite, i.e. not {@link Double#POSITIVE_INFINITY}, {@link
    * Double#NEGATIVE_INFINITY}, or {@link Double#NaN}.
    */
   public void isFinite() {
@@ -246,7 +246,7 @@ public void isFinite() {
   }
 
   /**
-   * Asserts that the subject is a non-null value other than {@link Double#NaN} (but it may be
+   * Asserts that the actual value is a non-null value other than {@link Double#NaN} (but it may be
    * {@link Double#POSITIVE_INFINITY} or {@link Double#NEGATIVE_INFINITY}).
    */
   public void isNotNaN() {
@@ -258,39 +258,39 @@ public void isNotNaN() {
   }
 
   /**
-   * Checks that the subject is greater than {@code other}.
+   * Checks that the actual value is greater than {@code other}.
    *
-   * <p>To check that the subject is greater than <i>or equal to</i> {@code other}, use {@link
+   * <p>To check that the actual value is greater than <i>or equal to</i> {@code other}, use {@link
    * #isAtLeast}.
    */
   public void isGreaterThan(int other) {
     isGreaterThan((double) other);
   }
 
   /**
-   * Checks that the subject is less than {@code other}.
+   * Checks that the actual value is less than {@code other}.
    *
-   * <p>To check that the subject is less than <i>or equal to</i> {@code other}, use {@link
+   * <p>To check that the actual value is less than <i>or equal to</i> {@code other}, use {@link
    * #isAtMost} .
    */
   public void isLessThan(int other) {
     isLessThan((double) other);
   }
 
   /**
-   * Checks that the subject is less than or equal to {@code other}.
+   * Checks that the actual value is less than or equal to {@code other}.
    *
-   * <p>To check that the subject is <i>strictly</i> less than {@code other}, use {@link
+   * <p>To check that the actual value is <i>strictly</i> less than {@code other}, use {@link
    * #isLessThan}.
    */
   public void isAtMost(int other) {
     isAtMost((double) other);
   }
 
   /**
-   * Checks that the subject is greater than or equal to {@code other}.
+   * Checks that the actual value is greater than or equal to {@code other}.
    *
-   * <p>To check that the subject is <i>strictly</i> greater than {@code other}, use {@link
+   * <p>To check that the actual value is <i>strictly</i> greater than {@code other}, use {@link
    * #isGreaterThan}.
    */
   public void isAtLeast(int other) {