public abstract Class AbstractComparableAssert<SELF extends AbstractComparableAssert<SELF, ACTUAL>, ACTUAL extends Comparable<? super ACTUAL>>

Overrides org.assertj.core.api.AbstractAssert.inBinary.

Doc from org.assertj.core.api.AbstractAssert.inBinary.

Use binary object representation instead of standard representation in error messages.

Example:

 assertThat(1).inBinary().isEqualTo(2);

org.junit.ComparisonFailure:
Expected :0b00000000_00000000_00000000_00000010
Actual   :0b00000000_00000000_00000000_00000001

Returns:SELF

this assertion object.

Annotations

@Override

@CheckReturnValue

Overrides org.assertj.core.api.AbstractAssert.inHexadecimal.

Doc from org.assertj.core.api.AbstractAssert.inHexadecimal.

Use hexadecimal object representation instead of standard representation in error messages.

It can be useful when comparing UNICODE characters - many unicode chars have duplicate characters assigned, it is thus impossible to find differences from the standard error message:

With standard message:

 assertThat("µµµ").contains("μμμ");

java.lang.AssertionError:
Expecting:
  <"µµµ">
to contain:
  <"μμμ">

 assertThat("µµµ").inHexadecimal().contains("μμμ");

java.lang.AssertionError:
Expecting:
  <"['00B5', '00B5', '00B5']">
to contain:
  <"['03BC', '03BC', '03BC']">

Returns:SELF

this assertion object.

Annotations

@Override

@CheckReturnValue

Implements org.assertj.core.api.ComparableAssert.isBetween.

Doc from org.assertj.core.api.ComparableAssert.isBetween.

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

Example:

 // assertions succeed
assertThat('b').isBetween('a', 'c');
assertThat('a').isBetween('a', 'b');
assertThat('b').isBetween('a', 'b');

// assertions fail
assertThat('a').isBetween('b', 'c');
assertThat('c').isBetween('a', 'b');

Parameters

startInclusive:ACTUAL

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

endInclusive:ACTUAL

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

Returns:SELF

this assertion object.

Annotations

@Override

Implements org.assertj.core.api.ComparableAssert.isEqualByComparingTo.

Doc from org.assertj.core.api.ComparableAssert.isEqualByComparingTo.

Verifies that the actual value is equal to the given one by invoking Comparable#compareTo(Object).

Example:

 // assertion will pass
assertThat(1.0).isEqualByComparingTo(1.0);
// assertion will pass because 8.0 is equal to 8.00 using BigDecimal#compareTo(BigDecimal)
assertThat(new BigDecimal("8.0")).isEqualByComparingTo(new BigDecimal("8.00"));

// assertion will fail
assertThat(new BigDecimal(1.0)).isEqualByComparingTo(new BigDecimal(2.0));

Parameters

other:ACTUAL

the given value to compare the actual value to.

Returns:SELF

this assertion object.

Annotations

@Override

Implements org.assertj.core.api.ComparableAssert.isGreaterThan.

Doc from org.assertj.core.api.ComparableAssert.isGreaterThan.

Verifies that the actual value is greater than the given one.

Example:

 // assertions will pass
assertThat('b').isGreaterThan('a');
assertThat(BigInteger.ONE).isGreaterThan(BigInteger.ZERO);

// assertions will fail
assertThat('b').isGreaterThan('a');
assertThat(BigInteger.ZERO).isGreaterThan(BigInteger.ZERO);

Parameters

other:ACTUAL

the given value to compare the actual value to.

Returns:SELF

this assertion object.

Annotations

@Override

Implements org.assertj.core.api.ComparableAssert.isGreaterThanOrEqualTo.

Doc from org.assertj.core.api.ComparableAssert.isGreaterThanOrEqualTo.

Verifies that the actual value is greater than or equal to the given one.

Example:

 // assertions will pass
assertThat('b').isGreaterThanOrEqualTo('a');
assertThat(BigInteger.ONE).isGreaterThanOrEqualTo(BigInteger.ONE);

// assertions will fail
assertThat('a').isGreaterThanOrEqualTo('b');
assertThat(BigInteger.ZERO).isGreaterThanOrEqualTo(BigInteger.ONE);

Parameters

other:ACTUAL

the given value to compare the actual value to.

Returns:SELF

this assertion object.

Annotations

@Override

Implements org.assertj.core.api.ComparableAssert.isLessThan.

Doc from org.assertj.core.api.ComparableAssert.isLessThan.

