NumberAssert (AssertJ fluent assertions 3.12.2 API)

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

All Methods Instance Methods Abstract 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

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

Method Summary

Method Detail

isZero

isNotZero

isOne

isPositive

isNegative

isNotNegative

isNotPositive

isBetween

isStrictlyBetween

isCloseTo

isNotCloseTo

isCloseTo

isNotCloseTo