com.google.common.truth

Class PrimitiveFloatArraySubject

java.lang.Object

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

com.google.common.truth.AbstractArraySubject<PrimitiveFloatArraySubject,float[]>

com.google.common.truth.PrimitiveFloatArraySubject

public final class PrimitiveFloatArraySubject
extends AbstractArraySubject<PrimitiveFloatArraySubject,float[]>

A Subject to handle testing propositions for float[].

Note: this class deprecates some common methods because the operation of equality and comparison on floating point numbers requires additional specification. Alternative equality tests are provided.

Author:

Christian Gruber ([email protected])

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	PrimitiveFloatArraySubject.TolerantPrimitiveFloatArrayComparison A partially specified proposition about an approximate relationship to a float[] subject using a tolerance.

Field Summary

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

failureStrategy

Method Summary

Modifier and Type	Method and Description
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) 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).
void	isEqualTo(Object expected) Deprecated. use either usingTolerance(someTolerance).containsExactly(someValues).inOrder() or usingExactEquality().containsExactly(someValues).inOrder()
void	isEqualTo(Object expected, float tolerance) Deprecated. use usingTolerance(someTolerance).containsExactly(someValues).inOrder(), noting the different behaviour for non-finite values
void	isNotEqualTo(Object expected) Deprecated. If you really want this, convert the array to a list, possibly using Floats.asList(float...), and do the assertion on that, e.g. assertThat(asList(actualFloatArray)).isNotEqualTo(asList(expectedFloatArray));.
void	isNotEqualTo(Object expectedArray, float tolerance) Deprecated. Write a for loop over the values looking for mismatches (see this implementation for an example)
protected List<Float>	listRepresentation() Returns a List representation suitable for displaying in a string.
protected String	underlyingType()
IterableSubject.UsingCorrespondence<Float,Float>	usingExactEquality() Starts a method chain for a test proposition in which the actual values (i.e.
IterableSubject.UsingCorrespondence<Number,Number>	usingTolerance(float tolerance) Starts a method chain for a test proposition in which the actual values (i.e.

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

actualCustomStringRepresentation, hasLength, isEmpty, isNotEmpty

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

actual, actualAsString, check, equals, fail, fail, fail, failWithBadResults, failWithCustomSubject, failWithoutActual, failWithoutSubject, failWithRawMessage, getDisplaySubject, getSubject, hashCode, internalCustomName, isAnyOf, isIn, isInstanceOf, isNoneOf, isNotIn, isNotInstanceOf, isNotNull, isNotSameAs, isNull, isSameAs, named

Methods inherited from class java.lang.Object

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

Method Detail

underlyingType

protected String underlyingType()

listRepresentation

protected List<Float> listRepresentation()

Description copied from class: AbstractArraySubject

Returns a List representation suitable for displaying in a string.

isEqualTo

@Deprecated
public void isEqualTo(Object expected)

Deprecated. use either usingTolerance(someTolerance).containsExactly(someValues).inOrder() or usingExactEquality().containsExactly(someValues).inOrder()

This form is unsafe for floating point types, and will throw an UnsupportedOperationException.

Overrides:

isEqualTo in class Subject<PrimitiveFloatArraySubject,float[]>

isEqualTo

@Deprecated
public void isEqualTo(Object expected,
                                  float tolerance)

Deprecated. use usingTolerance(someTolerance).containsExactly(someValues).inOrder(), noting the different behaviour for non-finite values

A proposition that the provided float[] is an array of the same length and type, and contains elements such that each element in expected is equal to each element in the subject, and in the same position.

Behaviour for non-finite values (POSITIVE_INFINITY, NEGATIVE_INFINITY, and NaN) is as follows: If the subject and the object of the assertion are the same array, the test will pass. If not (including if one is a clone of the other) then non-finite values are considered not equal so the any non-finite value in either argument will cause the test to fail.

isNotEqualTo

@Deprecated
public void isNotEqualTo(Object expected)

Deprecated. If you really want this, convert the array to a list, possibly using Floats.asList(float...), and do the assertion on that, e.g. assertThat(asList(actualFloatArray)).isNotEqualTo(asList(expectedFloatArray));.

This form is unsafe for floating point types, and will throw an UnsupportedOperationException.

Overrides:

isNotEqualTo in class Subject<PrimitiveFloatArraySubject,float[]>

isNotEqualTo

@Deprecated
public void isNotEqualTo(Object expectedArray,
                                     float tolerance)

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

A proposition that the provided float[] is not an array of the same length or type, or has at least one element that does not pass an equality test within the given tolerance.

Behaviour for non-finite values (POSITIVE_INFINITY, NEGATIVE_INFINITY, and NaN) is as follows: If the subject and the object of the assertion are the same array, the test will fail. If not (including if one is a clone of the other) then non-finite values are considered not equal so the any non-finite value in either argument will cause the test to pass.

hasValuesWithin

public PrimitiveFloatArraySubject.TolerantPrimitiveFloatArrayComparison hasValuesWithin(float tolerance)

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 IterableSubject.UsingCorrespondence<Number,Number> usingTolerance(float tolerance)

Starts a method chain for a test proposition 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 proposition 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 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 Float.NaN, Float.POSITIVE_INFINITY, or negative, including -0.0f

usingExactEquality

public IterableSubject.UsingCorrespondence<Float,Float> usingExactEquality()

Starts a method chain for a test proposition 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(float) 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 proposition is actually executed by continuing the method chain. For example:

   
 assertThat(actualFloatArray).usingExactEquality().contains(3.14159f);

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