Package org.assertj.core.api

Class AbstractCharacterAssert<SELF extends AbstractCharacterAssert<SELF>>

java.lang.Object
org.assertj.core.api.AbstractAssert<SELF,ACTUAL>
org.assertj.core.api.AbstractObjectAssert<SELF,ACTUAL>
org.assertj.core.api.AbstractComparableAssert<SELF,Character>
org.assertj.core.api.AbstractCharacterAssert<SELF>
Type Parameters:
SELF - the "self" type of this assertion class. Please read "Emulating 'self types' using Java Generics to simplify fluent API implementation" for more details.
All Implemented Interfaces:
Assert<SELF,Character>, ComparableAssert<SELF,Character>, Descriptable<SELF>, ExtensionPoints<SELF,Character>
Direct Known Subclasses:
CharacterAssert
public abstract class AbstractCharacterAssert<SELF extends AbstractCharacterAssert<SELF>> extends AbstractComparableAssert<SELF,Character>
Base class for all implementations of assertions for Characters.
Author:
Yvonne Wang, David DIDIER, Ansgar Konermann, Alex Ruiz, Joel Costigliola, Mikhail Mazursky

  • Constructor Details

    • AbstractCharacterAssert

      protected AbstractCharacterAssert(Character actual, Class<?> selfType)

  • Method Details

    • isEqualTo

      public SELF isEqualTo(char expected)
      Verifies that the actual value is equal to the given one.

      Example: 

       // assertion will pass
 assertThat('a').isEqualTo('a');

 // assertions will fail
 assertThat('a').isEqualTo('b');
 assertThat('a').isEqualTo('A');
      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.

    • isNotEqualTo

      public SELF isNotEqualTo(char other)
      Verifies that the actual value is not equal to the given one.

      Example: 

       // assertions will pass
 assertThat('a').isNotEqualTo('b');
 assertThat('a').isNotEqualTo('A');

 // assertion will fail
 assertThat('a').isNotEqualTo('a');
      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 SELF isLessThan(char other)
      Verifies that the actual value is less than the given one.

      Example: 

       // assertions will pass
 assertThat('A').isLessThan('a');
 assertThat('a').isLessThan('b');

 // assertions will fail
 assertThat('a').isLessThan('A');
 assertThat('b').isLessThan('a');
 assertThat('a').isLessThan('a');
      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 SELF isLessThanOrEqualTo(char other)
      Verifies that the actual value is less than or equal to the given one.

      Example: 

       // assertions will pass
 assertThat('A').isLessThanOrEqualTo('a');
 assertThat('A').isLessThanOrEqualTo('A');

 // assertion will fail
 assertThat('b').isLessThanOrEqualTo('a');
      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 SELF isGreaterThan(char other)
      Verifies that the actual value is greater than the given one.

      Example: 

       // assertions will pass
 assertThat('a').isGreaterThan('A');
 assertThat('b').isGreaterThan('a');

 // assertions will fail
 assertThat('A').isGreaterThan('a');
 assertThat('a').isGreaterThan('b');
 assertThat('a').isGreaterThan('a');
      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.

    • inUnicode

      public SELF inUnicode()
      Use unicode character 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 error message: 

       assertThat('µ').isEqualTo('μ');

 org.junit.ComparisonFailure:
 Expected :'μ'
 Actual   :'µ'
      With unicode based error message: 
       assertThat('µ').inUnicode().isEqualTo('μ');

 org.junit.ComparisonFailure:
 Expected :μ
 Actual   :µ
      Returns:
      this assertion object.

    • isGreaterThanOrEqualTo

      public SELF isGreaterThanOrEqualTo(char other)
      Verifies that the actual value is greater than or equal to the given one.

      Example: 

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

 // assertion will fail
 assertThat('a').isGreaterThanOrEqualTo('b');
      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.

    • isLowerCase

      public SELF isLowerCase()
      Verifies that the actual value is a lowercase character.

      Example: 

       // assertion will pass
 assertThat('a').isLowerCase();

 // assertions will fail
 assertThat('A').isLowerCase();
 assertThat(' ').isLowerCase();
 assertThat('.').isLowerCase();
 assertThat('1').isLowerCase();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual value is null.
      AssertionError - if the actual value is not a lowercase character.

    • isUpperCase

      public SELF isUpperCase()
      Verifies that the actual value is a uppercase character.

      Example: 

       // assertion will pass
 assertThat('A').isUpperCase();

 // assertions will fail
 assertThat('a').isUpperCase();
 assertThat(' ').isUpperCase();
 assertThat('.').isUpperCase();
 assertThat('1').isUpperCase();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual value is null.
      AssertionError - if the actual value is not a uppercase character.

    • usingComparator

      public SELF usingComparator(Comparator<? super Character> 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<SELF extends AbstractCharacterAssert<SELF>,Character>
      Overrides:
      usingComparator in class AbstractComparableAssert<SELF extends AbstractCharacterAssert<SELF>,Character>
      Parameters:
      customComparator - the comparator to use for the incoming assertion checks.
      Returns:
      this assertion object.

    • usingComparator

      public SELF usingComparator(Comparator<? super Character> 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<SELF extends AbstractCharacterAssert<SELF>,Character>
      Overrides:
      usingComparator in class AbstractComparableAssert<SELF extends AbstractCharacterAssert<SELF>,Character>
      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.

    • usingDefaultComparator

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

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

      Specified by:
      usingDefaultComparator in interface Assert<SELF extends AbstractCharacterAssert<SELF>,Character>
      Overrides:
      usingDefaultComparator in class AbstractComparableAssert<SELF extends AbstractCharacterAssert<SELF>,Character>
      Returns:
      this assertion object.