Package org.assertj.core.api

Interface FloatingPointNumberAssert<SELF extends FloatingPointNumberAssert<SELF,​ACTUAL>,​ACTUAL extends Number>

    • Method Detail

      • isEqualTo

        SELF isEqualTo​(ACTUAL expected,
               Offset<ACTUAL> offset)
        Verifies that the actual number is close to the given one within the given offset value.

        This assertion is the same as isCloseTo(Number, Offset).

        When abs(actual - expected) == offset value, the assertion:

        Examples: 

         // assertions succeed
 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));
        Parameters:
        expected - the given value 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 equal to the given one.

      • 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 succeed:
 assertThat(8.1).isCloseTo(new Double(8.0), within(0.2));

 // you can use offset if you prefer
 assertThat(8.1).isCloseTo(new Double(8.0), offset(0.2));

 // if difference is exactly equals to the offset (0.1), it's ok
 assertThat(8.1).isCloseTo(new Double(8.0), within(0.1));

 // assertion will fail
 assertThat(8.1).isCloseTo(new Double(8.0), within(0.01));
        Specified by:
        isCloseTo in interface NumberAssert<SELF extends FloatingPointNumberAssert<SELF,​ACTUAL>,​ACTUAL extends Number>
        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 by less than the given offset.
        If the difference is equal to the offset value, the assertion fails.

        Example with double: 

         // assertions succeed:
 assertThat(8.3).isNotCloseTo(new Double(8.0), byLessThan(0.2));

 // you can use offset if you prefer
 assertThat(8.3).isNotCloseTo(new Double(8.0), offset(0.2));

 // assertions fail
 assertThat(8.1).isNotCloseTo(new Double(8.0), byLessThan(0.1));
 assertThat(8.1).isNotCloseTo(new Double(8.0), byLessThan(0.2));
        Specified by:
        isNotCloseTo in interface NumberAssert<SELF extends FloatingPointNumberAssert<SELF,​ACTUAL>,​ACTUAL extends Number>
        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 equal to the given one.
        Since:
        2.6.0 / 3.6.0
        See Also:
        Assertions.byLessThan(Double)

      • isNaN

        SELF isNaN()
        Verifies that the actual value is equal to NaN.

        Example: 

         // assertions succeed
 assertThat(Double.NaN).isNaN();
 assertThat(0.0 / 0.0).isNaN();
 assertThat(0.0F * Float.POSITIVE_INFINITY).isNaN();

 // assertions fail
 assertThat(1.0).isNaN();
 assertThat(-1.0F).isNaN();
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual value is not equal to NaN.

      • isNotNaN

        SELF isNotNaN()
        Verifies that the actual value is not equal to NaN.

        Example: 

         // assertions succeed
 assertThat(1.0).isNotNaN();
 assertThat(-1.0F).isNotNaN();

 // assertions fail
 assertThat(Double.NaN).isNotNaN();
 assertThat(0.0 / 0.0).isNotNaN();
 assertThat(0.0F * Float.POSITIVE_INFINITY).isNotNaN();
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual value is equal to NaN.

      • isFinite

        SELF isFinite()

      • isNotFinite

        SELF isNotFinite()

      • isInfinite

        SELF isInfinite()

      • isNotInfinite

        SELF isNotInfinite()