Top Description Fields Constructors Methods
org.assertj.core.api

public abstract Class AbstractUniversalComparableAssert<SELF extends AbstractUniversalComparableAssert<SELF, T>, T>

extends AbstractObjectAssert<SELF extends AbstractUniversalComparableAssert<SELF, T>, Comparable<T>>
Class Inheritance
Known Direct Subclasses
org.assertj.core.api.UniversalComparableAssert
Imports
java.math.BigDecimal, java.util.Comparator, org.assertj.core.internal.Comparables, .ComparatorBasedComparisonStrategy, org.assertj.core.util.CheckReturnValue, .VisibleForTesting
Base class for 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);
Since
3.23.0
See Also
Assertions#assertThatComparable(Comparable)

Field Summary

Modifier and TypeField and Description
pack-priv Comparables
comparables

Constructor Summary

AccessConstructor and Description
protected
AbstractUniversalComparableAssert(Comparable<T> actual, Class<?> selfType)

Method Summary

Modifier and TypeMethod and Description
public SELF
inBinary()

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

Use binary object representation instead of standard representation in error messages.
public SELF
inHexadecimal()

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

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

Returns:

this assertion object.
isBetween(T
the start value (inclusive), expected not to be null.
startInclusive, T
the end value (inclusive), expected not to be null.
endInclusive)

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

public SELF

Returns:

this assertion object.
isEqualByComparingTo(T
the given value to compare the actual value to.
other)

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

public SELF

Returns:

this assertion object.
isGreaterThan(T
the given value to compare the actual value to.
other)

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

public SELF

Returns:

this assertion object.
isGreaterThanOrEqualTo(T
the given value to compare the actual value to.
other)

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

public SELF

Returns:

this assertion object.
isLessThan(T
the given value to compare the actual value to.
other)

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

public SELF

Returns:

this assertion object.
isLessThanOrEqualTo(T
the given value to compare the actual value to.
other)

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

public SELF

Returns:

this assertion object.
isNotEqualByComparingTo(T
the given value to compare the actual value to.
other)

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

public SELF

Returns:

this assertion object.
isStrictlyBetween(T
the start value (exclusive), expected not to be null.
startExclusive, T
the end value (exclusive), expected not to be null.
endExclusive)

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

public SELF
usingComparator(Comparator<? super Comparable<T>>
the comparator to use for the incoming assertion checks.
customComparator)

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

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

Use the given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
public SELF
usingComparator(Comparator<? super Comparable<T>>
the comparator to use for the incoming assertion checks.
customComparator, String
comparator description to be used in assertion error messages
customComparatorDescription)

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

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

Use the given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
public SELF
usingDefaultComparator()

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

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

Revert to standard comparison for the incoming assertion checks.
Inherited from org.assertj.core.api.AbstractObjectAssert:
asasdoesNotReturnextractingextractingextractingextractingextractingextractingextractingForProxygetComparatorsByTypehasAllNullFieldsOrPropertieshasAllNullFieldsOrPropertiesExcepthasFieldOrPropertyhasFieldOrPropertyWithValuehasNoNullFieldsOrPropertieshasNoNullFieldsOrPropertiesExcepthasOnlyFieldsisEqualToComparingFieldByFieldisEqualToComparingFieldByFieldRecursivelyisEqualToComparingOnlyGivenFieldsisEqualToIgnoringGivenFieldsisEqualToIgnoringNullFieldsnewObjectAssertreturnsusingComparatorForFieldsusingComparatorForTypeusingRecursiveAssertionusingRecursiveAssertionusingRecursiveComparisonusingRecursiveComparisonwithAssertionStatewithComparatorByPropertyOrFieldwithTypeComparator

Field Detail

comparablesback to summary
pack-priv Comparables comparables
Annotations
@VisibleForTesting

Constructor Detail

AbstractUniversalComparableAssertback to summary
protected AbstractUniversalComparableAssert(Comparable<T> actual, Class<?> selfType)

Method Detail

inBinaryback to summary
public SELF inBinary()

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
inHexadecimalback to summary
public SELF inHexadecimal()

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:
  <"μμμ">
With Hexadecimal message: 
 assertThat("µµµ").inHexadecimal().contains("μμμ");

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

this assertion object.

Annotations
@Override
@CheckReturnValue
isBetweenback to summary
public SELF isBetween(T startInclusive, T endInclusive)

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

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');
Parameters
startInclusive:T

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

endInclusive:T

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

Returns:SELF

this assertion object.

Exceptions
AssertionError:
  • if the actual value is null.
  • if the actual value is not in [start, end] range.
NullPointerException:
  • if start value is null.
  • if end value is null.
isEqualByComparingToback to summary
public SELF isEqualByComparingTo(T other)

Verifies that the actual value is equal to the given one by invoking 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));
Parameters
other:T

the given value to compare the actual value to.

Returns:SELF

this assertion object.

Exceptions
AssertionError:
  • if the actual value is null.
  • if the actual value is not equal when comparing to the given one.
isGreaterThanback to summary
public SELF isGreaterThan(T other)

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

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);
Parameters
other:T

the given value to compare the actual value to.

Returns:SELF

this assertion object.

Exceptions
AssertionError:
  • if the actual value is null.
  • if the actual value is equal to or less than the given one.
isGreaterThanOrEqualToback to summary
public SELF isGreaterThanOrEqualTo(T other)

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

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);
Parameters
other:T

the given value to compare the actual value to.

Returns:SELF

this assertion object.

Exceptions
AssertionError:
  • if the actual value is null.
  • if the actual value is less than the given one.
isLessThanback to summary
public SELF isLessThan(T other)

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

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);
Parameters
other:T

the given value to compare the actual value to.

Returns:SELF

this assertion object.

Exceptions
AssertionError:
  • if the actual value is null.
  • if the actual value is equal to or greater than the given one.
isLessThanOrEqualToback to summary
public SELF isLessThanOrEqualTo(T other)

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

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);
Parameters
other:T

the given value to compare the actual value to.

Returns:SELF

this assertion object.

Exceptions
AssertionError:
  • if the actual value is null.
  • if the actual value is greater than the given one.
isNotEqualByComparingToback to summary
public SELF isNotEqualByComparingTo(T other)

Verifies that the actual value is not equal to the given one by invoking 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"));
Parameters
other:T

the given value to compare the actual value to.

Returns:SELF

this assertion object.

Exceptions
AssertionError:
  • if the actual value is null.
  • if the actual value is equal when comparing to the given one.
isStrictlyBetweenback to summary
public SELF isStrictlyBetween(T startExclusive, T endExclusive)

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

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');
Parameters
startExclusive:T

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

endExclusive:T

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

Returns:SELF

this assertion object.

Exceptions
AssertionError:
  • if the actual value is null.
  • if the actual value is not in ]start, end[ range.
NullPointerException:
  • if start value is null.
  • if end value is null.
usingComparatorback to summary
public SELF usingComparator(Comparator<? super Comparable<T>> customComparator)

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 Comparable<T>>

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
usingComparatorback to summary
public SELF usingComparator(Comparator<? super Comparable<T>> customComparator, String customComparatorDescription)

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 Comparable<T>>

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
usingDefaultComparatorback to summary
public SELF usingDefaultComparator()

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