Class PrimitiveFloatArraySubject

java.lang.Object
com.google.common.truth.Subject
com.google.common.truth.PrimitiveFloatArraySubject
public final class PrimitiveFloatArraySubject extends Subject
A subject for float[] values.

  • Method Details

    • isEqualTo

      public void isEqualTo(@Nullable Object expected)
      Checks that the actual array and expected are arrays of the same length and type, containing elements such that each element in expected is equal to each element in the actual array, and in the same position, with element equality defined the same way that Arrays.equals(float[], float[]) and Float.equals(Object) define it (which is different to the way that the == operator on primitive float defines it). This method is not recommended when the code under test is doing any kind of arithmetic: use usingTolerance(double) with a suitable tolerance in that case, e.g. assertThat(actualArray).usingTolerance(1.0e-5).containsExactly(expectedArray).inOrder(). (Remember that the exact result of floating point arithmetic is sensitive to apparently trivial changes such as replacing (a + b) + c with a + (b + c).) This method is recommended when the code under test is specified as either copying values without modification from its input or returning well-defined literal or constant values.
      Overrides:
      isEqualTo in class Subject

    • isNotEqualTo

      public void isNotEqualTo(@Nullable Object other)
      Checks that the actual array and expected are not arrays of the same length and type, containing elements such that each element in expected is equal to each element in the actual array, and in the same position, with element equality defined the same way that Arrays.equals(float[], float[]) and Float.equals(Object) define it (which is different to the way that the == operator on primitive float defines it). See isEqualTo(Object) for advice on when exact equality is recommended.
      Overrides:
      isNotEqualTo in class Subject

    • usingTolerance

      public PrimitiveFloatArraySubject.FloatArrayAsIterable usingTolerance(double tolerance)
      Starts a method chain for a check in which the actual values (i.e. the elements of the array under test) are compared to expected elements using a Correspondence which considers values to correspond if they are finite values within tolerance of each other. The check is actually executed by continuing the method chain. For example: 
      
 assertThat(actualFloatArray).usingTolerance(1.0e-5f).contains(3.14159f);
      • It does not consider values to correspond if either value is infinite or NaN.
      • It considers -0.0f to be within any tolerance of 0.0f.
      • The expected values provided later in the chain will be Number instances which will be converted to floats, which may result in a loss of precision for some numeric types.
      • The subsequent methods in the chain may throw a NullPointerException if any expected Number instance is null.
      Parameters:
      tolerance - an inclusive upper bound on the difference between the float values of the actual and expected numbers, which must be a non-negative finite value, i.e. not Double.NaN, Double.POSITIVE_INFINITY, or negative, including -0.0

    • usingExactEquality

      public PrimitiveFloatArraySubject.FloatArrayAsIterable usingExactEquality()
      Starts a method chain for a check in which the actual values (i.e. the elements of the array under test) are compared to expected elements using a Correspondence which considers values to correspond if they are exactly equal, with equality defined by Float.equals(java.lang.Object). This method is not recommended when the code under test is doing any kind of arithmetic: use usingTolerance(double) with a suitable tolerance in that case. (Remember that the exact result of floating point arithmetic is sensitive to apparently trivial changes such as replacing (a + b) + c with a + (b + c).) This method is recommended when the code under test is specified as either copying a value without modification from its input or returning a well-defined literal or constant value. The check is actually executed by continuing the method chain. For example: 
      
 assertThat(actualFloatArray).usingExactEquality().contains(3.14159f);

      For convenience, some subsequent methods accept expected values as Number instances. These numbers must be either of type Float, Integer, or Long, and if they are Integer or Long then their absolute values must not exceed 2^24 which is 16,777,216. (This restriction ensures that the expected values have exact Float representations: using exact equality makes no sense if they do not.)

    • isEmpty

      public void isEmpty()
      Checks that the actual array is empty (i.e., that array.length == 0).

    • isNotEmpty

      public void isNotEmpty()
      Checks that the actual array is not empty (i.e., that array.length > 0).

    • hasLength

      public void hasLength(int length)
      Checks that the actual array has the given length.