com.google.common.truth

Class PrimitiveFloatArraySubject

java.lang.Object

com.google.common.truth.Subject<S,T>

com.google.common.truth.PrimitiveFloatArraySubject

public final class PrimitiveFloatArraySubject
extends Subject<S,T>

A Subject for float[].

Author:

Christian Gruber (cgruber@israfil.net)

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	PrimitiveFloatArraySubject.FloatArrayAsIterable A partially specified check for doing assertions on the array similar to the assertions supported for Iterable subjects, in which the elements of the array under test are compared to expected elements using either exact or tolerant float equality: see usingExactEquality() and usingTolerance(double).
static class	PrimitiveFloatArraySubject.TolerantPrimitiveFloatArrayComparison A partially specified check about an approximate relationship to a float[] subject using a tolerance.

Nested classes/interfaces inherited from class com.google.common.truth.Subject

Subject.Factory<SubjectT extends Subject<SubjectT,ActualT>,ActualT>

Method Summary

Modifier and Type	Method and Description
void	hasLength(int length) Fails if the array does not have the given length.
PrimitiveFloatArraySubject.TolerantPrimitiveFloatArrayComparison	hasValuesNotWithin(float tolerance) Deprecated. Write a for loop over the values looking for mismatches (see this implementation for an example)
PrimitiveFloatArraySubject.TolerantPrimitiveFloatArrayComparison	hasValuesWithin(float tolerance) Deprecated. Use usingTolerance(double), e.g. assertThat(floatArray).usingTolerance(1e-5).containsExactly(1.2f, 3.4f, 5.6f).inOrder();
void	isEmpty() Fails if the array is not empty (i.e.
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(float[], float[]) and Float.equals(Object) define it (which is different to the way that the == operator on primitive float defines it).
void	isNotEmpty() Fails if the array is empty (i.e.
void	isNotEqualTo(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).
PrimitiveFloatArraySubject.FloatArrayAsIterable	usingExactEquality() Starts a method chain for a check in which the actual values (i.e.
PrimitiveFloatArraySubject.FloatArrayAsIterable	usingTolerance(double tolerance) Starts a method chain for a check in which the actual values (i.e.

Methods inherited from class com.google.common.truth.Subject

actual, actualAsString, actualCustomStringRepresentation, check, check, equals, fail, fail, fail, failComparing, failComparing, failWithActual, failWithActual, failWithBadResults, failWithCustomSubject, failWithoutActual, failWithoutActual, failWithoutSubject, failWithRawMessage, failWithRawMessageAndCause, getSubject, hashCode, ignoreCheck, internalCustomName, isAnyOf, isIn, isInstanceOf, isNoneOf, isNotIn, isNotInstanceOf, isNotNull, isNotSameAs, isNull, isSameAs, named, toString

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

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(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.

• It considers Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, and Float.NaN to be equal to themselves (contrast with usingTolerance(0.0) which does not).
• It does not consider -0.0f to be equal to 0.0f (contrast with usingTolerance(0.0) which does).

Overrides:

isEqualTo in class Subject<PrimitiveFloatArraySubject,float[]>

isNotEqualTo

public void isNotEqualTo(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.

• It considers Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, and Float.NaN to be equal to themselves.
• It does not consider -0.0 to be equal to 0.0.

Overrides:

isNotEqualTo in class Subject<PrimitiveFloatArraySubject,float[]>

hasValuesWithin

@Deprecated
public PrimitiveFloatArraySubject.TolerantPrimitiveFloatArrayComparison hasValuesWithin(float tolerance)

Deprecated. Use usingTolerance(double), e.g. assertThat(floatArray).usingTolerance(1e-5).containsExactly(1.2f, 3.4f, 5.6f).inOrder();

Prepares for a check that the subject and object are arrays both (a) of the same length, and (b) where the values at all corresponding positions in each array are finite values within tolerance of each other, that is assertThat(actual[i]).isWithin(tolerance).of(expected[i]) passes for all i (see the isWithin assertion for floats).

The check will fail if any value in either the subject array or the object array is Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, or Float.NaN.

Parameters:

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 Float.NaN, Float.POSITIVE_INFINITY, or negative, including -0.0f

hasValuesNotWithin

@Deprecated
public PrimitiveFloatArraySubject.TolerantPrimitiveFloatArrayComparison hasValuesNotWithin(float tolerance)

Deprecated. Write a for loop over the values looking for mismatches (see this implementation for an example)

Prepares for a check that the subject and object are arrays either (a) of the different lengths, or (b) of the same length but where the values at at least one corresponding position in each array are finite values not within tolerance of each other, that is assertThat(actual[i]).isNotWithin(tolerance).of(expected[i]) passes for at least one i (see the isNotWithin assertion for floats).

In the case (b), a pair of subject and object values will not cause the test to pass if either of them is Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, or Float.NaN.

Parameters:

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 Float.NaN, Float.POSITIVE_INFINITY, or negative, including -0.0f

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.)

• It considers Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, and Float.NaN to be equal to themselves (contrast with usingTolerance(0.0) which does not).
• It does not consider -0.0f to be equal to 0.0f (contrast with usingTolerance(0.0) which does).
• The subsequent methods in the chain may throw a NullPointerException if any expected Float instance is null.

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