SELF
- the "self" type of this assertion class. Please read "Emulating 'self types' using Java Generics to simplify fluent API implementation"
for more details.Assert<SELF,ACTUAL>
, ComparableAssert<SELF,Double>
, Descriptable<SELF>
, ExtensionPoints<SELF,ACTUAL>
, FloatingPointNumberAssert<SELF,Double>
, NumberAssert<SELF,ACTUAL>
DoubleAssert
public abstract class AbstractDoubleAssert<SELF extends AbstractDoubleAssert<SELF>> extends AbstractComparableAssert<SELF,Double> implements FloatingPointNumberAssert<SELF,Double>
Double
s.actual, info, myself
Constructor | Description |
---|---|
AbstractDoubleAssert(double actual,
Class<?> selfType) |
|
AbstractDoubleAssert(Double actual,
Class<?> selfType) |
Modifier and Type | Method | Description |
---|---|---|
SELF |
isBetween(Double start,
Double end) |
Verifies that the actual value is in [start, end] range (start included, end included).
|
SELF |
isCloseTo(double expected,
Offset<Double> offset) |
Verifies that the actual number is close to the given one within the given offset.
If difference is equal to offset value, assertion is considered valid. |
SELF |
isCloseTo(double expected,
Percentage percentage) |
Verifies that the actual number is close to the given one within the given percentage.
If difference is equal to the percentage value, assertion is considered valid. |
SELF |
isCloseTo(Double expected,
Offset<Double> offset) |
Verifies that the actual number is close to the given one within the given offset.
If difference is equal to offset value, assertion is considered valid. |
SELF |
isCloseTo(Double expected,
Percentage percentage) |
Verifies that the actual number is close to the given one within the given percentage.
If difference is equal to the percentage value, assertion is considered valid. |
SELF |
isEqualTo(double expected) |
Verifies that the actual value is equal to the given one.
|
SELF |
isEqualTo(double expected,
Offset<Double> offset) |
Verifies that the actual value is close to the given one by less than the given offset.
If difference is equal to offset value, assertion is considered valid. |
SELF |
isEqualTo(Double expected,
Offset<Double> offset) |
Verifies that the actual value is close to the given one by less than the given offset.
If difference is equal to offset value, assertion is considered valid. |
SELF |
isGreaterThan(double other) |
Verifies that the actual value is greater than the given one.
|
SELF |
isGreaterThanOrEqualTo(double other) |
Verifies that the actual value is greater than or equal to the given one.
|
SELF |
isLessThan(double other) |
Verifies that the actual value is less than the given one.
|
SELF |
isLessThanOrEqualTo(double other) |
Verifies that the actual value is less than or equal to the given one.
|
SELF |
isNaN() |
Verifies that the actual value is equal to
NaN . |
SELF |
isNegative() |
Verifies that the actual value is negative.
|
SELF |
isNotCloseTo(double expected,
Offset<Double> offset) |
Verifies that the actual number is not close to the given one by less than the given offset.
If the difference is equal to the offset value, the assertion fails. |
SELF |
isNotCloseTo(double expected,
Percentage percentage) |
Verifies that the actual number is not close to the given one within the given percentage.
If difference is equal to the percentage value, the assertion fails. |
SELF |
isNotCloseTo(Double expected,
Offset<Double> offset) |
Verifies that the actual number is close to the given one by less than the given offset.
If the difference is equal to the offset value, the assertion fails. |
SELF |
isNotCloseTo(Double expected,
Percentage percentage) |
Verifies that the actual number is close to the given one within the given percentage.
If difference is equal to the percentage value, the assertion fails. |
SELF |
isNotEqualTo(double other) |
Verifies that the actual value is not equal to the given one.
|
SELF |
isNotNaN() |
Verifies that the actual value is not equal to
NaN . |
SELF |
isNotNegative() |
Verifies that the actual value is non negative (positive or equal zero).
|
SELF |
isNotPositive() |
Verifies that the actual value is non positive (negative or equal zero).
|
SELF |
isNotZero() |
Verifies that the actual value is not equal to zero.
|
SELF |
isOne() |
Verifies that the actual value is equal to one.
|
SELF |
isPositive() |
Verifies that the actual value is positive.
|
SELF |
isStrictlyBetween(Double start,
Double end) |
Verifies that the actual value is in ]start, end[ range (start excluded, end excluded).
|
SELF |
isZero() |
Verifies that the actual value is equal to zero.
|
SELF |
usingComparator(Comparator<? super Double> customComparator) |
Use given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
|
SELF |
usingDefaultComparator() |
Revert to standard comparison for incoming assertion checks.
|
asList, asString, describedAs, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, equals, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasToString, is, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, overridingErrorMessage, satisfies, setCustomRepresentation, throwAssertionError, withFailMessage, withRepresentation, withThreadDumpOnError
inBinary, inHexadecimal, isEqualByComparingTo, isGreaterThan, isGreaterThanOrEqualTo, isLessThan, isLessThanOrEqualTo, isNotEqualByComparingTo
as, as, defaultTypeComparators, extracting, extracting, hasFieldOrProperty, hasFieldOrPropertyWithValue, hasNoNullFieldsOrProperties, hasNoNullFieldsOrPropertiesExcept, isEqualToComparingFieldByField, isEqualToComparingFieldByFieldRecursively, isEqualToComparingOnlyGivenFields, isEqualToIgnoringGivenFields, isEqualToIgnoringNullFields, returns, usingComparatorForFields, usingComparatorForType
public AbstractDoubleAssert(double actual, Class<?> selfType)
public SELF isNaN()
NaN
.
Example:
// assertions will pass
assertThat(Double.NaN).isNaN();
assertThat(0.0 / 0.0).isNaN();
assertThat(0.0F * Float.POSITIVE_INFINITY).isNaN();
// assertions will fail
assertThat(1.0).isNaN();
assertThat(-1.0F).isNaN();
isNaN
in interface FloatingPointNumberAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
public SELF isNotNaN()
NaN
.
Example:
// assertions will pass
assertThat(1.0).isNotNaN();
assertThat(-1.0F).isNotNaN();
// assertions will fail
assertThat(Double.NaN).isNotNaN();
assertThat(0.0 / 0.0).isNotNaN();
assertThat(0.0F * Float.POSITIVE_INFINITY).isNotNaN();
isNotNaN
in interface FloatingPointNumberAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
public SELF isZero()
Although 0.0 == -0.0
(primitives), Double(-0.0)
is not zero as Double.doubleToRawLongBits(0.0) == Double.doubleToRawLongBits(-0.0)
is false.
Example:
// assertions will pass
assertThat(0.0).isZero();
assertThat(-0.0).isZero();
// assertions will fail
assertThat(new Double(-0.0)).isZero();
assertThat(3.142).isZero();
isZero
in interface NumberAssert<SELF extends FloatingPointNumberAssert<SELF,ACTUAL>,ACTUAL extends Number>
AssertionError
- if the actual value is null
.AssertionError
- if the actual value is not equal to zero.public SELF isNotZero()
Although 0.0 == -0.0
(primitives), Double(-0.0)
is not zero as Double.doubleToRawLongBits(0.0) == Double.doubleToRawLongBits(-0.0)
is false.
Example:
// assertions will pass
assertThat(3.142).isNotZero();
assertThat(new Double(-0.0)).isNotZero();
// assertions will fail
assertThat(0.0).isNotZero();
assertThat(new Double(0.0)).isNotZero();
assertThat(-0.0).isNotZero();
isNotZero
in interface NumberAssert<SELF extends FloatingPointNumberAssert<SELF,ACTUAL>,ACTUAL extends Number>
AssertionError
- if the actual value is null
.AssertionError
- if the actual value is equal to zero.public SELF isOne()
Example:
// assertions will pass
assertThat(1).isOne();
assertThat(1.0).isOne();
// assertions will fail
assertThat(42).isOne();
assertThat(3.142).isOne();
isOne
in interface NumberAssert<SELF extends FloatingPointNumberAssert<SELF,ACTUAL>,ACTUAL extends Number>
public SELF isPositive()
Example:
// assertions will pass
assertThat(42).isPositive();
assertThat(3.142).isPositive();
// assertions will fail
assertThat(0).isPositive();
assertThat(-42).isPositive();
isPositive
in interface NumberAssert<SELF extends FloatingPointNumberAssert<SELF,ACTUAL>,ACTUAL extends Number>
public SELF isNegative()
Example:
// assertions will pass
assertThat(-42).isNegative();
assertThat(-3.124).isNegative();
// assertions will fail
assertThat(0).isNegative();
assertThat(42).isNegative();
isNegative
in interface NumberAssert<SELF extends FloatingPointNumberAssert<SELF,ACTUAL>,ACTUAL extends Number>
public SELF isNotNegative()
Example:
// assertions will pass
assertThat(42).isNotNegative();
assertThat(0).isNotNegative();
// assertions will fail
assertThat(-42).isNotNegative();
assertThat(-3.124).isNotNegative();
isNotNegative
in interface NumberAssert<SELF extends FloatingPointNumberAssert<SELF,ACTUAL>,ACTUAL extends Number>
this
assertion object.public SELF isNotPositive()
Example:
// assertions will pass
assertThat(-42).isNotPositive();
assertThat(0).isNotPositive();
// assertions will fail
assertThat(42).isNotPositive();
assertThat(3.124).isNotPositive();
isNotPositive
in interface NumberAssert<SELF extends FloatingPointNumberAssert<SELF,ACTUAL>,ACTUAL extends Number>
this
assertion object.public SELF isCloseTo(double expected, Offset<Double> offset)
Example:
// assertion will pass
assertThat(8.1).isCloseTo(8.0, within(0.2));
// you can use offset if you prefer
assertThat(8.1).isCloseTo(8.0, offset(0.2));
// if difference is exactly equals to 0.1, it's ok
assertThat(8.1).isCloseTo(8.0, within(0.1));
// assertion will fail
assertThat(8.1).isCloseTo(8.0, within(0.01));
expected
- the given number to compare the actual value to.offset
- the given positive offset.this
assertion object.NullPointerException
- if the given offset is null
.NullPointerException
- if the expected number is null
.AssertionError
- if the actual value is not close to the given one.public SELF isNotCloseTo(double expected, Offset<Double> offset)
Example:
// assertion will pass
assertThat(8.1).isNotCloseTo(8.0, byLessThan(0.01));
// you can use offset if you prefer
assertThat(8.1).isNotCloseTo(8.0, offset(0.01));
// assertions will fail
assertThat(8.1).isNotCloseTo(8.0, byLessThan(0.1));
assertThat(8.1).isNotCloseTo(8.0, byLessThan(0.2));
expected
- the given number to compare the actual value to.offset
- the given positive offset.this
assertion object.NullPointerException
- if the given offset is null
.NullPointerException
- if the expected number is null
.AssertionError
- if the actual value is close to the given one.Assertions.byLessThan(Double)
public SELF isCloseTo(Double expected, Offset<Double> offset)
Example:
// assertion will pass
assertThat(8.1).isCloseTo(Double.valueOf(8.0), within(0.2));
// you can use offset if you prefer
assertThat(8.1).isCloseTo(Double.valueOf(8.0), offset(0.2));
// if difference is exactly equals to 0.1, it's ok
assertThat(8.1).isCloseTo(Double.valueOf(8.0), within(0.1));
// assertion will fail
assertThat(8.1).isCloseTo(Double.valueOf(8.0), within(0.01));
isCloseTo
in interface FloatingPointNumberAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
isCloseTo
in interface NumberAssert<SELF extends FloatingPointNumberAssert<SELF,ACTUAL>,ACTUAL extends Number>
expected
- the given number to compare the actual value to.offset
- the given positive offset.this
assertion object.NullPointerException
- if the given offset is null
.NullPointerException
- if the expected number is null
.AssertionError
- if the actual value is not close to the given one.public SELF isNotCloseTo(Double expected, Offset<Double> offset)
Example:
// assertion will pass
assertThat(8.1).isNotCloseTo(Double.valueOf(8.0), byLessThan(0.01));
// you can use offset if you prefer
assertThat(8.1).isNotCloseTo(Double.valueOf(8.0), offset(0.01));
// assertions will fail
assertThat(8.1).isNotCloseTo(Double.valueOf(8.0), byLessThan(0.1));
assertThat(8.1).isNotCloseTo(Double.valueOf(8.0), byLessThan(0.2));
isNotCloseTo
in interface FloatingPointNumberAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
isNotCloseTo
in interface NumberAssert<SELF extends FloatingPointNumberAssert<SELF,ACTUAL>,ACTUAL extends Number>
expected
- the given number to compare the actual value to.offset
- the given positive offset.this
assertion object.NullPointerException
- if the given offset is null
.NullPointerException
- if the expected number is null
.AssertionError
- if the actual value is close to the given one.Assertions.byLessThan(Double)
public SELF isCloseTo(Double expected, Percentage percentage)
Example with double:
// assertions will pass:
assertThat(11.0).isCloseTo(Double.valueOf(10.0), withinPercentage(20d));
// if difference is exactly equals to the computed offset (1.0), it's ok
assertThat(11.0).isCloseTo(Double.valueOf(10.0), withinPercentage(10d));
// assertion will fail
assertThat(11.0).isCloseTo(Double.valueOf(10.0), withinPercentage(5d));
isCloseTo
in interface NumberAssert<SELF extends FloatingPointNumberAssert<SELF,ACTUAL>,ACTUAL extends Number>
expected
- the given number to compare the actual value to.percentage
- the given positive percentage.this
assertion object.NullPointerException
- if the given offset is null
.NullPointerException
- if the expected number is null
.AssertionError
- if the actual value is not close to the given one.public SELF isNotCloseTo(Double expected, Percentage percentage)
Example with double:
// assertion will pass:
assertThat(11.0).isNotCloseTo(Double.valueOf(10.0), withinPercentage(5d));
// assertions will fail
assertThat(11.0).isNotCloseTo(Double.valueOf(10.0), withinPercentage(10d));
assertThat(11.0).isNotCloseTo(Double.valueOf(10.0), withinPercentage(20d));
isNotCloseTo
in interface NumberAssert<SELF extends FloatingPointNumberAssert<SELF,ACTUAL>,ACTUAL extends Number>
expected
- the given number to compare the actual value to.percentage
- the given positive percentage.this
assertion object.NullPointerException
- if the given offset is null
.NullPointerException
- if the expected number is null
.AssertionError
- if the actual value is close to the given one.public SELF isCloseTo(double expected, Percentage percentage)
Example with double:
// assertions will pass:
assertThat(11.0).isCloseTo(10.0, withinPercentage(20d));
// if difference is exactly equals to the computed offset (1.0), it's ok
assertThat(11.0).isCloseTo(10.0, withinPercentage(10d));
// assertion will fail
assertThat(11.0).isCloseTo(10.0, withinPercentage(5d));
expected
- the given number to compare the actual value to.percentage
- the given positive percentage.this
assertion object.NullPointerException
- if the given offset is null
.NullPointerException
- if the expected number is null
.AssertionError
- if the actual value is not close to the given one.public SELF isNotCloseTo(double expected, Percentage percentage)
Example with double:
// assertion will pass:
assertThat(11.0).isNotCloseTo(10.0, withinPercentage(5d));
// assertions will fail
assertThat(11.0).isNotCloseTo(10.0, withinPercentage(10d));
assertThat(11.0).isNotCloseTo(10.0, withinPercentage(20d));
expected
- the given number to compare the actual value to.percentage
- the given positive percentage.this
assertion object.NullPointerException
- if the given offset is null
.NullPointerException
- if the expected number is null
.AssertionError
- if the actual value is close to the given one.public SELF isEqualTo(double expected)
Example:
// assertions will pass:
assertThat(1.0).isEqualTo(1.0);
assertThat(1D).isEqualTo(1.0);
// assertions will fail:
assertThat(0.0).isEqualTo(1.0);
assertThat(-1.0).isEqualTo(1.0);
expected
- the given value to compare the actual value to.this
assertion object.AssertionError
- if the actual value is null
.AssertionError
- if the actual value is not equal to the given one.public SELF isEqualTo(Double expected, Offset<Double> offset)
Example with double:
// assertion will pass:
assertThat(8.1).isEqualTo(new Double(8.0), offset(0.2));
// if difference is exactly equals to the offset (0.1), it's ok
assertThat(8.1).isEqualTo(new Double(8.0), offset(0.1));
// within is an alias of offset
assertThat(8.1).isEqualTo(new Double(8.0), within(0.1));
// assertion will fail
assertThat(8.1).isEqualTo(new Double(8.0), offset(0.01));
isEqualTo
in interface FloatingPointNumberAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
expected
- the given value to compare the actual value to.offset
- the given positive offset.this
assertion object.public SELF isEqualTo(double expected, Offset<Double> offset)
Example with double:
// assertion will pass:
assertThat(8.1).isEqualTo(8.0, offset(0.2));
// if difference is exactly equals to the offset (0.1), it's ok
assertThat(8.1).isEqualTo(8.0, offset(0.1));
// within is an alias of offset
assertThat(8.1).isEqualTo(8.0, within(0.1));
// assertion will fail
assertThat(8.1).isEqualTo(8.0, offset(0.01));
expected
- the given value to compare the actual value to.offset
- the given positive offset.this
assertion object.NullPointerException
- if the given offset is null
.NullPointerException
- if the expected number is null
.AssertionError
- if the actual value is not equal to the given one.public SELF isNotEqualTo(double other)
Example:
// assertions will pass:
assertThat(0.0).isNotEqualTo(1.0);
assertThat(-1.0).isNotEqualTo(1.0);
// assertions will fail:
assertThat(1.0).isNotEqualTo(1.0);
assertThat(1D).isNotEqualTo(1.0);
other
- the given value to compare the actual value to.this
assertion object.AssertionError
- if the actual value is null
.AssertionError
- if the actual value is equal to the given one.public SELF isLessThan(double other)
Example:
// assertion will pass:
assertThat(1.0).isLessThan(2.0);
// assertions will fail:
assertThat(2.0).isLessThan(1.0);
assertThat(1.0).isLessThan(1.0);
other
- the given value to compare the actual value to.this
assertion object.AssertionError
- if the actual value is null
.AssertionError
- if the actual value is equal to or greater than the given one.public SELF isLessThanOrEqualTo(double other)
Example:
// assertions will pass:
assertThat(-1.0).isLessThanOrEqualTo(1.0);
assertThat(1.0).isLessThanOrEqualTo(1.0);
// assertion will fail:
assertThat(2.0).isLessThanOrEqualTo(1.0);
other
- the given value to compare the actual value to.this
assertion object.AssertionError
- if the actual value is null
.AssertionError
- if the actual value is greater than the given one.public SELF isGreaterThan(double other)
Example:
// assertion will pass:
assertThat(2.0).isGreaterThan(1.0);
// assertions will fail:
assertThat(1.0).isGreaterThan(1.0);
assertThat(1.0).isGreaterThan(2.0);
other
- the given value to compare the actual value to.this
assertion object.AssertionError
- if the actual value is null
.AssertionError
- if the actual value is equal to or less than the given one.public SELF isGreaterThanOrEqualTo(double other)
Example:
// assertions will pass:
assertThat(2.0).isGreaterThanOrEqualTo(1.0);
assertThat(1.0).isGreaterThanOrEqualTo(1.0);
// assertion will fail:
assertThat(1.0).isGreaterThanOrEqualTo(2.0);
other
- the given value to compare the actual value to.this
assertion object.AssertionError
- if the actual value is null
.AssertionError
- if the actual value is less than the given one.public SELF isBetween(Double start, Double end)
// assertions succeed
assertThat('b').isBetween('a', 'c');
assertThat('a').isBetween('a', 'b');
assertThat('b').isBetween('a', 'b');
// assertions fail
assertThat('a').isBetween('b', 'c');
assertThat('c').isBetween('a', 'b');
isBetween
in interface ComparableAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
isBetween
in interface NumberAssert<SELF extends FloatingPointNumberAssert<SELF,ACTUAL>,ACTUAL extends Number>
isBetween
in class AbstractComparableAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
start
- the start value (inclusive), expected not to be null.end
- the end value (inclusive), expected not to be null.public SELF isStrictlyBetween(Double start, Double end)
// assertion succeeds
assertThat('b').isStrictlyBetween('a', 'c');
// assertions fail
assertThat('d').isStrictlyBetween('a', 'c');
assertThat('a').isStrictlyBetween('b', 'd');
assertThat('a').isStrictlyBetween('a', 'b');
assertThat('b').isStrictlyBetween('a', 'b');
isStrictlyBetween
in interface ComparableAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
isStrictlyBetween
in interface NumberAssert<SELF extends FloatingPointNumberAssert<SELF,ACTUAL>,ACTUAL extends Number>
isStrictlyBetween
in class AbstractComparableAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
start
- the start value (exclusive), expected not to be null.end
- the end value (exclusive), expected not to be null.public SELF usingComparator(Comparator<? super Double> customComparator)
AbstractAssert
Custom comparator is bound to assertion instance, meaning that if a new assertion is created, it will use default comparison strategy. Examples :
// frodo and sam are instances of Character with Hobbit race (obviously :).
// raceComparator implements Comparator<Character>
assertThat(frodo).usingComparator(raceComparator).isEqualTo(sam);
usingComparator
in interface Assert<SELF extends AbstractObjectAssert<SELF,ACTUAL>,ACTUAL>
usingComparator
in class AbstractComparableAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
customComparator
- the comparator to use for incoming assertion checks.this
assertion object.public SELF usingDefaultComparator()
AbstractAssert
This method should be used to disable a custom comparison strategy set by calling
Assert.usingComparator(Comparator)
.
usingDefaultComparator
in interface Assert<SELF extends AbstractObjectAssert<SELF,ACTUAL>,ACTUAL>
usingDefaultComparator
in class AbstractComparableAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
this
assertion object.Copyright © 2014–2019. All rights reserved.