org.assertj.core.api

Interface NumberAssert<SELF extends NumberAssert<SELF,ACTUAL>,ACTUAL extends Number>

Type Parameters:

SELF - the "self" type of this assertion class. Please read "Emulating 'self types' using Java Generics to simplify fluent API implementation" for more details.

ACTUAL - the type of the "actual" value.

All Known Subinterfaces:

FloatingPointNumberAssert<SELF,ACTUAL>

All Known Implementing Classes:

AbstractBigDecimalAssert, AbstractBigIntegerAssert, AbstractByteAssert, AbstractDoubleAssert, AbstractFloatAssert, AbstractIntegerAssert, AbstractIterableSizeAssert, AbstractLongAssert, AbstractMapSizeAssert, AbstractShortAssert, BigDecimalAssert, BigIntegerAssert, ByteAssert, DoubleAssert, FloatAssert, IntegerAssert, IterableSizeAssert, LongAssert, MapSizeAssert, ShortAssert

public interface NumberAssert<SELF extends NumberAssert<SELF,ACTUAL>,ACTUAL extends Number>

Assertion methods applicable to Numbers.

Author:

Drummond Dawson, Alex Ruiz, Nicolas François, Mikhail Mazursky

Method Summary

Methods

Modifier and Type	Method and Description
SELF	isBetween(ACTUAL start, ACTUAL end) Verifies that the actual value is in [start, end] range (start included, end included).
SELF	isCloseTo(ACTUAL expected, Offset<ACTUAL> 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(ACTUAL 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	isNegative() Verifies that the actual value is negative.
SELF	isNotCloseTo(ACTUAL expected, Offset<ACTUAL> offset) Verifies that the actual number is not close to the given one within the given offset. If the difference is equal to the offset value, the assertion fails.
SELF	isNotCloseTo(ACTUAL 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	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(ACTUAL start, ACTUAL 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.

Method Detail

isZero

SELF isZero()

Verifies that the actual value is equal to zero.

Example:

 // assertions will pass
 assertThat(0).isZero();
 assertThat(0.0).isZero();

 // assertions will fail
 assertThat(42).isZero();
 assertThat(3.142).isZero();

Returns:

this assertion object.

Throws:

AssertionError - if the actual value is null.

AssertionError - if the actual value is not equal to zero.

isNotZero

SELF isNotZero()

Verifies that the actual value is not equal to zero.

Example:

 // assertions will pass
 assertThat(42).isNotZero();
 assertThat(3.142).isNotZero();

 // assertions will fail
 assertThat(0).isNotZero();
 assertThat(0.0).isNotZero();

Returns:

this assertion object.

Throws:

AssertionError - if the actual value is null.

AssertionError - if the actual value is equal to zero.

isOne

SELF isOne()

Verifies that the actual value is equal to one.

Example:

 // assertions will pass
 assertThat(1).isOne();
 assertThat(1.0).isOne();

 // assertions will fail
 assertThat(42).isOne();
 assertThat(3.142).isOne();

Returns:

this assertion object.

Throws:

AssertionError - if the actual value is null.

AssertionError - if the actual value is not equal to one.

Since:

2.7.0 / 3.7.0

isPositive

SELF isPositive()

Verifies that the actual value is positive.

Example:

 // assertions will pass
 assertThat(42).isPositive();
 assertThat(3.142).isPositive();

 // assertions will fail
 assertThat(0).isPositive();
 assertThat(-42).isPositive();

Returns:

this assertion object.

Throws:

AssertionError - if the actual value is null.

AssertionError - if the actual value is not positive.

isNegative

SELF isNegative()

Verifies that the actual value is negative.

Example:

 // assertions will pass
 assertThat(-42).isNegative();
 assertThat(-3.124).isNegative();

 // assertions will fail
 assertThat(0).isNegative();
 assertThat(42).isNegative();

Returns:

this assertion object.

Throws:

AssertionError - if the actual value is null.

AssertionError - if the actual value is not negative.

isNotNegative

SELF isNotNegative()

Verifies that the actual value is non negative (positive or equal zero).

Example:

 // assertions will pass
 assertThat(42).isNotNegative();
 assertThat(0).isNotNegative();

 // assertions will fail
 assertThat(-42).isNotNegative();
 assertThat(-3.124).isNotNegative();

Returns:

this assertion object.

Throws:

AssertionError - if the actual value is null.

AssertionError - if the actual value is not non negative.

isNotPositive

SELF isNotPositive()

Verifies that the actual value is non positive (negative or equal zero).

Example:

 // assertions will pass
 assertThat(-42).isNotPositive();
 assertThat(0).isNotPositive();

 // assertions will fail
 assertThat(42).isNotPositive();
 assertThat(3.124).isNotPositive();

Returns:

this assertion object.

Throws:

AssertionError - if the actual value is null.

AssertionError - if the actual value is not non positive.

isBetween

SELF isBetween(ACTUAL start,
             ACTUAL end)

Verifies that the actual value is in [start, end] range (start included, end included).

Example:

 // these assertions succeed ...
 assertThat(12).isBetween(10, 14);
 assertThat(12).isBetween(12, 14);
 assertThat(12).isBetween(10, 12);
 
 // ... but this one fails
 assertThat(12).isBetween(14, 16);

Parameters:

start - the start value (inclusive), expected not to be null.

end - the end value (inclusive), expected not to be null.

Returns:

this assertion object.

Throws:

AssertionError - if the actual value is null.

NullPointerException - if start value is null.

NullPointerException - if end value is null.

AssertionError - if the actual value is not in [start, end] range.

isStrictlyBetween

SELF isStrictlyBetween(ACTUAL start,
                     ACTUAL end)

Verifies that the actual value is in ]start, end[ range (start excluded, end excluded).

Example:

 // this assertion succeeds ...
 assertThat(12).isStrictlyBetween(10, 14);
 
 // ... but these ones fail
 assertThat(12).isStrictlyBetween(12, 14);
 assertThat(12).isStrictlyBetween(10, 12);
 assertThat(12).isStrictlyBetween(16, 18);

Parameters:

start - the start value (exclusive), expected not to be null.

end - the end value (exclusive), expected not to be null.

Returns:

this assertion object.

Throws:

AssertionError - if the actual value is null.

NullPointerException - if start value is null.

NullPointerException - if end value is null.

AssertionError - if the actual value is not in ]start, end[ range.

isCloseTo

SELF isCloseTo(ACTUAL expected,
             Offset<ACTUAL> 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.

Example with double:

 // assertions 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 the offset (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));

Parameters:

expected - the given number to compare the actual value to.

offset - the given positive offset.

Returns:

this assertion object.

Throws:

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.

isNotCloseTo

SELF isNotCloseTo(ACTUAL expected,
                Offset<ACTUAL> offset)

Verifies that the actual number is not close to the given one within the given offset.
If the difference is equal to the offset value, the assertion fails.

Example with double:

 // assertions 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));

Parameters:

expected - the given number to compare the actual value to.

offset - the given positive offset.

Returns:

this assertion object.

Throws:

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.

Since:

2.6.0 / 3.6.0

isCloseTo

SELF isCloseTo(ACTUAL 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.

Example with double:

 // assertions will pass:
 assertThat(11.0).isCloseTo(10.0, withinPercentage(20));

 // if difference is exactly equals to the computed offset (1.0), it's ok
 assertThat(11.0).isCloseTo(10.0, withinPercentage(10));

 // assertion will fail
 assertThat(11.0).isCloseTo(10.0, withinPercentage(5));

Parameters:

expected - the given number to compare the actual value to.

percentage - the given positive percentage.

Returns:

this assertion object.

Throws:

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.

isNotCloseTo

SELF isNotCloseTo(ACTUAL 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.

Example with double:

 // assertions will pass:
 assertThat(11.0).isNotCloseTo(10.0, withinPercentage(5));

 // assertions will fail
 assertThat(11.0).isNotCloseTo(10.0, withinPercentage(10));
 assertThat(11.0).isNotCloseTo(10.0, withinPercentage(20));

Parameters:

expected - the given number to compare the actual value to.

percentage - the given positive percentage.

Returns:

this assertion object.

Throws:

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.

Since:

2.6.0 / 3.6.0