Class FloatAssert

All Implemented Interfaces:
Assert<FloatAssert,Float>, ComparableAssert<FloatAssert,Float>, Descriptable<FloatAssert>, ExtensionPoints<FloatAssert,Float>, FloatingPointNumberAssert<Float>, NumberAssert<Float>

public class FloatAssert extends AbstractComparableAssert<FloatAssert,Float> implements FloatingPointNumberAssert<Float>
Assertion methods for floats.

To create an instance of this class, invoke Assertions.assertThat(Float) or Assertions.assertThat(float).

Author:
Yvonne Wang, Alex Ruiz, Ansgar Konermann, Mikhail Mazursky, Nicolas François
  • Constructor Details

    • FloatAssert

      protected FloatAssert(Float actual)
  • Method Details

    • isNaN

      public FloatAssert isNaN()
      Verifies that the actual value is equal to NaN.
      Specified by:
      isNaN in interface FloatingPointNumberAssert<Float>
      Returns:
      this assertion object.
    • isNotNaN

      public FloatAssert isNotNaN()
      Verifies that the actual value is not equal to NaN.
      Specified by:
      isNotNaN in interface FloatingPointNumberAssert<Float>
      Returns:
      this assertion object.
    • isZero

      public FloatAssert isZero()
      Verifies that the actual value is equal to zero.
      Specified by:
      isZero in interface NumberAssert<Float>
      Returns:
      this assertion object.
    • isNotZero

      public FloatAssert isNotZero()
      Verifies that the actual value is not equal to zero.
      Specified by:
      isNotZero in interface NumberAssert<Float>
      Returns:
      this assertion object.
    • isPositive

      public FloatAssert isPositive()
      Verifies that the actual value is positive.
      Specified by:
      isPositive in interface NumberAssert<Float>
      Returns:
      this assertion object.
    • isNegative

      public FloatAssert isNegative()
      Verifies that the actual value is negative.
      Specified by:
      isNegative in interface NumberAssert<Float>
      Returns:
      this assertion object.
    • isNotNegative

      public FloatAssert isNotNegative()
      Verifies that the actual value is non negative (positive or equal zero).
      Specified by:
      isNotNegative in interface NumberAssert<Float>
      Returns:
      this assertion object.
    • isNotPositive

      public FloatAssert isNotPositive()
      Verifies that the actual value is non positive (negative or equal zero).
      Specified by:
      isNotPositive in interface NumberAssert<Float>
      Returns:
      this assertion object.
    • isEqualTo

      public FloatAssert isEqualTo(float expected)
      Verifies that the actual value is equal to the given one.
      Parameters:
      expected - the given value to compare the actual value to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual value is null.
      AssertionError - if the actual value is not equal to the given one.
    • isEqualTo

      public FloatAssert isEqualTo(Float expected, Offset<Float> offset)
      Verifies that the actual value is equal to the given one, within a positive offset.
      Specified by:
      isEqualTo in interface FloatingPointNumberAssert<Float>
      Parameters:
      expected - the given value to compare the actual value to.
      offset - the given positive offset.
      Returns:
      this assertion object.
    • isEqualTo

      public FloatAssert isEqualTo(float expected, Offset<Float> offset)
      Verifies that the actual value is equal to the given one, within a positive offset.
      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.
      AssertionError - if the actual value is null.
      AssertionError - if the actual value is not equal to the given one.
    • isNotEqualTo

      public FloatAssert isNotEqualTo(float other)
      Verifies that the actual value is not equal to the given one.
      Parameters:
      other - the given value to compare the actual value to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual value is null.
      AssertionError - if the actual value is equal to the given one.
    • isLessThan

      public FloatAssert isLessThan(float other)
      Verifies that the actual value is less than the given one.
      Parameters:
      other - the given value to compare the actual value to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual value is null.
      AssertionError - if the actual value is equal to or greater than the given one.
    • isLessThanOrEqualTo

      public FloatAssert isLessThanOrEqualTo(float other)
      Verifies that the actual value is less than or equal to the given one.
      Parameters:
      other - the given value to compare the actual value to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual value is null.
      AssertionError - if the actual value is greater than the given one.
    • isGreaterThan

      public FloatAssert isGreaterThan(float other)
      Verifies that the actual value is greater than the given one.
      Parameters:
      other - the given value to compare the actual value to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual value is null.
      AssertionError - if the actual value is equal to or less than the given one.
    • isGreaterThanOrEqualTo

      public FloatAssert isGreaterThanOrEqualTo(float other)
      Verifies that the actual value is greater than or equal to the given one.
      Parameters:
      other - the given value to compare the actual value to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual value is null.
      AssertionError - if the actual value is less than the given one.
    • usingComparator

      public FloatAssert usingComparator(Comparator<? super Float> customComparator)
      Description copied from class: AbstractAssert
      Use given custom comparator instead of relying on actual type A equals method for incoming assertion checks.

      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); 
       
      Specified by:
      usingComparator in interface Assert<FloatAssert,Float>
      Overrides:
      usingComparator in class AbstractComparableAssert<FloatAssert,Float>
      Parameters:
      customComparator - the comparator to use for incoming assertion checks.
      Returns:
      this assertion object.
    • usingDefaultComparator

      public FloatAssert usingDefaultComparator()
      Description copied from class: AbstractAssert
      Revert to standard comparison for incoming assertion checks.

      This method should be used to disable a custom comparison strategy set by calling Assert.usingComparator(Comparator).

      Specified by:
      usingDefaultComparator in interface Assert<FloatAssert,Float>
      Overrides:
      usingDefaultComparator in class AbstractComparableAssert<FloatAssert,Float>
      Returns:
      this assertion object.