Package com.google.common.truth

Class PrimitiveFloatArraySubject

  • public final class PrimitiveFloatArraySubject
extends Subject
    A Subject for float[].
    Author:
    Christian Gruber (cgruber@israfil.net)

    • Method Detail

      • isEqualTo

        public void isEqualTo​(@Nullable Object expected)
        A check 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), and that unless strictfp is in force even the result of (a + b) + c is sensitive to the JVM's choice of precision for the intermediate result.) 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 expected)
        A check 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 Float.NaN, Float.POSITIVE_INFINITY, or negative, including -0.0f

      • 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), and that unless strictfp is in force even the result of (a + b) + c is sensitive to the JVM's choice of precision for the intermediate result.) 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 final void isEmpty()
        Fails if the array is not empty (i.e. array.length > 0).

      • isNotEmpty

        public final void isNotEmpty()
        Fails if the array is empty (i.e. array.length == 0).

      • hasLength

        public final void hasLength​(int length)
        Fails if the array does not have the given length.
        Throws:
        IllegalArgumentException - if length < 0