Package org.assertj.core.api

Class AtomicIntegerAssert

    • Field Detail

      • comparables

        org.assertj.core.internal.Comparables comparables

      • integers

        org.assertj.core.internal.Integers integers

    • Constructor Detail

      • AtomicIntegerAssert

        public AtomicIntegerAssert​(AtomicInteger actual)

    • Method Detail

      • hasValueBetween

        public AtomicIntegerAssert hasValueBetween​(int startInclusive,
                                           int endInclusive)
        Verifies that the actual atomic has a value in [start, end] range (start included, end included).

        Example: 

         AtomicInteger actual =  new AtomicInteger(5);
  
 // assertions succeed
 assertThat(actual).hasValueBetween(4, 6)
                   .hasValueBetween(4, 5)
                   .hasValueBetween(5, 6);
 
 // assertions fail
 assertThat(actual).hasValueBetween(6, 8)
                   .hasValueBetween(0, 4);
        Parameters:
        startInclusive - the start value (inclusive).
        endInclusive - the end value (inclusive).
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual atomic is null.
        AssertionError - if the actual atomic value is not in [start, end] range.
        Since:
        2.7.0 / 3.7.0

      • hasValueLessThan

        public AtomicIntegerAssert hasValueLessThan​(int other)
        Verifies that the actual atomic has a value strictly less than the given one.

        Example: 

         // assertions will pass:
 assertThat(new AtomicInteger(1)).hasValueLessThan(2);
 assertThat(new AtomicInteger(-2)).hasValueLessThan(-1);
 
 // assertions will fail:
 assertThat(new AtomicInteger(1)).hasValueLessThan(0);
 assertThat(new AtomicInteger(1)).hasValueLessThan(1);
        Parameters:
        other - the given value to compare the actual value to.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual atomic is null.
        AssertionError - if the actual value is equal to or greater than the given one.
        Since:
        2.7.0 / 3.7.0

      • hasValueLessThanOrEqualTo

        public AtomicIntegerAssert hasValueLessThanOrEqualTo​(int other)
        Verifies that the actual atomic has a value strictly less than the given one.

        Example: 

         // assertions will pass:
 assertThat(new AtomicInteger(1)).hasValueLessThanOrEqualTo(1)
                                 .hasValueLessThanOrEqualTo(2);
 assertThat(new AtomicInteger(-2)).hasValueLessThanOrEqualTo(-1);
 
 // assertion will fail:
 assertThat(new AtomicInteger(1)).hasValueLessThanOrEqualTo(0);
        Parameters:
        other - the given value to compare the actual value to.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual atomic is null.
        AssertionError - if the actual atomic value is greater than the given one.
        Since:
        2.7.0 / 3.7.0

      • hasValueGreaterThan

        public AtomicIntegerAssert hasValueGreaterThan​(int other)
        Verifies that the actual atomic has a value strictly greater than the given one.

        Example: 

         // assertions will pass:
 assertThat(new AtomicInteger(1)).hasValueGreaterThan(0);
 assertThat(new AtomicInteger(-1)).hasValueGreaterThan(-2);
 
 // assertions will fail:
 assertThat(new AtomicInteger(1)).hasValueGreaterThan(2)
                                 .hasValueGreaterThan(1);
        Parameters:
        other - the given value to compare the actual value to.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if actual is null.
        AssertionError - if the actual atomic value is equal to or less than the given one.
        Since:
        2.7.0 / 3.7.0

      • hasValueGreaterThanOrEqualTo

        public AtomicIntegerAssert hasValueGreaterThanOrEqualTo​(int other)
        Verifies that the actual atomic has a value strictly greater than the given one.

        Example: 

         // assertions will pass:
 assertThat(new AtomicInteger(1)).hasValueGreaterThanOrEqualTo(0);
 assertThat(new AtomicInteger(1)).hasValueGreaterThanOrEqualTo(1);
 assertThat(new AtomicInteger(-1)).hasValueGreaterThanOrEqualTo(-2);
 
 // assertion will fail:
 assertThat(new AtomicInteger(1)).hasValueGreaterThanOrEqualTo(2);
        Parameters:
        other - the given value to compare the actual value to.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual atomic is null.
        AssertionError - if the actual atomic value is less than the given one.
        Since:
        2.7.0 / 3.7.0

      • hasPositiveValue

        public AtomicIntegerAssert hasPositiveValue()
        Verifies that the actual atomic has a positive value.

        Example: 

         // assertion will pass
 assertThat(new AtomicInteger(42)).hasPositiveValue();

 // assertions will fail
 assertThat(new AtomicInteger(0)).hasPositiveValue();
 assertThat(new AtomicInteger(-1)).hasPositiveValue();
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual atomic is null.
        AssertionError - if the actual atomic value is not positive.
        Since:
        2.7.0 / 3.7.0

      • hasNonPositiveValue

        public AtomicIntegerAssert hasNonPositiveValue()
        Verifies that the actual atomic has a non positive value (negative or equal zero).

        Example: 

         // assertions will pass
 assertThat(new AtomicInteger(-42)).hasNonPositiveValue();
 assertThat(new AtomicInteger(0)).hasNonPositiveValue();

 // assertion will fail
 assertThat(new AtomicInteger(42)).hasNonPositiveValue();
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual atomic is null.
        AssertionError - if the actual atomic value is not non positive.
        Since:
        2.7.0 / 3.7.0

      • hasNegativeValue

        public AtomicIntegerAssert hasNegativeValue()
        Verifies that the actual atomic has a negative value.

        Example: 

         // assertion will pass
 assertThat(new AtomicInteger(-42)).hasNegativeValue();

 // assertions will fail
 assertThat(new AtomicInteger(0)).hasNegativeValue();
 assertThat(new AtomicInteger(42)).hasNegativeValue();
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual atomic is null.
        AssertionError - if the actual atomic value is not negative.
        Since:
        2.7.0 / 3.7.0

      • hasNonNegativeValue

        public AtomicIntegerAssert hasNonNegativeValue()
        Verifies that the actual atomic has a non negative value (positive or equal zero).

        Example: 

         // assertions will pass
 assertThat(new AtomicInteger(42)).hasNonNegativeValue();
 assertThat(new AtomicInteger(0)).hasNonNegativeValue();

 // assertion will fail
 assertThat(new AtomicInteger(-42)).hasNonNegativeValue();
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual atomic is null.
        AssertionError - if the actual atomic value is not non negative.
        Since:
        2.7.0 / 3.7.0

      • hasValueCloseTo

        public AtomicIntegerAssert hasValueCloseTo​(int expected,
                                           Percentage percentage)
        Verifies that the actual atomic has a value close to the given one within the given percentage.
        If difference is equal to the percentage value, assertion is considered valid.

        Example with integer: 

         // assertions will pass:
 assertThat(new AtomicInteger(11)).hasValueCloseTo(10, withinPercentage(20));

 // if difference is exactly equals to the computed offset (1), it's ok
 assertThat(new AtomicInteger(11)).hasValueCloseTo(10, withinPercentage(10));

 // assertion will fail
 assertThat(new AtomicInteger(11)).hasValueCloseTo(10, 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 Percentage is null.
        AssertionError - if the actual atomic value is not close enough to the given one.
        Since:
        2.7.0 / 3.7.0

      • hasValueCloseTo

        public AtomicIntegerAssert hasValueCloseTo​(int expected,
                                           Offset<Integer> offset)
        Verifies that the actual atomic has a value close to the given one within the given offset.

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

        Breaking change since 2.9.0/3.9.0: using Assertions.byLessThan(Integer) implies a strict comparison, use Assertions.within(Integer) to get the old behavior.

        Example with Integer: 

         // assertions will pass:
 assertThat(new AtomicInteger(5)).hasValueCloseTo(7, within(3))
                                 .hasValueCloseTo(7, byLessThan(3));

 // if the difference is exactly equals to the offset, it's ok ...
 assertThat(new AtomicInteger(5)).hasValueCloseTo(7, within(2));
 // ... but not with byLessThan which implies a strict comparison
 assertThat(new AtomicInteger(5)).hasValueCloseTo(7, byLessThan(2)); // FAIL

 // assertion will fail
 assertThat(new AtomicInteger(5)).hasValueCloseTo(7, within(1));
 assertThat(new AtomicInteger(5)).hasValueCloseTo(7, byLessThan(1));
        Parameters:
        expected - the given number to compare the actual value to.
        offset - the given allowed Offset.
        Returns:
        this assertion object.
        Throws:
        NullPointerException - if the given Offset is null.
        AssertionError - if the actual atomic value is not close enough to the given one.
        Since:
        2.7.0 / 3.7.0

      • hasValue

        public AtomicIntegerAssert hasValue​(int expectedValue)
        Verifies that the actual atomic has the given value.

        Example: 

         // assertion will pass
 assertThat(new AtomicInteger(42)).hasValue(42);

 // assertion will fail
 assertThat(new AtomicInteger(42)).hasValue(0);
        Parameters:
        expectedValue - the expected value.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual atomic is null.
        AssertionError - if the actual atomic does not have the given value.
        Since:
        2.7.0 / 3.7.0

      • doesNotHaveValue

        public AtomicIntegerAssert doesNotHaveValue​(int expectedValue)
        Verifies that the actual atomic does not have the given value.

        Example: 

         // assertion will pass
 assertThat(new AtomicInteger(42)).doesNotHaveValue(0);

 // assertion will fail
 assertThat(new AtomicInteger(42)).doesNotHaveValue(42);
        Parameters:
        expectedValue - the value not expected .
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual atomic is null.
        AssertionError - if the actual atomic has the given value.
        Since:
        2.7.0 / 3.7.0

      • usingComparator

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

        The custom comparator is bound to assertion instance, meaning that if a new assertion instance is created, the default comparison strategy will be used.

        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<AtomicIntegerAssert,​AtomicInteger>
        Overrides:
        usingComparator in class AbstractAssert<AtomicIntegerAssert,​AtomicInteger>
        Parameters:
        customComparator - the comparator to use for the incoming assertion checks.
        Returns:
        this assertion object.

      • usingComparator

        public AtomicIntegerAssert usingComparator​(Comparator<? super AtomicInteger> customComparator,
                                           String customComparatorDescription)
        Description copied from class: AbstractAssert
        Use the given custom comparator instead of relying on actual type A equals method for incoming assertion checks.

        The custom comparator is bound to assertion instance, meaning that if a new assertion instance is created, the default comparison strategy will be used.

        Examples : 

         // frodo and sam are instances of Character with Hobbit race (obviously :).
 // raceComparator implements Comparator<Character>
 assertThat(frodo).usingComparator(raceComparator, "Hobbit Race Comparator").isEqualTo(sam);
        Specified by:
        usingComparator in interface Assert<AtomicIntegerAssert,​AtomicInteger>
        Overrides:
        usingComparator in class AbstractAssert<AtomicIntegerAssert,​AtomicInteger>
        Parameters:
        customComparator - the comparator to use for the incoming assertion checks.
        customComparatorDescription - comparator description to be used in assertion error messages
        Returns:
        this assertion object.