public abstract class AbstractUniversalComparableAssert<SELF extends AbstractUniversalComparableAssert<SELF,T>,T> extends AbstractObjectAssert<SELF,Comparable<T>>
Comparable assertions.
This class offers better compatibility than ComparableAssert and related implementations, currently limited
due to the upper bound of ComparableAssert's type parameters.
Let's take an example with a class Name implementing Comparable<Name>.
Comparable<Name> name1 = new Name("abc");The following does not compile or work as expected:
// does not compile as assertThat(name1) resolves to Object assertions
assertThat(name1).isLessThanOrEqualTo(name1);
// compiles fine but requires a raw Comparable cast (assertThat resolves to AbstractComparableAssert)
assertThat((Comparable)name1).isLessThanOrEqualTo(name1);
// does not compile: Cannot infer type arguments for GenericComparableAssert<>
new GenericComparableAssert<>(name1).isLessThanOrEqualTo(name3);
// compiles fine with the concrete type (assertThat resolves to AbstractComparableAssert)
Name name = name1;
assertThat(name).isEqualByComparingTo(name);This class aims to allow writing
// assertThatComparable resolves to AbstractUniversalComparableAssert
assertThatComparable(name1).isLessThanOrEqualTo(name1);
// it works with the concrete type too
assertThatComparable(name).isEqualByComparingTo(name);Assertions.assertThatComparable(Comparable)actual, info, myself, objects, throwUnsupportedExceptionOnEquals| Modifier | Constructor and Description |
|---|---|
protected |
AbstractUniversalComparableAssert(Comparable<T> actual,
Class<?> selfType) |
| Modifier and Type | Method and Description |
|---|---|
SELF |
inBinary()
Use binary object representation instead of standard representation in error messages.
|
SELF |
inHexadecimal()
Use hexadecimal object representation instead of standard representation in error messages.
|
SELF |
isBetween(T startInclusive,
T endInclusive)
Verifies that the actual value is in [start, end] range (start included, end included).
|
SELF |
isEqualByComparingTo(T other)
Verifies that the actual value is equal to the given one by invoking
|
SELF |
isGreaterThan(T other)
Verifies that the actual value is greater than the given one.
|
SELF |
isGreaterThanOrEqualTo(T other)
Verifies that the actual value is greater than or equal to the given one.
|
SELF |
isLessThan(T other)
Verifies that the actual value is less than the given one.
|
SELF |
isLessThanOrEqualTo(T other)
Verifies that the actual value is less than or equal to the given one.
|
SELF |
isNotEqualByComparingTo(T other)
Verifies that the actual value is not equal to the given one by invoking
|
SELF |
isStrictlyBetween(T startExclusive,
T endExclusive)
Verifies that the actual value is in ]start, end[ range (start excluded, end excluded).
|
SELF |
usingComparator(Comparator<? super Comparable<T>> customComparator)
Use the given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
|
SELF |
usingComparator(Comparator<? super Comparable<T>> customComparator,
String customComparatorDescription)
Use the given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
|
SELF |
usingDefaultComparator()
Revert to standard comparison for the incoming assertion checks.
|
as, as, doesNotReturn, extracting, extracting, extracting, extracting, extracting, extracting, extractingForProxy, getComparatorsByType, hasAllNullFieldsOrProperties, hasAllNullFieldsOrPropertiesExcept, hasFieldOrProperty, hasFieldOrPropertyWithValue, hasNoNullFieldsOrProperties, hasNoNullFieldsOrPropertiesExcept, hasOnlyFields, isEqualToComparingFieldByField, isEqualToComparingFieldByFieldRecursively, isEqualToComparingOnlyGivenFields, isEqualToIgnoringGivenFields, isEqualToIgnoringNullFields, newObjectAssert, returns, usingComparatorForFields, usingComparatorForType, usingRecursiveComparison, usingRecursiveComparisonareEqual, asInstanceOf, asList, assertionError, asString, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, doesNotHaveSameHashCodeAs, doesNotHaveToString, equals, extracting, extracting, failure, failureWithActualExpected, failWithActualExpectedAndMessage, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, hasToString, is, isElementOfCustomAssert, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, newListAssertInstance, overridingErrorMessage, overridingErrorMessage, satisfies, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, satisfiesAnyOfForProxy, satisfiesForProxy, setCustomRepresentation, setDescriptionConsumer, setPrintAssertionsDescription, throwAssertionError, withFailMessage, withFailMessage, withRepresentation, withThreadDumpOnErrorclone, finalize, getClass, notify, notifyAll, toString, wait, wait, waitas, describedAsprotected AbstractUniversalComparableAssert(Comparable<T> actual, Class<?> selfType)
public SELF isEqualByComparingTo(T other)
Comparable.compareTo(Object)Example:
// assertion will pass
assertThatComparable(1.0).isEqualByComparingTo(1.0);
// assertion will pass because 8.0 is equal to 8.00 using BigDecimal.compareTo(BigDecimal)
assertThatComparable(new BigDecimal("8.0")).isEqualByComparingTo(new BigDecimal("8.00"));
// assertion will fail
assertThatComparable(new BigDecimal(1.0)).isEqualByComparingTo(new BigDecimal(2.0));other - the given value to compare the actual value to.this assertion object.AssertionError - if the actual value is null.AssertionError - if the actual value is not equal when comparing to the given one.public SELF isNotEqualByComparingTo(T other)
Comparable.compareTo(Object)Example:
// assertion will pass
assertThatComparable(new BigDecimal(1.0)).isNotEqualByComparingTo(new BigDecimal(2.0));
// assertion will fail
assertThatComparable(1.0).isNotEqualByComparingTo(1.0);
// assertion will fail because 8.0 is equal to 8.00 using BigDecimal.compareTo(BigDecimal)
assertThatComparable(new BigDecimal("8.0")).isNotEqualByComparingTo(new BigDecimal("8.00"));other - the given value to compare the actual value to.this assertion object.AssertionError - if the actual value is null.AssertionError - if the actual value is equal when comparing to the given one.public SELF isLessThan(T other)
Example:
// assertions will pass
assertThatComparable('a').isLessThan('b');
assertThatComparable(BigInteger.ZERO).isLessThan(BigInteger.ONE);
// assertions will fail
assertThatComparable('a').isLessThan('a');
assertThatComparable(BigInteger.ONE).isLessThan(BigInteger.ZERO);other - the given value to compare the actual value to.this assertion object.AssertionError - if the actual value is null.AssertionError - if the actual value is equal to or greater than the given one.public SELF isLessThanOrEqualTo(T other)
Example:
// assertions will pass
assertThatComparable('a').isLessThanOrEqualTo('b');
assertThatComparable('a').isLessThanOrEqualTo('a');
assertThatComparable(BigInteger.ZERO).isLessThanOrEqualTo(BigInteger.ZERO);
// assertions will fail
assertThatComparable('b').isLessThanOrEqualTo('a');
assertThatComparable(BigInteger.ONE).isLessThanOrEqualTo(BigInteger.ZERO);other - the given value to compare the actual value to.this assertion object.AssertionError - if the actual value is null.AssertionError - if the actual value is greater than the given one.public SELF isGreaterThan(T other)
Example:
// assertions will pass
assertThatComparable('b').isGreaterThan('a');
assertThatComparable(BigInteger.ONE).isGreaterThan(BigInteger.ZERO);
// assertions will fail
assertThatComparable('b').isGreaterThan('a');
assertThatComparable(BigInteger.ZERO).isGreaterThan(BigInteger.ZERO);other - the given value to compare the actual value to.this assertion object.AssertionError - if the actual value is null.AssertionError - if the actual value is equal to or less than the given one.public SELF isGreaterThanOrEqualTo(T other)
Example:
// assertions will pass
assertThatComparable('b').isGreaterThanOrEqualTo('a');
assertThatComparable(BigInteger.ONE).isGreaterThanOrEqualTo(BigInteger.ONE);
// assertions will fail
assertThatComparable('a').isGreaterThanOrEqualTo('b');
assertThatComparable(BigInteger.ZERO).isGreaterThanOrEqualTo(BigInteger.ONE);other - the given value to compare the actual value to.this assertion object.AssertionError - if the actual value is null.AssertionError - if the actual value is less than the given one.public SELF isBetween(T startInclusive, T endInclusive)
Example:
// assertions succeed
assertThatComparable('b').isBetween('a', 'c');
assertThatComparable('a').isBetween('a', 'b');
assertThatComparable('b').isBetween('a', 'b');
// assertions fail
assertThatComparable('a').isBetween('b', 'c');
assertThatComparable('c').isBetween('a', 'b');startInclusive - the start value (inclusive), expected not to be null.endInclusive - the end value (inclusive), expected not to be null.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.public SELF isStrictlyBetween(T startExclusive, T endExclusive)
Example:
// assertion succeeds
assertThatComparable('b').isStrictlyBetween('a', 'c');
// assertions fail
assertThatComparable('d').isStrictlyBetween('a', 'c');
assertThatComparable('a').isStrictlyBetween('b', 'd');
assertThatComparable('a').isStrictlyBetween('a', 'b');
assertThatComparable('b').isStrictlyBetween('a', 'b');startExclusive - the start value (exclusive), expected not to be null.endExclusive - the end value (exclusive), expected not to be null.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.public SELF usingComparator(Comparator<? super Comparable<T>> customComparator)
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);usingComparator in interface Assert<SELF extends AbstractUniversalComparableAssert<SELF,T>,Comparable<T>>usingComparator in class AbstractAssert<SELF extends AbstractUniversalComparableAssert<SELF,T>,Comparable<T>>customComparator - the comparator to use for the incoming assertion checks.this assertion object.public SELF usingComparator(Comparator<? super Comparable<T>> customComparator, String customComparatorDescription)
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);usingComparator in interface Assert<SELF extends AbstractUniversalComparableAssert<SELF,T>,Comparable<T>>usingComparator in class AbstractAssert<SELF extends AbstractUniversalComparableAssert<SELF,T>,Comparable<T>>customComparator - the comparator to use for the incoming assertion checks.customComparatorDescription - comparator description to be used in assertion error messagesthis assertion object.public SELF usingDefaultComparator()
This method should be used to disable a custom comparison strategy set by calling usingComparator.
usingDefaultComparator in interface Assert<SELF extends AbstractUniversalComparableAssert<SELF,T>,Comparable<T>>usingDefaultComparator in class AbstractAssert<SELF extends AbstractUniversalComparableAssert<SELF,T>,Comparable<T>>this assertion object.public SELF inHexadecimal()
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']">inHexadecimal in class AbstractAssert<SELF extends AbstractUniversalComparableAssert<SELF,T>,Comparable<T>>this assertion object.public SELF inBinary()
Example:
assertThat(1).inBinary().isEqualTo(2);
org.junit.ComparisonFailure:
Expected :0b00000000_00000000_00000000_00000010
Actual :0b00000000_00000000_00000000_00000001inBinary in class AbstractAssert<SELF extends AbstractUniversalComparableAssert<SELF,T>,Comparable<T>>this assertion object.Copyright © 2025. All rights reserved.