Package com.google.common.truth

Class PrimitiveDoubleArraySubject

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

    • Method Detail

      • isEqualTo

        public void isEqualTo​(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(double[], double[]) and Double.equals(Object) define it (which is different to the way that the == operator on primitive double 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-10).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

      • usingTolerance

        public PrimitiveDoubleArraySubject.DoubleArrayAsIterable 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(actualDoubleArray).usingTolerance(1.0e-5).contains(3.14159);
        • It does not consider values to correspond if either value is infinite or NaN.
        • It considers -0.0 to be within any tolerance of 0.0.
        • The expected values provided later in the chain will be Number instances which will be converted to doubles, 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 double 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 PrimitiveDoubleArraySubject.DoubleArrayAsIterable 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 Double.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(actualDoubleArray).usingExactEquality().contains(3.14159);

        For convenience, some subsequent methods accept expected values as Number instances. These numbers must be either of type Double, Float, Integer, or Long, and if they are Long then their absolute values must not exceed 2^53 which is just over 9e15. (This restriction ensures that the expected values have exact Double 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