SELF
- the "self" type of this assertion class. Please read "Emulating 'self types' using Java Generics to simplify fluent API implementation"
for more details.public abstract class AbstractDoubleAssert<SELF extends AbstractDoubleAssert<SELF>> extends AbstractComparableAssert<SELF,Double> implements FloatingPointNumberAssert<SELF,Double>
Double
s.actual, info, myself, throwUnsupportedExceptionOnEquals
Constructor and Description |
---|
AbstractDoubleAssert(double actual,
Class<?> selfType) |
AbstractDoubleAssert(Double actual,
Class<?> selfType) |
Modifier and Type | Method and 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 value.
|
SELF |
isCloseTo(Double expected,
Offset<Double> offset)
Verifies that the actual number is close to the given one within the given offset value.
|
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,
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 number is close to the given one within the given offset value.
|
SELF |
isEqualTo(Double expected,
Offset<Double> offset)
Verifies that the actual number is close to the given one within the given offset value.
|
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.
|
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.
|
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,
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 the given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
|
SELF |
usingComparator(Comparator<? super Double> customComparator,
String customComparatorDescription)
Use the given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
|
SELF |
usingDefaultComparator()
Revert to standard comparison for the incoming assertion checks.
|
inBinary, inHexadecimal, isEqualByComparingTo, isGreaterThan, isGreaterThanOrEqualTo, isLessThan, isLessThanOrEqualTo, isNotEqualByComparingTo
as, as, extracting, extracting, extracting, getComparatorsByType, hasAllNullFieldsOrProperties, hasAllNullFieldsOrPropertiesExcept, hasFieldOrProperty, hasFieldOrPropertyWithValue, hasNoNullFieldsOrProperties, hasNoNullFieldsOrPropertiesExcept, isEqualToComparingFieldByField, isEqualToComparingFieldByFieldRecursively, isEqualToComparingOnlyGivenFields, isEqualToIgnoringGivenFields, isEqualToIgnoringNullFields, newObjectAssert, returns, usingComparatorForFields, usingComparatorForType, usingRecursiveComparison, usingRecursiveComparison
asList, asString, describedAs, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, equals, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, hasToString, is, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, newListAssertInstance, overridingErrorMessage, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, setCustomRepresentation, throwAssertionError, withFailMessage, withRepresentation, withThreadDumpOnError
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 AbstractDoubleAssert<SELF>,Double>
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 AbstractDoubleAssert<SELF>,Double>
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 AbstractDoubleAssert<SELF>,Double>
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 AbstractDoubleAssert<SELF>,Double>
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 AbstractDoubleAssert<SELF>,Double>
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 AbstractDoubleAssert<SELF>,Double>
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 AbstractDoubleAssert<SELF>,Double>
this
assertion object.public SELF isCloseTo(double expected, Offset<Double> offset)
When abs(actual - expected) == offset value, the assertion:
Assertions.within(Double)
or Assertions.offset(Double)
Assertions.byLessThan(Double)
or Offset.strictOffset(Number)
Breaking change since 2.9.0/3.9.0: using Assertions.byLessThan(Double)
implies a strict comparison,
use Assertions.within(Double)
to get the old behavior.
Examples:
// assertions succeed
assertThat(8.1).isCloseTo(8.0, within(0.2));
assertThat(8.1).isCloseTo(8.0, offset(0.2)); // alias of within
assertThat(8.1).isCloseTo(8.0, byLessThan(0.2)); // strict
// assertions succeed when the difference == offset value ...
assertThat(8.1).isCloseTo(8.0, within(0.1));
assertThat(8.1).isCloseTo(8.0, offset(0.1));
// ... except when using byLessThan which implies a strict comparison
assertThat(0.1).isCloseTo(0.0, byLessThan(0.1)); // strict => fail
// this assertion also fails
assertThat(8.1).isCloseTo(8.0, within(0.001));
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)
When abs(actual - expected) == offset value, the assertion:
Assertions.byLessThan(Double)
or Offset.strictOffset(Number)
Assertions.within(Double)
or Assertions.offset(Double)
Breaking change since 2.9.0/3.9.0: using Assertions.byLessThan(Double)
implies a strict comparison,
use Assertions.within(Double)
to get the old behavior.
Example:
// assertions succeed
assertThat(8.1).isNotCloseTo(8.0, byLessThan(0.01));
assertThat(8.1).isNotCloseTo(8.0, within(0.01));
assertThat(8.1).isNotCloseTo(8.0, offset(0.01));
// diff == offset but isNotCloseTo succeeds as we use byLessThan
assertThat(0.1).isNotCloseTo(0.0, byLessThan(0.1));
// assertions fail
assertThat(0.1).isNotCloseTo(0.0, within(0.1));
assertThat(0.1).isNotCloseTo(0.0, offset(0.1));
assertThat(8.1).isNotCloseTo(8.0, within(0.2));
assertThat(8.1).isNotCloseTo(8.0, offset(0.2));
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)
When abs(actual - expected) == offset value, the assertion:
Assertions.within(Double)
or Assertions.offset(Double)
Assertions.byLessThan(Double)
or Offset.strictOffset(Number)
Breaking change since 2.9.0/3.9.0: using Assertions.byLessThan(Double)
implies a strict comparison,
use Assertions.within(Double)
to get the old behavior.
Examples:
// assertions succeed
assertThat(8.1).isCloseTo(8.0, within(0.2));
assertThat(8.1).isCloseTo(8.0, offset(0.2)); // alias of within
assertThat(8.1).isCloseTo(8.0, byLessThan(0.2)); // strict
// assertions succeed when the difference == offset value ...
assertThat(8.1).isCloseTo(8.0, within(0.1));
assertThat(8.1).isCloseTo(8.0, offset(0.1));
// ... except when using byLessThan which implies a strict comparison
assertThat(0.1).isCloseTo(0.0, byLessThan(0.1)); // strict => fail
// this assertion also fails
assertThat(8.1).isCloseTo(8.0, within(0.001));
isCloseTo
in interface FloatingPointNumberAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
isCloseTo
in interface NumberAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
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)
When abs(actual - expected) == offset value, the assertion:
Assertions.byLessThan(Double)
or Offset.strictOffset(Number)
Assertions.within(Double)
or Assertions.offset(Double)
Breaking change since 2.9.0/3.9.0: using Assertions.byLessThan(Double)
implies a strict comparison,
use Assertions.within(Double)
to get the old behavior.
Example:
// assertions succeed
assertThat(8.1).isNotCloseTo(8.0, byLessThan(0.01));
assertThat(8.1).isNotCloseTo(8.0, within(0.01));
assertThat(8.1).isNotCloseTo(8.0, offset(0.01));
// diff == offset but isNotCloseTo succeeds as we use byLessThan
assertThat(0.1).isNotCloseTo(0.0, byLessThan(0.1));
// assertions fail
assertThat(8.1).isNotCloseTo(8.0, within(0.1));
assertThat(8.1).isNotCloseTo(8.0, offset(0.1));
assertThat(8.1).isNotCloseTo(8.0, within(0.2));
assertThat(8.1).isNotCloseTo(8.0, offset(0.2));
assertThat(8.1).isNotCloseTo(8.0, byLessThan(0.2));
isNotCloseTo
in interface FloatingPointNumberAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
isNotCloseTo
in interface NumberAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
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 AbstractDoubleAssert<SELF>,Double>
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 AbstractDoubleAssert<SELF>,Double>
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)
This assertion is the same as FloatingPointNumberAssert.isCloseTo(Number, Offset)
.
When abs(actual - expected) == offset value, the assertion:
Assertions.within(Double)
or Assertions.offset(Double)
Assertions.byLessThan(Double)
or Offset.strictOffset(Number)
Examples:
// assertions will pass
assertThat(8.1).isEqualTo(8.0, within(0.2));
assertThat(8.1).isEqualTo(8.0, offset(0.2)); // alias of within
assertThat(8.1).isEqualTo(8.0, byLessThan(0.2)); // strict
// assertions succeed when the difference == offset value ...
assertThat(8.1).isEqualTo(8.0, within(0.1));
assertThat(8.1).isEqualTo(8.0, offset(0.1));
// ... except when using byLessThan which is strict
assertThat(8.1).isEqualTo(8.0, byLessThan(0.1)); // strict => fail
// this assertions also fails
assertThat(8.1).isEqualTo(8.0, within(0.001));
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)
This assertion is the same as isCloseTo(double, Offset)
.
When abs(actual - expected) == offset value, the assertion:
Assertions.within(Double)
or Assertions.offset(Double)
Assertions.byLessThan(Double)
or Offset.strictOffset(Number)
Examples:
// assertions will pass
assertThat(8.1).isEqualTo(8.0, within(0.2));
assertThat(8.1).isEqualTo(8.0, offset(0.2)); // alias of within
assertThat(8.1).isEqualTo(8.0, byLessThan(0.2)); // strict
// assertions succeed when the difference == offset value ...
assertThat(8.1).isEqualTo(8.0, within(0.1));
assertThat(8.1).isEqualTo(8.0, offset(0.1));
// ... except when using byLessThan which implies a strict comparison
assertThat(0.1).isEqualTo(0.0, byLessThan(0.1)); // strict => fail
// this assertion also fails
assertThat(8.1).isEqualTo(8.0, within(0.001));
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)
Example:
// assertions will pass
assertThat(1d).isBetween(-1d, 2d);
assertThat(1d).isBetween(1d, 2d);
assertThat(1d).isBetween(0d, 1d);
// assertion will fail
assertThat(1d).isBetween(2d, 3d);
isBetween
in interface ComparableAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
isBetween
in interface NumberAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
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)
Example:
// assertion will pass
assertThat(1d).isStrictlyBetween(-1d, 2d);
// assertions will fail
assertThat(1d).isStrictlyBetween(1d, 2d);
assertThat(1d).isStrictlyBetween(0d, 1d);
assertThat(1d).isStrictlyBetween(2d, 3d);
isStrictlyBetween
in interface ComparableAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
isStrictlyBetween
in interface NumberAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
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
The custom comparator is bound to assertion instance, meaning that if a new assertion instance is created, the default comparison strategy will be used.
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 AbstractDoubleAssert<SELF>,Double>
usingComparator
in class AbstractComparableAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
customComparator
- the comparator to use for the incoming assertion checks.this
assertion object.public SELF usingComparator(Comparator<? super Double> customComparator, String customComparatorDescription)
AbstractAssert
The custom comparator is bound to assertion instance, meaning that if a new assertion instance is created, the default comparison strategy will be used.
Examples :
// frodo and sam are instances of Character with Hobbit race (obviously :).
// raceComparator implements Comparator<Character>
assertThat(frodo).usingComparator(raceComparator, "Hobbit Race Comparator").isEqualTo(sam);
usingComparator
in interface Assert<SELF extends AbstractDoubleAssert<SELF>,Double>
usingComparator
in class AbstractComparableAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
customComparator
- the comparator to use for the incoming assertion checks.customComparatorDescription
- comparator description to be used in assertion error messagesthis
assertion object.public SELF usingDefaultComparator()
AbstractAssert
This method should be used to disable a custom comparison strategy set by calling usingComparator
.
usingDefaultComparator
in interface Assert<SELF extends AbstractDoubleAssert<SELF>,Double>
usingDefaultComparator
in class AbstractComparableAssert<SELF extends AbstractDoubleAssert<SELF>,Double>
this
assertion object.Copyright © 2014–2019 AssertJ. All rights reserved.