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,Float>
, Descriptable<SELF>
, ExtensionPoints<SELF,ACTUAL>
, FloatingPointNumberAssert<SELF,Float>
, NumberAssert<SELF,ACTUAL>
FloatAssert
public abstract class AbstractFloatAssert<SELF extends AbstractFloatAssert<SELF>> extends AbstractComparableAssert<SELF,Float> implements FloatingPointNumberAssert<SELF,Float>
Float
s.actual, info, myself
Constructor | Description |
---|---|
AbstractFloatAssert(float actual,
Class<?> selfType) |
|
AbstractFloatAssert(Float actual,
Class<?> selfType) |
Modifier and Type | Method | Description |
---|---|---|
SELF |
isBetween(Float start,
Float end) |
Verifies that the actual value is in [start, end] range (start included, end included).
|
SELF |
isCloseTo(float expected,
Offset<Float> 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(float 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(Float expected,
Offset<Float> 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(Float 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(float expected) |
Verifies that the actual value is equal to the given one.
|
SELF |
isEqualTo(float expected,
Offset<Float> 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(Float expected,
Offset<Float> 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(float other) |
Verifies that the actual value is greater than the given one.
|
SELF |
isGreaterThanOrEqualTo(float other) |
Verifies that the actual value is greater than or equal to the given one.
|
SELF |
isLessThan(float other) |
Verifies that the actual value is less than the given one.
|
SELF |
isLessThanOrEqualTo(float 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(float expected,
Offset<Float> 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(float 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(Float expected,
Offset<Float> 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(Float 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 |
isNotEqualTo(float 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(Float start,
Float 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 Float> 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 AbstractFloatAssert(float 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 AbstractFloatAssert<SELF>,Float>
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 AbstractFloatAssert<SELF>,Float>
public SELF isZero()
Although 0.0f == -0.0f
(primitives), Float(-0.0f)
is not zero as Float.floatToIntBits(0.0f) == Float.floatToIntBits(-0.0f)
is false.
Example:
// assertions will pass
assertThat(0.0f).isZero();
assertThat(-0.0f).isZero();
// assertions will fail
assertThat(new Float(-0.0)).isZero();
assertThat(3.142f).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.0f == -0.0f
(primitives), Float(-0.0f)
is not zero as Float.floatToIntBits(0.0f) == Float.floatToIntBits(-0.0f)
is false.
Example:
// assertions will pass
assertThat(3.142f).isNotZero();
assertThat(new Float(-0.0f)).isNotZero();
// assertions will fail
assertThat(0.0f).isNotZero();
assertThat(new Float(0.0f)).isNotZero();
assertThat(-0.0f).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 isEqualTo(float expected)
Example:
// assertions will pass:
assertThat(1.0f).isEqualTo(1.0f);
assertThat(1f).isEqualTo(1.0f);
// assertions will fail:
assertThat(0.0f).isEqualTo(1.0f);
assertThat(-1.0f).isEqualTo(1.0f);
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 isCloseTo(float expected, Offset<Float> offset)
Example:
// assertion will pass:
assertThat(8.1f).isCloseTo(8.2f, within(0.2f));
// you can use offset if you prefer
assertThat(8.1f).isCloseTo(8.2f, offset(0.2f));
// if difference is exactly equals to 0.1, it's ok
assertThat(8.1f).isCloseTo(8.2f, within(0.1f));
// assertion will fail
assertThat(8.1f).isCloseTo(8.2f, within(0.01f));
Beware that java floating point number precision might have some unexpected behavior, e.g. the assertion below
fails:
// fails because 8.1f - 8.0f is evaluated to 0.10000038f in java.
assertThat(8.1f).isCloseTo(8.0f, within(0.1f));
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
.AssertionError
- if the actual value is not close to the given one.public SELF isNotCloseTo(float expected, Offset<Float> offset)
Example:
// assertion will pass:
assertThat(8.1f).isNotCloseTo(8.2f, byLessThan(0.01f));
// you can use offset if you prefer
assertThat(8.1f).isNotCloseTo(8.2f, offset(0.01f));
// assertions will fail
assertThat(8.1f).isNotCloseTo(8.2f, byLessThan(0.1f));
assertThat(8.1f).isNotCloseTo(8.2f, byLessThan(0.2f));
Beware that java floating point number precision might have some unexpected behavior.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
.AssertionError
- if the actual value is close to the given one.Assertions.byLessThan(Float)
public SELF isCloseTo(Float expected, Offset<Float> offset)
Example:
// assertion will pass:
assertThat(8.1f).isCloseTo(new Float(8.2f), within(0.2f));
// you can use offset if you prefer
assertThat(8.1f).isCloseTo(new Float(8.2f), offset(0.2f));
// if difference is exactly equals to the offset (0.1), it's ok
assertThat(8.1f).isCloseTo(new Float(8.2f), within(0.1f));
// assertion will fail
assertThat(8.1f).isCloseTo(new Float(8.2f), within(0.01f));
Beware that java floating point number precision might have some unexpected behavior, e.g. the assertion below
fails:
// fails because 8.1f - 8.0f is evaluated to 0.10000038f in java.
assertThat(8.1f).isCloseTo(new Float(8.0f), within(0.1f));
isCloseTo
in interface FloatingPointNumberAssert<SELF extends AbstractFloatAssert<SELF>,Float>
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 other number is null
.AssertionError
- if the actual value is not close to the given one.public SELF isNotCloseTo(Float expected, Offset<Float> offset)
Example:
// assertion will pass:
assertThat(8.1f).isNotCloseTo(new Float(8.2f), within(0.01f));
// you can use offset if you prefer
assertThat(8.1f).isNotCloseTo(new Float(8.2f), offset(0.01f));
// assertions will fail
assertThat(8.1f).isNotCloseTo(new Float(8.2f), within(0.1f));
assertThat(8.1f).isNotCloseTo(new Float(8.2f), within(0.2f));
Beware that java floating point number precision might have some unexpected behavior.isNotCloseTo
in interface FloatingPointNumberAssert<SELF extends AbstractFloatAssert<SELF>,Float>
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 other number is null
.AssertionError
- if the actual value is close to the given one.Assertions.byLessThan(Float)
public SELF isCloseTo(Float expected, Percentage percentage)
Example with float:
// assertions will pass:
assertThat(11.0f).isCloseTo(new Float(10.0f), withinPercentage(20f));
// if difference is exactly equals to the computed offset (1.0), it's ok
assertThat(11.0f).isCloseTo(new Float(10.0f), withinPercentage(10f));
// assertion will fail
assertThat(11.0f).isCloseTo(new Float(10.0f), withinPercentage(5f));
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(Float expected, Percentage percentage)
Example with float:
// assertion will pass:
assertThat(11.0f).isNotCloseTo(new Float(10.0f), withinPercentage(5f));
// assertions will fail
assertThat(11.0f).isNotCloseTo(new Float(10.0f), withinPercentage(10f));
assertThat(11.0f).isNotCloseTo(new Float(10.0f), withinPercentage(20f));
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(float expected, Percentage percentage)
Example with float:
// assertions will pass:
assertThat(11.0f).isCloseTo(10.0f, withinPercentage(20f));
// if difference is exactly equals to the computed offset (1.0), it's ok
assertThat(11.0f).isCloseTo(10.0f, withinPercentage(10f));
// assertion will fail
assertThat(11.0f).isCloseTo(10.0f, withinPercentage(5f));
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(float expected, Percentage percentage)
Example with float:
// assertion will pass:
assertThat(11.0f).isNotCloseTo(10.0f, withinPercentage(5f));
// assertions will fail
assertThat(11.0f).isNotCloseTo(10.0f, withinPercentage(10f));
assertThat(11.0f).isNotCloseTo(10.0f, withinPercentage(20f));
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(Float expected, Offset<Float> 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 AbstractFloatAssert<SELF>,Float>
expected
- the given value to compare the actual value to.offset
- the given positive offset.this
assertion object.public SELF isEqualTo(float expected, Offset<Float> offset)
Example:
// assertion will pass
assertThat(8.1f).isEqualTo(8.2f, offset(0.1f));
// within is an alias of offset
assertThat(8.1f).isEqualTo(8.2f, within(0.1f));
// assertion will fail
assertThat(8.1f).isEqualTo(8.2f, offset(0.01f));
Beware that java floating point number precision might have some unexpected behavior, e.g. the assertion below
fails:
// fails because 8.1f - 8.0f is evaluated to 0.10000038f in java.
assertThat(8.1f).isEqualTo(8.0f, offset(0.1f));
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
.AssertionError
- if the actual value is null
.AssertionError
- if the actual value is not equal to the given one.public SELF isNotEqualTo(float other)
Example:
// assertions will pass:
assertThat(0.0f).isNotEqualTo(1.0f);
assertThat(-1.0f).isNotEqualTo(1.0f);
// assertions will fail:
assertThat(1.0f).isNotEqualTo(1.0f);
assertThat(1f).isNotEqualTo(1.0f);
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(float other)
Example:
// assertions will pass:
assertThat(1.0f).isLessThan(2.0f);
assertThat(1.0f).isLessThan(1.01f);
// assertions will fail:
assertThat(2.0f).isLessThan(1.0f);
assertThat(1.0f).isLessThan(1.0f);
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(float other)
Example:
// assertions will pass:
assertThat(-1.0f).isLessThanOrEqualTo(1.0f);
assertThat(1.0f).isLessThanOrEqualTo(1.0f);
// assertion will fail:
assertThat(2.0f).isLessThanOrEqualTo(1.0f);
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(float other)
Example:
// assertions will pass:
assertThat(2.0f).isGreaterThan(1.0f);
assertThat(2.0f).isGreaterThan(1.99f);
// assertions will fail:
assertThat(1.0f).isGreaterThan(1.0f);
assertThat(1.0f).isGreaterThan(2.0f);
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(float other)
Example:
// assertions will pass:
assertThat(2.0f).isGreaterThanOrEqualTo(1.0f);
assertThat(1.0f).isGreaterThanOrEqualTo(1.0f);
// assertions will fail:
assertThat(1.0f).isGreaterThanOrEqualTo(2.0f);
assertThat(1.0f).isGreaterThanOrEqualTo(0.99f);
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(Float start, Float 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 AbstractFloatAssert<SELF>,Float>
isBetween
in interface NumberAssert<SELF extends FloatingPointNumberAssert<SELF,ACTUAL>,ACTUAL extends Number>
isBetween
in class AbstractComparableAssert<SELF extends AbstractFloatAssert<SELF>,Float>
start
- the start value (inclusive), expected not to be null.end
- the end value (inclusive), expected not to be null.public SELF isStrictlyBetween(Float start, Float 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 AbstractFloatAssert<SELF>,Float>
isStrictlyBetween
in interface NumberAssert<SELF extends FloatingPointNumberAssert<SELF,ACTUAL>,ACTUAL extends Number>
isStrictlyBetween
in class AbstractComparableAssert<SELF extends AbstractFloatAssert<SELF>,Float>
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 Float> 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 AbstractFloatAssert<SELF>,Float>
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 AbstractFloatAssert<SELF>,Float>
this
assertion object.Copyright © 2014–2019. All rights reserved.