com.google.common.truth

Class DoubleSubject

java.lang.Object

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

com.google.common.truth.ComparableSubject<DoubleSubject,Double>

com.google.common.truth.DoubleSubject

public final class DoubleSubject
extends ComparableSubject<DoubleSubject,Double>

Propositions for Double subjects.

Author:

Kurt Alfred Kluever

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	DoubleSubject.TolerantDoubleComparison A partially specified check about an approximate relationship to a double 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	isEqualTo(Double other) Asserts that the subject is exactly equal to the given value, with equality defined as by Double#equals.
void	isEquivalentAccordingToCompareTo(Double other) Deprecated. Use isWithin(double) or isEqualTo(java.lang.Double) instead (see documentation for advice).
void	isFinite() Asserts that the subject is finite, i.e.
void	isNaN() Asserts that the subject is Double.NaN.
void	isNegativeInfinity() Asserts that the subject is Double.NEGATIVE_INFINITY.
void	isNonZero() Asserts that the subject is a non-null value other than zero (i.e.
void	isNotEqualTo(Double other) Asserts that the subject is not exactly equal to the given value, with equality defined as by Double#equals.
void	isNotNaN() Asserts that the subject is a non-null value other than Double.NaN (but it may be Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY).
DoubleSubject.TolerantDoubleComparison	isNotWithin(double tolerance) Prepares for a check that the subject is a finite number not within the given tolerance of an expected value that will be provided in the next call in the fluent chain.
void	isPositiveInfinity() Asserts that the subject is Double.POSITIVE_INFINITY.
DoubleSubject.TolerantDoubleComparison	isWithin(double tolerance) Prepares for a check that the subject is a finite number within the given tolerance of an expected value that will be provided in the next call in the fluent chain.
void	isZero() Asserts that the subject is zero (i.e.

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

comparesEqualTo, isAtLeast, isAtMost, isGreaterThan, isIn, isLessThan, isNotIn

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, isEqualTo, isIn, isInstanceOf, isNoneOf, isNotEqualTo, 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

isWithin

public DoubleSubject.TolerantDoubleComparison isWithin(double tolerance)

Prepares for a check that the subject is a finite number within the given tolerance of an expected value that will be provided in the next call in the fluent chain.

The check will fail if either the subject or the object is Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, or Double.NaN. To check for those values, use isPositiveInfinity(), isNegativeInfinity(), isNaN(), or (with more generality) isEqualTo(java.lang.Double).

The check will pass if both values are zero, even if one is 0.0 and the other is -0.0. Use #isEqualTo to assert that a value is exactly 0.0 or that it is exactly -0.0.

You can use a tolerance of 0.0 to assert the exact equality of finite doubles, but often isEqualTo(java.lang.Double) is preferable (note the different behaviours around non-finite values and -0.0). See the documentation on isEqualTo(java.lang.Double) for advice on when exact equality assertions are appropriate.

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

isNotWithin

public DoubleSubject.TolerantDoubleComparison isNotWithin(double tolerance)

Prepares for a check that the subject is a finite number not within the given tolerance of an expected value that will be provided in the next call in the fluent chain.

The check will fail if either the subject or the object is Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, or Double.NaN. See isFinite(), isNotNaN(), or isNotEqualTo(java.lang.Double) for checks with other behaviours.

The check will fail if both values are zero, even if one is 0.0 and the other is -0.0. Use #isNotEqualTo for a test which fails for a value of exactly zero with one sign but passes for zero with the opposite sign.

You can use a tolerance of 0.0 to assert the exact non-equality of finite doubles, but sometimes isNotEqualTo(java.lang.Double) is preferable (note the different behaviours around non-finite values and -0.0).

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

isEqualTo

public final void isEqualTo(@NullableDecl
                            Double other)

Asserts that the subject is exactly equal to the given value, with equality defined as by Double#equals. This method is not recommended when the code under test is doing any kind of arithmetic: use isWithin(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.

Note: The assertion isEqualTo(0.0) fails for an input of -0.0, and vice versa. For an assertion that passes for either 0.0 or -0.0, use isZero().

isNotEqualTo

public final void isNotEqualTo(@NullableDecl
                               Double other)

Asserts that the subject is not exactly equal to the given value, with equality defined as by Double#equals. See isEqualTo(java.lang.Double) for advice on when exact equality is recommended. Use isNotWithin(double) for an assertion with a tolerance.

Note: The assertion isNotEqualTo(0.0) passes for -0.0, and vice versa. For an assertion that fails for either 0.0 or -0.0, use isNonZero().

isEquivalentAccordingToCompareTo

@Deprecated
public final void isEquivalentAccordingToCompareTo(Double other)

Deprecated. Use isWithin(double) or isEqualTo(java.lang.Double) instead (see documentation for advice).

Description copied from class: ComparableSubject

Checks that the subject is equivalent to other according to Comparable.compareTo(T), (i.e., checks that a.comparesTo(b) == 0).

Note: Do not use this method for checking object equality. Instead, use Subject.isEqualTo(Object).

Overrides:

isEquivalentAccordingToCompareTo in class ComparableSubject<DoubleSubject,Double>

isZero

public final void isZero()

Asserts that the subject is zero (i.e. it is either 0.0 or -0.0).

isNonZero

public final void isNonZero()

Asserts that the subject is a non-null value other than zero (i.e. it is not 0.0, -0.0 or null).

isPositiveInfinity

public final void isPositiveInfinity()

Asserts that the subject is Double.POSITIVE_INFINITY.

isNegativeInfinity

public final void isNegativeInfinity()

Asserts that the subject is Double.NEGATIVE_INFINITY.

isNaN

public final void isNaN()

Asserts that the subject is Double.NaN.

isFinite

public final void isFinite()

Asserts that the subject is finite, i.e. not Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, or Double.NaN.

isNotNaN

public final void isNotNaN()

Asserts that the subject is a non-null value other than Double.NaN (but it may be Double.POSITIVE_INFINITY or Double.NEGATIVE_INFINITY).