Verifies that the actual value is less than the given one.

Example:

 // assertions will pass
assertThat('a').isLessThan('b');
assertThat(BigInteger.ZERO).isLessThan(BigInteger.ONE);

// assertions will fail
assertThat('a').isLessThan('a');
assertThat(BigInteger.ONE).isLessThan(BigInteger.ZERO);

Parameters

other:ACTUAL

the given value to compare the actual value to.

Returns:SELF

this assertion object.

Annotations

@Override

Implements org.assertj.core.api.ComparableAssert.isLessThanOrEqualTo.

Doc from org.assertj.core.api.ComparableAssert.isLessThanOrEqualTo.

Verifies that the actual value is less than or equal to the given one.

Example:

 // assertions will pass
assertThat('a').isLessThanOrEqualTo('b');
assertThat('a').isLessThanOrEqualTo('a');
assertThat(BigInteger.ZERO).isLessThanOrEqualTo(BigInteger.ZERO);

// assertions will fail
assertThat('b').isLessThanOrEqualTo('a');
assertThat(BigInteger.ONE).isLessThanOrEqualTo(BigInteger.ZERO);

Parameters

other:ACTUAL

the given value to compare the actual value to.

Returns:SELF

this assertion object.

Annotations

@Override

Implements org.assertj.core.api.ComparableAssert.isNotEqualByComparingTo.

Doc from org.assertj.core.api.ComparableAssert.isNotEqualByComparingTo.

Verifies that the actual value is not equal to the given one by invoking Comparable#compareTo(Object).

Example:

 // assertion will pass
assertThat(new BigDecimal(1.0)).isNotEqualByComparingTo(new BigDecimal(2.0));

// assertion will fail
assertThat(1.0).isNotEqualByComparingTo(1.0);
// assertion will fail because 8.0 is equal to 8.00 using BigDecimal#compareTo(BigDecimal)
assertThat(new BigDecimal("8.0")).isNotEqualByComparingTo(new BigDecimal("8.00"));

Parameters

other:ACTUAL

the given value to compare the actual value to.

Returns:SELF

this assertion object.

Annotations

@Override

Implements org.assertj.core.api.ComparableAssert.isStrictlyBetween.

Doc from org.assertj.core.api.ComparableAssert.isStrictlyBetween.

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

Example:

 // assertion succeeds
assertThat('b').isStrictlyBetween('a', 'c');

// assertions fail
assertThat('d').isStrictlyBetween('a', 'c');
assertThat('a').isStrictlyBetween('b', 'd');
assertThat('a').isStrictlyBetween('a', 'b');
assertThat('b').isStrictlyBetween('a', 'b');

Parameters

startExclusive:ACTUAL

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

endExclusive:ACTUAL

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

Returns:SELF

this assertion object.

Annotations

@Override

Overrides org.assertj.core.api.AbstractAssert.usingComparator.

Implements org.assertj.core.api.Assert.usingComparator.

Doc from org.assertj.core.api.AbstractAssert.usingComparator.

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

Parameters

customComparator:Comparator<? super ACTUAL>

Doc from org.assertj.core.api.Assert.usingComparator.

the comparator to use for the incoming assertion checks.

Returns:SELF

Doc from org.assertj.core.api.Assert.usingComparator.

this assertion object.

Annotations

@Override

@CheckReturnValue

Overrides org.assertj.core.api.AbstractAssert.usingComparator.

Implements org.assertj.core.api.Assert.usingComparator.

Doc from org.assertj.core.api.AbstractAssert.usingComparator.

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

Parameters

customComparator:Comparator<? super ACTUAL>

Doc from org.assertj.core.api.Assert.usingComparator.

the comparator to use for the incoming assertion checks.

customComparatorDescription:String

Doc from org.assertj.core.api.Assert.usingComparator.

comparator description to be used in assertion error messages

Returns:SELF

Doc from org.assertj.core.api.Assert.usingComparator.

this assertion object.

Annotations

@Override

@CheckReturnValue

Overrides org.assertj.core.api.AbstractAssert.usingDefaultComparator.

Implements org.assertj.core.api.Assert.usingDefaultComparator.

Doc from org.assertj.core.api.AbstractAssert.usingDefaultComparator.

Revert to standard comparison for the incoming assertion checks.

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

Returns:SELF

Doc from org.assertj.core.api.Assert.usingDefaultComparator.

this assertion object.

Annotations

@Override

@CheckReturnValue