Package org.assertj.core.api

Class AbstractCharSequenceAssert<SELF extends AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>

java.lang.Object
org.assertj.core.api.AbstractAssert<SELF,ACTUAL>
org.assertj.core.api.AbstractCharSequenceAssert<SELF,ACTUAL>
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.
ACTUAL - the type of the "actual" value.
All Implemented Interfaces:
Assert<SELF,ACTUAL>, Descriptable<SELF>, EnumerableAssert<SELF,Character>, ExtensionPoints<SELF,ACTUAL>
Direct Known Subclasses:
AbstractStringAssert, CharSequenceAssert
public abstract class AbstractCharSequenceAssert<SELF extends AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence> extends AbstractAssert<SELF,ACTUAL> implements EnumerableAssert<SELF,Character>
Base class for all implementations of assertions for CharSequences.
Author:
Yvonne Wang, David DIDIER, Alex Ruiz, Joel Costigliola, Mikhail Mazursky, Nicolas Francois, Daniel Weber

  • Constructor Details

    • AbstractCharSequenceAssert

      protected AbstractCharSequenceAssert(ACTUAL actual, Class<?> selfType)

  • Method Details

    • isNullOrEmpty

      public void isNullOrEmpty()
      Verifies that the actual CharSequence is empty, i.e., it has a length of 0, or is null.

      If you do not want to accept a null value, use isEmpty() instead.

      Both of these assertions will succeed: 

       String emptyString = ""
 assertThat(emptyString).isNullOrEmpty();

 String nullString = null;
 assertThat(nullString).isNullOrEmpty();
      Whereas these assertions will fail: 
       assertThat("a").isNullOrEmpty();
 assertThat("   ").isNullOrEmpty();
      Specified by:
      isNullOrEmpty in interface EnumerableAssert<SELF extends AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>
      Throws:
      AssertionError - if the actual CharSequence has a non-zero length.

    • isEmpty

      public void isEmpty()
      Verifies that the actual CharSequence is empty, i.e., it has a length of 0 and is not null.

      If you want to accept a null value as well as a 0 length, use isNullOrEmpty() instead.

      This assertion will succeed: 

       String emptyString = ""
 assertThat(emptyString).isEmpty();
      Whereas these assertions will fail: 
       String nullString = null;
 assertThat(nullString).isEmpty();
 assertThat("a").isEmpty();
 assertThat("   ").isEmpty();
      Specified by:
      isEmpty in interface EnumerableAssert<SELF extends AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>
      Throws:
      AssertionError - if the actual CharSequence has a non-zero length or is null.

    • isNotEmpty

      public SELF isNotEmpty()
      Verifies that the actual CharSequence is not empty, i.e., is not null and has a length of 1 or more.

      This assertion will succeed: 

       String bookName = "A Game of Thrones"
 assertThat(bookName).isNotEmpty();
      Whereas these assertions will fail: 
       String emptyString = ""
 assertThat(emptyString).isNotEmpty();

 String nullString = null;
 assertThat(nullString).isNotEmpty();
      Specified by:
      isNotEmpty in interface EnumerableAssert<SELF extends AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is empty (has a length of 0).

    • isBlank

      public SELF isBlank()
      Verifies that the actual CharSequence is blank, i.e. is null, empty or consists of one or more whitespace characters (according to Character.isWhitespace(char)).

      The definition of this method has changed, the old behaviour is now under containsOnlyWhitespaces().

      These assertions succeed: 

       assertThat(" ").isBlank();
 assertThat("").isBlank();
 assertThat("    ").isBlank();
 String nullString = null;
 assertThat(nullString).isBlank();
      Whereas these assertions fail: 
       assertThat("a").isBlank();
 assertThat(" b").isBlank();
 assertThat(" c ").isBlank();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not blank.
      Since:
      2.6.0 / 3.6.0

    • isNotBlank

      public SELF isNotBlank()
      Verifies that the actual CharSequence is:

      The definition of this method has changed, the old behaviour is now under doesNotContainOnlyWhitespaces().

      These assertions succeed: 

       assertThat("a").isNotBlank();
 assertThat(" b").isNotBlank();
 assertThat(" c ").isNotBlank();
      Whereas these assertions fail: 
       assertThat(" ").isNotBlank();
 assertThat("").isNotBlank();
 assertThat("    ").isNotBlank();
 String nullString = null;
 assertThat(nullString).isNotBlank();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is blank.
      Since:
      2.6.0 / 3.6.0

    • containsWhitespaces

      public SELF containsWhitespaces()
      Verifies that the actual CharSequence contains one or more whitespace characters (according to Character.isWhitespace(char)).

      These assertions will succeed: 

       assertThat(" ").containsWhitespaces();
 assertThat("a b").containsWhitespaces();
 assertThat(" c ").containsWhitespaces();
      Whereas these assertions will fail: 
       assertThat("").containsWhitespaces();
 assertThat("a").containsWhitespaces();
 String nullString = null;
 assertThat(nullString).containsWhitespaces();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence does not contain any whitespace characters.
      Since:
      3.11.0

    • containsOnlyWhitespaces

      public SELF containsOnlyWhitespaces()
      Verifies that the actual CharSequence consists of one or more whitespace characters (according to Character.isWhitespace(char)).

      These assertions will succeed: 

       assertThat(" ").containsOnlyWhitespaces();
 assertThat("    ").containsOnlyWhitespaces();
      Whereas these assertions will fail: 
       assertThat("a").containsOnlyWhitespaces();
 assertThat("").containsOnlyWhitespaces();
 assertThat(" b").containsOnlyWhitespaces();
 assertThat(" c ").containsOnlyWhitespaces();

 String nullString = null;
 assertThat(nullString).containsOnlyWhitespaces();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not blank.
      Since:
      2.9.0 / 3.9.0

    • doesNotContainAnyWhitespaces

      public SELF doesNotContainAnyWhitespaces()
      Verifies that the actual CharSequence is either null, empty or does not contain any whitespace characters (according to Character.isWhitespace(char)).

      These assertions will succeed: 

       assertThat("a").doesNotContainAnyWhitespaces();
 assertThat("").doesNotContainAnyWhitespaces();
 assertThat("ab").doesNotContainAnyWhitespaces();

 String nullString = null;
 assertThat(nullString).doesNotContainAnyWhitespaces();
      Whereas these assertions will fail: 
       assertThat(" ").doesNotContainAnyWhitespaces();
 assertThat(" a").doesNotContainAnyWhitespaces();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence contains one or more whitespace characters.
      Since:
      3.11.0

    • doesNotContainOnlyWhitespaces

      public SELF doesNotContainOnlyWhitespaces()
      Verifies that the actual CharSequence is either:

      The main difference with isNotBlank() is that it accepts null or empty CharSequence.

      These assertions will succeed: 

       assertThat("a").doesNotContainOnlyWhitespaces();
 assertThat("").doesNotContainOnlyWhitespaces();
 assertThat(" b").doesNotContainOnlyWhitespaces();
 assertThat(" c ").doesNotContainOnlyWhitespaces();
 String nullString = null;
 assertThat(nullString).doesNotContainOnlyWhitespaces();
      Whereas these assertions will fail: 
       assertThat(" ").doesNotContainOnlyWhitespaces();
 assertThat("    ").doesNotContainOnlyWhitespaces();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is blank.
      Since:
      2.9.0 / 3.9.0

    • isJavaBlank

      @Deprecated public SELF isJavaBlank()
      Deprecated.
      Use isBlank() instead.
      Verifies that the actual CharSequence is blank, i.e. consists of one or more whitespace characters (according to Character.isWhitespace(char)).

      These assertions will succeed: 

       assertThat(" ").isJavaBlank();
 assertThat("     ").isJavaBlank();
      Whereas these assertions will fail: 
       assertThat("a").isJavaBlank();
 assertThat(" b").isJavaBlank();
 assertThat("").isJavaBlank();
 String nullString = null;
 assertThat(nullString).isJavaBlank();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not blank.
      Since:
      2.6.0 / 3.6.0

    • isNotJavaBlank

      @Deprecated public SELF isNotJavaBlank()
      Deprecated.
      Use isNotBlank() instead.
      Verifies that the actual CharSequence is not blank, i.e. either is null, empty or contains at least one non-whitespace character (according to Character.isWhitespace(char)).

      These assertions will succeed: 

       assertThat("a").isNotJavaBlank();
 assertThat(" b").isNotJavaBlank();
 assertThat(" c ").isNotJavaBlank();
 assertThat("").isNotJavaBlank();
 String nullString = null;
 assertThat(nullString).isNotJavaBlank();
      Whereas these assertions will fail: 
       assertThat(" ").isNotJavaBlank();
 assertThat("   ").isNotJavaBlank();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is blank.
      Since:
      2.6.0 / 3.6.0

    • hasSize

      public SELF hasSize(int expected)
      Verifies that the actual CharSequence has the expected length using the length() method.

      This assertion will succeed: 

       String bookName = "A Game of Thrones"
 assertThat(bookName).hasSize(17);
      Whereas this assertion will fail: 
       String bookName = "A Clash of Kings"
 assertThat(bookName).hasSize(4);
      Specified by:
      hasSize in interface EnumerableAssert<SELF extends AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>
      Parameters:
      expected - the expected length of the actual CharSequence.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual length is not equal to the expected length.

    • hasSizeLessThan

      public SELF hasSizeLessThan(int expected)
      Verifies that the actual CharSequence has has a length less than the given value using the length() method.

      This assertion will succeed: 

      assertThat("abc").hasSizeLessThan(4);
      Whereas this assertion will fail: 
      assertThat("abc").hasSizeLessThan(3);
      Specified by:
      hasSizeLessThan in interface EnumerableAssert<SELF extends AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>
      Parameters:
      expected - the expected maximum length of the actual CharSequence.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual length is equal or greater than the expected length.
      Since:
      3.12.0

    • hasSizeLessThanOrEqualTo

      public SELF hasSizeLessThanOrEqualTo(int expected)
      Verifies that the actual CharSequence has a length less than or equal to the given value using the length() method.

      This assertion will succeed: 

      assertThat("abc").hasSizeLessThanOrEqualTo(3);
      Whereas this assertion will fail: 
      assertThat("abc").hasSizeLessThanOrEqualTo(2);
      Specified by:
      hasSizeLessThanOrEqualTo in interface EnumerableAssert<SELF extends AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>
      Parameters:
      expected - the expected maximum length of the actual CharSequence.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual length is greater than the expected length.
      Since:
      3.12.0

    • hasSizeGreaterThan

      public SELF hasSizeGreaterThan(int expected)
      Verifies that the actual CharSequence has a length greater than the given value using the length() method.

      This assertion will succeed: 

      assertThat("abcs").hasSizeGreaterThan(2);
      Whereas this assertion will fail: 
      assertThat("abc").hasSizeGreaterThan(3);
      Specified by:
      hasSizeGreaterThan in interface EnumerableAssert<SELF extends AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>
      Parameters:
      expected - the expected minimum length of the actual CharSequence.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual length is equal or less than the expected length.
      Since:
      3.12.0

    • hasSizeGreaterThanOrEqualTo

      public SELF hasSizeGreaterThanOrEqualTo(int expected)
      Verifies that the actual CharSequence has a length greater than or equal to the given value using the length() method.

      This assertion will succeed: 

      assertThat("abc").hasSizeGreaterThanOrEqualTo(3);
      Whereas this assertion will fail: 
      assertThat("abc").hasSizeGreaterThanOrEqualTo(3);
      Specified by:
      hasSizeGreaterThanOrEqualTo in interface EnumerableAssert<SELF extends AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>
      Parameters:
      expected - the expected minimum length of the actual CharSequence.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual length is less than the expected length.
      Since:
      3.12.0

    • hasSizeBetween

      public SELF hasSizeBetween(int lowerBoundary, int higherBoundary)
      Verifies that the actual CharSequence has length between the given boundaries (inclusive) using the length() method.

      This assertion will succeed: 

       String bookName = "A Game of Thrones"
 assertThat(bookName).hasSizeBetween(5, 25);
 assertThat(bookName).hasSizeBetween(16, 17);
      Whereas this assertion will fail: 
       String bookName = "A Clash of Kings"
 assertThat(bookName).hasSizeBetween(2, 5);
      Specified by:
      hasSizeBetween in interface EnumerableAssert<SELF extends AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>
      Parameters:
      lowerBoundary - the lower boundary compared to which actual length should be greater than or equal to.
      higherBoundary - the higher boundary compared to which actual length should be less than or equal to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual length is not between the boundaries.
      Since:
      3.12.0

    • hasLineCount

      public SELF hasLineCount(int expectedLineCount)
      Verifies that the actual CharSequence has the expected line count.

      A line is considered to be terminated by any one of a line feed ('\n'), a carriage return ('\r'), or a carriage return followed immediately by a linefeed (see LineNumberReader).

      This assertion will succeed: 

       String multiLine = "First line\n" +
                    "Last line";
 assertThat(multiLine).hasLineCount(2);
      Whereas this assertion will fail: 
       String bookName = "A Clash of Kings";
 assertThat(bookName).hasLineCount(3);
      Parameters:
      expectedLineCount - the expected line count of the actual CharSequence.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual line count is not equal to the expected one.

    • hasSameSizeAs

      public SELF hasSameSizeAs(CharSequence other)
      Verifies that the actual CharSequence has a length that's the same as the length of the given CharSequence.

      Examples : 

       // assertion will pass
 assertThat("C-3PO").hasSameSizeAs("R2-D2");

 // assertion will fail as actual and expected sizes differ
 assertThat("C-3PO").hasSameSizeAs("B1 battle droid");
      Parameters:
      other - the given CharSequence to be used for size comparison.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence has a length that's different from the length of the given CharSequence.
      NullPointerException - if the given CharSequence is null.

    • hasSameSizeAs

      public SELF hasSameSizeAs(Object other)
      Verifies that the actual CharSequence has a length that's the same as the number of elements in the given array.

      Example: 

       // assertion will pass
 assertThat("12").hasSameSizeAs(new char[] { 'a', 'b' });

 // assertion will fail
 assertThat("12").hasSameSizeAs(new char[] { 'a', 'b', 'c' });
      Specified by:
      hasSameSizeAs in interface EnumerableAssert<SELF extends AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>
      Parameters:
      other - the given array to be used for size comparison.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence has a length that's different from the number of elements in the array.
      NullPointerException - if the given array is null.

    • hasSameSizeAs

      public SELF hasSameSizeAs(Iterable<?> other)
      Verifies that the actual CharSequence has a length that's the same as the number of elements in the given Iterable.

      Example: 

       // assertion will pass
 assertThat("abc").hasSameSizeAs(Arrays.asList(1, 2, 3));

 // assertion will fail
 assertThat("ab").hasSameSizeAs(Arrays.asList(1, 2, 3));
      Specified by:
      hasSameSizeAs in interface EnumerableAssert<SELF extends AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>
      Parameters:
      other - the given Iterable to be used for size comparison.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence has a length that's different from the number of elements in the Iterable.
      NullPointerException - if the given Iterable is null.

    • isEqualToIgnoringCase

      public SELF isEqualToIgnoringCase(CharSequence expected)
      Verifies that the actual CharSequence is equal to the given one, ignoring case considerations.

      Example: 

       // assertion will pass
 assertThat("Gandalf the grey").isEqualToIgnoringCase("GaNdAlF tHe GREY");
 assertThat("Gandalf the grey").isEqualToIgnoringCase("Gandalf the grey");

 // assertion will fail
 assertThat("Gandalf the grey").isEqualToIgnoringCase("Gandalf the white");
      Parameters:
      expected - the given CharSequence to compare the actual CharSequence to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not equal to the given one.

    • isNotEqualToIgnoringCase

      public SELF isNotEqualToIgnoringCase(CharSequence expected)
      Verifies that the actual CharSequence is not equal to the given one, ignoring case considerations.

      Example: 

       // assertions will pass
 assertThat("Gandalf").isNotEqualToIgnoringCase("Hobbit");
 assertThat("Gandalf").isNotEqualToIgnoringCase("HOBit");
 assertThat((String) null).isNotEqualToIgnoringCase("Gandalf");
 assertThat("Gandalf").isNotEqualToIgnoringCase(null);

 // assertions will fail
 assertThat("Gandalf").isNotEqualToIgnoringCase("Gandalf");
 assertThat("Gandalf").isNotEqualToIgnoringCase("GaNDalf");
 assertThat((String) null).isNotEqualToIgnoringCase(null);
      Parameters:
      expected - the given CharSequence to compare the actual CharSequence to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not equal to the given one.

    • containsOnlyDigits

      public SELF containsOnlyDigits()
      Verifies that the actual CharSequence contains only digits. It fails if it contains non-digit characters or is empty.

      This assertion succeeds: 

       assertThat("10").containsOnlyDigits();
      Whereas these assertions fail: 
       assertThat("10$").containsOnlyDigits();
 assertThat("").containsOnlyDigits();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence contains non-digit characters or is null.

    • containsOnlyOnce

      public SELF containsOnlyOnce(CharSequence sequence)
      Verifies that the actual CharSequence contains the given sequence only once.

      Example: 

       // assertion will pass
 assertThat("Frodo").containsOnlyOnce("do");

 // assertions will fail
 assertThat("Frodo").containsOnlyOnce("o");
 assertThat("Frodo").containsOnlyOnce("y");
      Parameters:
      sequence - the sequence to search for.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence either does not contain the given one at all, or contains it more than once.

    • contains

      public SELF contains(CharSequence... values)
      Verifies that the actual CharSequence contains all the given values.

      You can use one or several CharSequences as in this example: 

       assertThat("Gandalf the grey").contains("alf");
 assertThat("Gandalf the grey").contains("alf", "grey");
      Parameters:
      values - the values to look for.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given list of values is null.
      IllegalArgumentException - if the list of given values is empty.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence does not contain all the given values.

    • containsAnyOf

      public SELF containsAnyOf(CharSequence... values)
      Verifies that the actual CharSequence contains any of the given values.

      Example: 

       // assertion succeeds
 assertThat("Gandalf the grey").containsAnyOf("grey", "black");

 // assertion fails
 assertThat("Gandalf the grey").containsAnyOf("white", "black");
      Parameters:
      values - the values to look for.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given list of values is null.
      IllegalArgumentException - if the list of given values is empty.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence does not contain any of the given values.
      Since:
      3.21.0

    • contains

      public SELF contains(Iterable<? extends CharSequence> values)
      Verifies that the actual CharSequence contains all the CharSequences of the given Iterable.

      Examples: 

       assertThat("Gandalf the grey").contains(Arrays.asList("alf"));
 assertThat("Gandalf the grey").contains(Arrays.asList("alf", "grey"));
      Parameters:
      values - the values to look for.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given list of values is null.
      IllegalArgumentException - if the list of given values is empty.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence does not contain all the given values.

    • containsSequence

      public SELF containsSequence(CharSequence... values)
      Verifies that the actual CharSequence contains the given sequence of values in the given order without any other values between them.

      Breaking change since 2.9.0: in previous versions this assertion behaved like containsSubsequence and allowed other values between the sequence values.

      Example: 

       String book = "{ 'title':'A Game of Thrones', 'author':'George Martin'}";

 // this assertion succeeds
 assertThat(book).containsSequence("'title'", ":", "'A Game of Thrones'");

 // this assertion will fail because there are values between the expected sequence (e.g "'title':'")
 assertThat(book).containsSequence("{", "A Game of Thrones", "George Martin", "}");

 // this one fails as ":" must come after "'title'"
 assertThat(book).containsSequence(":", "'title'", "'A Game of Thrones'");
      Parameters:
      values - the sequence of charSequence to look for, in order.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given sequence of charSequence is null.
      IllegalArgumentException - if the given sequence of charSequence is empty.
      AssertionError - if the given CharSequence is null.
      AssertionError - if the given CharSequence does not contain the given sequence of values in the given order without any other values between them.

    • containsSequence

      public SELF containsSequence(Iterable<? extends CharSequence> values)
      Verifies that the actual CharSequence contains all the values of the given Iterable in the Iterable iteration order without any other values between them.

      Breaking change since 2.9.0: in previous versions this assertion behaved like containsSubsequence and allowed other values between the sequence values.

      Example: 

       String book = "{ 'title':'A Game of Thrones', 'author':'George Martin'}";

 // this assertion succeeds
 assertThat(book).containsSequence(asList("'title'", ":", "'A Game of Thrones'"));

 // this assertion will fail because there are values between the expected sequence (e.g "'title':'")
 assertThat(book).containsSequence(asList("{", "A Game of Thrones", "George Martin", "}"));

 // this one fails as "author" must come after "A Game of Thrones"
 assertThat(book).containsSequence(asList("author", "A Game of Thrones"));
      Parameters:
      values - the sequence of charSequence to look for, in order.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given sequence of charSequence is null.
      IllegalArgumentException - if the given sequence of charSequence is empty.
      AssertionError - if the given CharSequence is null.
      AssertionError - if the given CharSequence does not contain the given sequence of values in the given order without any other charvalues between them.

    • containsSubsequence

      public SELF containsSubsequence(CharSequence... values)
      Verifies that the actual CharSequence contains all the given values in the given order, possibly with other values between them.

      Example: 

       String book = "{ 'title':'A Game of Thrones', 'author':'George Martin'}";

 // this assertion succeeds
 assertThat(book).containsSubsequence("'title'", ":", "'A Game of Thrones'");

 // these ones succeed even if there are values between the given values
 assertThat(book).containsSubsequence("{", "A Game of Thrones", "George Martin", "}");
 assertThat(book).containsSubsequence("A", "Game", "of", "George");

 // this one fails as "author" must come after "A Game of Thrones"
 assertThat(book).containsSubsequence("{", "author", "A Game of Thrones", "}");
      Parameters:
      values - the Strings to look for, in order.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given values is null.
      IllegalArgumentException - if the given values is empty.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence does not contain all the given values in the given order.

    • containsSubsequence

      public SELF containsSubsequence(Iterable<? extends CharSequence> values)
      Verifies that the actual CharSequence contains all the values of the given Iterable in the Iterable iteration order (possibly with other values between them).

      Example: 

       String book = "{ 'title':'A Game of Thrones', 'author':'George Martin'}";

 // this assertion succeeds
 assertThat(book).containsSubsequence(asList("'title'", ":", "'A Game of Thrones'"));

 // these ones succeed even if there are values between the given values
 assertThat(book).containsSubsequence(asList("{", "A Game of Thrones", "George Martin", "}"));
 assertThat(book).containsSubsequence(asList("A", "Game", "of", "George"));

 // but this one fails as "author" must come after "A Game of Thrones"
 assertThat(book).containsSubsequence(asList("{", "author", "A Game of Thrones", "}"));
      Parameters:
      values - the Strings to look for, in order.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given values is null.
      IllegalArgumentException - if the given values is empty.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence does not contain all the given values in the given order.

    • containsIgnoringCase

      public SELF containsIgnoringCase(CharSequence sequence)
      Verifies that the actual CharSequence contains the given sequence, ignoring case considerations.

      Example: 

       // assertion will pass
 assertThat("Gandalf the grey").containsIgnoringCase("gandalf");

 // assertion will fail
 assertThat("Gandalf the grey").containsIgnoringCase("white");
      Parameters:
      sequence - the sequence to search for.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given sequence is null.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence does not contain the given one.

    • containsIgnoringWhitespaces

      public SELF containsIgnoringWhitespaces(CharSequence... values)
      Verifies that the actual CharSequence contains all the given values, ignoring whitespace differences.

      You can use one or several CharSequences as in this example: 

       // assertions succeed:
 assertThat("Gandalf the grey").containsIgnoringWhitespaces("alf")
                               .containsIgnoringWhitespaces("alf", "grey")
                               .containsIgnoringWhitespaces("thegrey")
                               .containsIgnoringWhitespaces("thegr  ey")
                               .containsIgnoringWhitespaces("t h e g r\t\r\n ey");
 // assertion fails:
 assertThat("Gandalf the grey").containsIgnoringWhitespaces("alF")
      Parameters:
      values - the values to look for.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given list of values is null.
      IllegalArgumentException - if the list of given values is empty.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence does not contain all the given values.

    • containsIgnoringNewLines

      public SELF containsIgnoringNewLines(CharSequence... values)
      Verifies that the actual CharSequence contains all the given values ignoring new line differences.

      You can use one or several CharSequences as in this example: 

       // assertions succeed:
 assertThat("Gandalf\nthe\ngrey").containsIgnoringNewLines("alf")
                                 .containsIgnoringNewLines("alf", "grey")
                                 .containsIgnoringNewLines("thegrey")
                                 .containsIgnoringNewLines("thegr\ney")
                                 .containsIgnoringNewLines("t\nh\ne\ng\nr\ney");
 // assertions fail:
 assertThat("Gandalf\nthe\ngrey").containsIgnoringNewLines("alF")
 assertThat("Gandalf\nthe\ngrey").containsIgnoringNewLines("t\nh\ne\ng\nr\t\r\ney")
      Parameters:
      values - the values to look for.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given list of values is null.
      IllegalArgumentException - if the list of given values is empty.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence does not contain all the given values.

    • doesNotContain

      public SELF doesNotContain(CharSequence... values)
      Verifies that the actual CharSequence does not contain any of the given values.

      Example: 

       // assertion will pass
 assertThat("Frodo").doesNotContain("pippin")
                    .doesNotContain("fro", "sam");


 // assertion will fail
 assertThat("Frodo").doesNotContain("Fro", "Gimli", "Legolas");
      Parameters:
      values - the CharSequences to search for.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given list of values is null.
      IllegalArgumentException - if the list of given values is empty.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence contains any of the given values.

    • doesNotContain

      public SELF doesNotContain(Iterable<? extends CharSequence> values)
      Verifies that the actual CharSequence does not contain any of the given Iterable.

      Example: 

       // assertion will pass
 assertThat("Frodo").doesNotContain(Arrays.asList(""))
                    .doesNotContain(Arrays.asList("fro", "sam"));

 // assertion will fail
 assertThat("Frodo").doesNotContain(Arrays.asList("Fro", "Gimli", "Legolas"));
      Parameters:
      values - the CharSequences to search for.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given list of values is null.
      IllegalArgumentException - if the list of given values is empty.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence contains any of the given values.

    • doesNotContainIgnoringCase

      public SELF doesNotContainIgnoringCase(CharSequence... values)
      Verifies that the actual CharSequence does not contain any of the given values, ignoring case considerations.

      Example: 

       // assertions will pass
 assertThat("Frodo").doesNotContainIgnoringCase("pippin")
                    .doesNotContainIgnoringCase("Merry", "sam");

 // assertions will fail
 assertThat("Frodo").doesNotContainIgnoringCase("Fro", "Gimli", "Legolas");
 assertThat("Frodo").doesNotContainIgnoringCase("fro");
      Parameters:
      values - the CharSequences to search for.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given list of values is null.
      NullPointerException - if any one of the given values is null.
      IllegalArgumentException - if the list of given values is empty.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence contains any one of the given values, ignoring case considerations.
      Since:
      3.17.0

    • doesNotContainPattern

      public SELF doesNotContainPattern(CharSequence pattern)
      Verifies that the actual CharSequence does not contain the given regular expression.

      Example: 

       // assertion will pass
 assertThat("Frodo").doesNotContainPattern("Fr.ud");

 // assertion will fail
 assertThat("Freud").doesNotContainPattern("Fr.ud");
      Parameters:
      pattern - the regular expression to find in the actual CharSequence.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given pattern is null.
      PatternSyntaxException - if the regular expression's syntax is invalid.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the given regular expression can be found in the actual CharSequence.
      Since:
      2.7.0 / 3.7.0

    • doesNotContainPattern

      public SELF doesNotContainPattern(Pattern pattern)
      Verifies that the actual CharSequence does not contain the given regular expression.

      Example: 

       // assertion will pass
 assertThat("Frodo").doesNotContainPattern(Pattern.compile("Fr.ud"));

 // assertion will fail
 assertThat("Freud").doesNotContainPattern(Pattern.compile("Fr.ud"));
      Parameters:
      pattern - the regular expression to find in the actual CharSequence.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given pattern is null.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the given regular expression can be found in the actual CharSequence.
      Since:
      2.7.0 / 3.7.0

    • startsWith

      public SELF startsWith(CharSequence prefix)
      Verifies that the actual CharSequence starts with the given prefix.

      Example: 

       // assertions will pass
 assertThat("Frodo").startsWith("Fro");
 assertThat("Gandalf the grey").startsWith("Gandalf");

 // assertions will fail
 assertThat("Frodo").startsWith("fro");
 assertThat("Gandalf the grey").startsWith("grey");
      Parameters:
      prefix - the given prefix.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given prefix is null.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence does not start with the given prefix.

    • startsWithIgnoringCase

      public SELF startsWithIgnoringCase(CharSequence prefix)
      Verifies that the actual CharSequence starts with the given prefix, ignoring case considerations.

      Example: 

       // assertions will pass
 assertThat("Gandalf the grey").startsWithIgnoringCase("Gandalf");
 assertThat("Gandalf the grey").startsWithIgnoringCase("gandalf");

 // assertion will fail
 assertThat("Gandalf the grey").startsWithIgnoringCase("grey");
      Parameters:
      prefix - the given prefix.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given prefix is null.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence does not start with the given prefix, ignoring case.
      Since:
      3.23.0

    • doesNotStartWith

      public SELF doesNotStartWith(CharSequence prefix)
      Verifies that the actual CharSequence does not start with the given prefix.

      Example: 

       // assertions will pass
 assertThat("Frodo").doesNotStartWith("fro");
 assertThat("Gandalf the grey").doesNotStartWith("grey");

 // assertions will fail
 assertThat("Gandalf the grey").doesNotStartWith("Gandalf");
 assertThat("Frodo").doesNotStartWith("");
      Parameters:
      prefix - the given prefix.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given prefix is null.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence starts with the given prefix.

    • doesNotStartWithIgnoringCase

      public SELF doesNotStartWithIgnoringCase(CharSequence prefix)
      Verifies that the actual CharSequence does not start with the given prefix, ignoring case considerations.

      Example: 

       // assertions will pass
 assertThat("Gandalf the grey").doesNotStartWithIgnoringCase("fro");
 assertThat("Gandalf the grey").doesNotStartWithIgnoringCase("grey");

 // assertions will fail
 assertThat("Gandalf the grey").doesNotStartWithIgnoringCase("Gandalf");
 assertThat("Gandalf the grey").doesNotStartWithIgnoringCase("gandalf");
      Parameters:
      prefix - the given prefix.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given prefix is null.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence starts with the given prefix, ignoring case.
      Since:
      3.23.0

    • endsWith

      public SELF endsWith(CharSequence suffix)
      Verifies that the actual CharSequence ends with the given suffix, ignoring case considerations.

      Example: 

       // assertion will pass
 assertThat("Frodo").endsWith("do");

 // assertion will fail
 assertThat("Frodo").endsWith("Fro");
      Parameters:
      suffix - the given suffix.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given suffix is null.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence does not end with the given suffix.

    • endsWithIgnoringCase

      public SELF endsWithIgnoringCase(CharSequence suffix)
      Verifies that the actual CharSequence ends with the given suffix, ignoring case considerations.

      Example: 

       // assertions will pass
 assertThat("Frodo").endsWithIgnoringCase("do");
 assertThat("Frodo").endsWithIgnoringCase("DO");

 // assertion will fail
 assertThat("Frodo").endsWithIgnoringCase("Fro");
      Parameters:
      suffix - the given suffix.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given suffix is null.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence does not end with the given suffix, ignoring case.
      Since:
      3.23.0

    • doesNotEndWith

      public SELF doesNotEndWith(CharSequence suffix)
      Verifies that the actual CharSequence does not end with the given suffix.

      Example: 

       // assertion will pass
 assertThat("Frodo").doesNotEndWith("Fro");

 // assertions will fail
 assertThat("Frodo").doesNotEndWith("do");
 assertThat("Frodo").doesNotEndWith("");
      Parameters:
      suffix - the given suffix.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given suffix is null.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence ends with the given suffix.

    • doesNotEndWithIgnoringCase

      public SELF doesNotEndWithIgnoringCase(CharSequence suffix)
      Verifies that the actual CharSequence does not end with the given suffix, ignoring case considerations.

      Example: 

       // assertion will pass
 assertThat("Frodo").doesNotEndWithIgnoringCase("Fro");

 // assertions will fail
 assertThat("Frodo").doesNotEndWithIgnoringCase("do");
 assertThat("Frodo").doesNotEndWithIgnoringCase("DO");
      Parameters:
      suffix - the given suffix.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given suffix is null.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence ends with the given suffix, ignoring case.
      Since:
      3.23.0

    • matches

      public SELF matches(CharSequence regex)
      Verifies that the actual CharSequence matches the given regular expression.

      Example: 

       // assertion will pass
 assertThat("Frodo").matches("..o.o");

 // assertion will fail
 assertThat("Frodo").matches(".*d");
      Parameters:
      regex - the regular expression to which the actual CharSequence is to be matched.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given pattern is null.
      PatternSyntaxException - if the regular expression's syntax is invalid.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence does not match the given regular expression.

    • matchesSatisfying

      public SELF matchesSatisfying(CharSequence regex, Consumer<Matcher> matchSatisfies)
      Verifies that the actual CharSequence matches the given regular expression pattern, then accepts the given Consumer<Matcher> to do further verification on the matcher.

      Example: 

       // assertion succeeds:
 assertThat("Frodo").matchesSatisfying("..(o.o)", matcher -> assertThat(matcher.group(1)).isEqualTo("odo"));
      Parameters:
      regex - the regular expression to which the actual CharSequence is to be matched.
      matchSatisfies - a consumer of the found match to do further verification
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given pattern is null.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence does not match the given regular expression.

    • doesNotMatch

      public SELF doesNotMatch(CharSequence regex)
      Verifies that the actual CharSequence does not match the given regular expression.

      Example: 

       // assertion will pass
 assertThat("Frodo").doesNotMatch(".*d");

 // assertion will fail
 assertThat("Frodo").doesNotMatch("..o.o");
      Parameters:
      regex - the regular expression to which the actual CharSequence is to be matched.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given pattern is null.
      PatternSyntaxException - if the regular expression's syntax is invalid.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence matches the given regular expression.

    • matches

      public SELF matches(Pattern pattern)
      Verifies that the actual CharSequence matches the given regular expression pattern.

      Example: 

       // assertion will pass
 assertThat("Frodo").matches(Pattern.compile("..o.o"));

 // assertion will fail
 assertThat("Frodo").matches(Pattern.compile(".*d"));
      Parameters:
      pattern - the regular expression to which the actual CharSequence is to be matched.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given pattern is null.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence does not match the given regular expression.

    • matchesSatisfying

      public SELF matchesSatisfying(Pattern pattern, Consumer<Matcher> matchSatisfies)
      Verifies that the actual CharSequence matches the given regular expression pattern, then accepts the given Consumer<Matcher> to do further verification on the matcher.

      Example: 

       Pattern pattern = Pattern.compile("..(o.o)");

 // assertion succeeds:
 assertThat("Frodo").matchesSatisfying(pattern, matcher -> assertThat(matcher.group(1)).isEqualTo("odo"));
      Parameters:
      pattern - the regular expression to which the actual CharSequence is to be matched.
      matchSatisfies - a consumer of the found match to do further verification
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given pattern is null.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the actual CharSequence does not match the given regular expression.

    • doesNotMatch

      public SELF doesNotMatch(Pattern pattern)
      Verifies that the actual CharSequence does not match the given regular expression pattern.

      Example: 

       // assertion will pass
 assertThat("Frodo").doesNotMatch(Pattern.compile(".*d"));

 // assertion will fail
 assertThat("Frodo").doesNotMatch(Pattern.compile("..o.o"));
      Parameters:
      pattern - the regular expression to which the actual CharSequence is to be matched.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given pattern is null.
      AssertionError - if the actual CharSequence does not match the given regular expression.

    • isXmlEqualTo

      @Deprecated public SELF isXmlEqualTo(CharSequence expectedXml)
      Deprecated.
      This assertion has some limitations, for example it does not handle tab vs space and would fail if elements are the same but in a different order.
      The recommended approach is XML Unit which is able to deal with these limitations and provides many more features like XPath support and schema validation.

      Original javadoc:

      Verifies that the actual CharSequence is equal to the given XML CharSequence after both have been formatted the same way.

      Example: 

       String expectedXml =
     "<rings>\n" +
         "  <bearer>\n" +
         "    <name>Frodo</name>\n" +
         "    <ring>\n" +
         "      <name>one ring</name>\n" +
         "      <createdBy>Sauron</createdBy>\n" +
         "    </ring>\n" +
         "  </bearer>\n" +
         "</rings>";

 // No matter how your xml string is formatted, isXmlEqualTo is able to compare it's content with another xml String.
 String oneLineXml = "<rings><bearer><name>Frodo</name><ring><name>one ring</name><createdBy>Sauron</createdBy></ring></bearer></rings>";
 assertThat(oneLineXml).isXmlEqualTo(expectedXml);

 String xmlWithNewLine =
     "<rings>\n" +
         "<bearer>   \n" +
         "  <name>Frodo</name>\n" +
         "  <ring>\n" +
         "    <name>one ring</name>\n" +
         "    <createdBy>Sauron</createdBy>\n" +
         "  </ring>\n" +
         "</bearer>\n" +
         "</rings>";
 assertThat(xmlWithNewLine).isXmlEqualTo(expectedXml);

 // You can compare it with oneLineXml
 assertThat(xmlWithNewLine).isXmlEqualTo(oneLineXml);

 // Tip : use isXmlEqualToContentOf assertion to compare your XML String with the content of an XML file :
 assertThat(oneLineXml).isXmlEqualToContentOf(new File("src/test/resources/formatted.xml"));
      Parameters:
      expectedXml - the XML CharSequence to which the actual CharSequence is to be compared to.
      Returns:
      this assertion object to chain other assertions.
      Throws:
      NullPointerException - if the given CharSequence is null.
      AssertionError - if the actual CharSequence is null or is not the same XML as the given XML CharSequence.
      See Also:

    • isXmlEqualToContentOf

      @Deprecated public SELF isXmlEqualToContentOf(File xmlFile)
      Deprecated.
      Verifies that the actual CharSequence is equal to the content of the given file.

      This is an handy shortcut that calls : isXmlEqualTo(contentOf(xmlFile))

      Example: 
       // You can easily compare your XML String to the content of an XML file, whatever how formatted they are.
 String oneLineXml = "<rings><bearer><name>Frodo</name><ring><name>one ring</name><createdBy>Sauron</createdBy></ring></bearer></rings>";
 assertThat(oneLineXml).isXmlEqualToContentOf(new File("src/test/resources/formatted.xml"));
      Parameters:
      xmlFile - the file to read the expected XML String to compare with actual CharSequence
      Returns:
      this assertion object to chain other assertions.
      Throws:
      NullPointerException - if the given File is null.
      AssertionError - if the actual CharSequence is null or is not the same XML as the content of given File.

    • usingElementComparator

      @Deprecated public final SELF usingElementComparator(Comparator<? super Character> customComparator)
      Deprecated.
      Custom element Comparator is not supported for CharSequence comparison.
      Do not use this method.
      Specified by:
      usingElementComparator in interface EnumerableAssert<SELF extends AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>
      Parameters:
      customComparator - the comparator to use for incoming assertion checks.
      Returns:
      this assertion object.
      Throws:
      UnsupportedOperationException - if this method is called.

    • usingDefaultElementComparator

      @Deprecated public final SELF usingDefaultElementComparator()
      Deprecated.
      Custom element Comparator is not supported for CharSequence comparison.
      Do not use this method.
      Specified by:
      usingDefaultElementComparator in interface EnumerableAssert<SELF extends AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>
      Returns:
      this assertion object.
      Throws:
      UnsupportedOperationException - if this method is called.

    • usingComparator

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

    • usingComparator

      public SELF usingComparator(Comparator<? super ACTUAL> 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 AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>
      Overrides:
      usingComparator in class AbstractAssert<SELF extends AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>
      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 AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>
      Overrides:
      usingDefaultComparator in class AbstractAssert<SELF extends AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>
      Returns:
      this assertion object.

    • inHexadecimal

      public SELF inHexadecimal()
      Description copied from class: AbstractAssert
      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']">
      Overrides:
      inHexadecimal in class AbstractAssert<SELF extends AbstractCharSequenceAssert<SELF,ACTUAL>,ACTUAL extends CharSequence>
      Returns:
      this assertion object.

    • 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 message: 

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

 java.lang.AssertionError:
 Expecting:
   <"µµµ">
 to contain:
   <"μμμ">
      With Hexadecimal message: 
       assertThat("µµµ").inUnicode().contains("μμμ");

 java.lang.AssertionError:
 Expecting:
   <µµµ>
 to contain:
   <μμμ>
      Returns:
      this assertion object.

    • isEqualToIgnoringWhitespace

      public SELF isEqualToIgnoringWhitespace(CharSequence expected)
      Verifies that the actual CharSequence is equal to the given one, ignoring whitespace differences

      Examples : 

       // assertions will pass
 assertThat("Game of Thrones").isEqualToIgnoringWhitespace("Game   of   Thrones")
                              .isEqualToIgnoringWhitespace("  Game of   Thrones  ")
                              .isEqualToIgnoringWhitespace("  Game of Thrones  ")
                              .isEqualToIgnoringWhitespace("Gameof      Thrones")
                              .isEqualToIgnoringWhitespace("Game of\tThrones")
                              .isEqualToIgnoringWhitespace("GameofThrones");

 // assertion will fail
 assertThat("Game of Thrones").isEqualToIgnoringWhitespace("Game OF Thrones");

      This assertion behavior has changed in 2.8.0 to really ignore all whitespaces, the old behaviour has been kept in the better named isEqualToNormalizingWhitespace(CharSequence).

      Parameters:
      expected - the given CharSequence to compare the actual CharSequence to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not equal ignoring whitespace differences to the given one.

    • isNotEqualToIgnoringWhitespace

      public SELF isNotEqualToIgnoringWhitespace(CharSequence expected)
      Verifies that the actual CharSequence is not equal to the given one, ignoring whitespace differences.

      Example: 

       // assertions will pass
 assertThat(" my\tfoo bar ").isNotEqualToIgnoringWhitespace("myfoo");
 assertThat(" my\tfoo").isNotEqualToIgnoringWhitespace(" my bar");

 // assertions will fail
 assertThat("my      foo bar").isNotEqualToIgnoringWhitespace("my foo bar");
 assertThat("  my foo bar  ").isNotEqualToIgnoringWhitespace("my foo bar");
 assertThat(" my     foo bar ").isNotEqualToIgnoringWhitespace("my foo bar");
 assertThat(" my\tfoo bar ").isNotEqualToIgnoringWhitespace(" my foo bar");
 assertThat("my foo bar").isNotEqualToIgnoringWhitespace("   my foo bar   ");
      Parameters:
      expected - the given CharSequence to compare the actual CharSequence to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is equal ignoring whitespace differences to the given one.

    • isEqualToNormalizingWhitespace

      public SELF isEqualToNormalizingWhitespace(CharSequence expected)
      Verifies that the actual CharSequence is equal to the given one, after the whitespace of both strings has been normalized.
      To be exact, the following rules are applied:
      • all leading and trailing whitespace of both actual and expected strings are ignored
      • any remaining whitespace, appearing within either string, is collapsed to a single space before comparison

      Example: 

       // assertions will pass
 assertThat("Game of Thrones").isEqualToNormalizingWhitespace("Game   of   Thrones")
                              .isEqualToNormalizingWhitespace("Game of     Thrones")
                              .isEqualToNormalizingWhitespace("Game     of Thrones")
                              .isEqualToNormalizingWhitespace("  Game of Thrones  ")
                              .isEqualToNormalizingWhitespace("  Game of   Thrones  ")
                              .isEqualToNormalizingWhitespace("Game of\tThrones")
                              .isEqualToNormalizingWhitespace("Game of Thrones");

 // assertions will fail
 assertThat("Game of Thrones").isEqualToNormalizingWhitespace("Game ofThrones");
 assertThat("Game of Thrones").isEqualToNormalizingWhitespace("Gameo fThrones");
 assertThat("Game of Thrones").isEqualToNormalizingWhitespace("Gameof Thrones");
      Parameters:
      expected - the given CharSequence to compare the actual CharSequence to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not equal to the given one after whitespace has been normalized.
      Since:
      2.8.0 / 3.8.0

    • isNotEqualToNormalizingWhitespace

      public SELF isNotEqualToNormalizingWhitespace(CharSequence expected)
      Verifies that the actual CharSequence is not equal to the given one, after the whitespace of both strings has been normalized.
      To be exact, the following rules are applied:
      • all leading and trailing whitespace of both actual and expected strings are ignored
      • any remaining whitespace, appearing within either string, is collapsed to a single space before comparison

      Example: 

       // assertions will pass
 assertThat(" my\tfoo").isNotEqualToNormalizingWhitespace(" my bar");
 assertThat(" my\tfoo bar ").isNotEqualToNormalizingWhitespace(" my foobar");

 // assertions will fail
 assertThat("my      foo bar").isNotEqualToNormalizingWhitespace("my foo bar");
 assertThat("  my foo bar  ").isNotEqualToNormalizingWhitespace("my foo bar");
 assertThat(" my     foo bar ").isNotEqualToNormalizingWhitespace("my foo bar");
 assertThat(" my\tfoo bar ").isNotEqualToNormalizingWhitespace(" my foo bar");
 assertThat("my foo bar").isNotEqualToNormalizingWhitespace("   my foo bar   ");
      Parameters:
      expected - the given CharSequence to compare the actual CharSequence to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is equal to the given one after whitespace has been normalized.
      Since:
      2.8.0 / 3.8.0

    • isEqualToNormalizingPunctuationAndWhitespace

      public SELF isEqualToNormalizingPunctuationAndWhitespace(CharSequence expected)
      Verifies that the actual CharSequence is equal to the given one, after the punctuation of both strings have been normalized.

      To be exact, the following rules are applied:

      • All punctuation of actual and expected strings are ignored and whitespaces are normalized
      • Punctuation is any of the following character !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

      Example: 

       // assertions will pass
 assertThat("Game'of'Thrones").isEqualToNormalizingPunctuationAndWhitespace("GameofThrones")
 assertThat("Game of Throne's").isEqualToNormalizingPunctuationAndWhitespace("Game of Thrones")
 assertThat(":Game of Thrones:").isEqualToNormalizingPunctuationAndWhitespace("Game of Thrones")
 assertThat(":Game-of-Thrones:").isEqualToNormalizingPunctuationAndWhitespace("Game of Thrones")
 assertThat("Game of Thrones?").isEqualToNormalizingPunctuationAndWhitespace("Game of Thrones")
 assertThat("Game of Thrones!!!").isEqualToNormalizingPunctuationAndWhitespace("Game of Thrones")
 assertThat("Game of  {{(!)}}    Thrones!!!").isEqualToNormalizingPunctuationAndWhitespace("Game of Thrones")
 assertThat("{(Game)-(of)-(Thrones)!!!}").isEqualToNormalizingPunctuationAndWhitespace("GameofThrones");

 // assertions will fail
 assertThat("Game-of-Thrones").isEqualToNormalizingPunctuationAndWhitespace("Game of Thrones");
 assertThat("{Game:of:Thrones}").isEqualToNormalizingPunctuationAndWhitespace("Game of Thrones");
 assertThat("{(Game)-(of)-(Thrones)!!!}").isEqualToNormalizingPunctuationAndWhitespace("Game of Thrones");
      Parameters:
      expected - the given CharSequence to compare the actual CharSequence to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not equal to the given one after punctuation have been normalized.
      Since:
      3.16.0

    • isSubstringOf

      public SELF isSubstringOf(CharSequence sequence)
      Verifies that the actual CharSequence is a substring of the given one (opposite assertion of contains(CharSequence cs).

      Example: 

       // assertions will pass
 assertThat("Lego").isSubstringOf("Legolas");
 assertThat("Legolas").isSubstringOf("Legolas");

 // assertion will fail
 assertThat("Frodo").isSubstringOf("Frod");
      Parameters:
      sequence - the sequence that is expected to contain actual.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not a substring of the given parameter.

    • containsPattern

      public SELF containsPattern(CharSequence regex)
      Verifies that the actual CharSequence contains the given regular expression.

      Example: 

       // assertion will pass
 assertThat("Frodo").containsPattern("Fr.d");

 // assertion will fail
 assertThat("Frodo").containsPattern("Frodod");
      Parameters:
      regex - the regular expression to find in the actual CharSequence.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given pattern is null.
      PatternSyntaxException - if the regular expression's syntax is invalid.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the given regular expression cannot be found in the actual CharSequence.

    • containsPatternSatisfying

      public SELF containsPatternSatisfying(CharSequence regex, Consumer<Matcher> matchSatisfies)
      Verifies that the actual CharSequence contains the given regular expression pattern, then accepts the given Consumer<Matcher> for further verification on the matcher.

      Example : 

       // assertion succeeds:
 assertThat("Frodo").containsPatternSatisfying(".o(.o)", matcher -> assertThat(matcher.group(1)).isEqualTo("do"));
      Parameters:
      regex - the regular expression to find in the actual CharSequence.
      matchSatisfies - a consumer for further verifying the Matcher.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given pattern is null.
      PatternSyntaxException - if the regular expression's syntax is invalid.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the given regular expression cannot be found in the actual CharSequence.

    • containsPattern

      public SELF containsPattern(Pattern pattern)
      Verifies that the actual CharSequence contains the given regular expression pattern.

      Example: 

       // assertion will pass
 assertThat("Frodo").containsPattern(Pattern.compile("Fr.d"));

 // assertion will fail
 assertThat("Frodo").containsPattern(Pattern.compile("Frodod"));
      Parameters:
      pattern - the regular expression to find in the actual CharSequence.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given pattern is null.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the given regular expression cannot be found in the actual CharSequence.

    • containsPatternSatisfying

      public SELF containsPatternSatisfying(Pattern pattern, Consumer<Matcher> matchSatisfies)
      Verifies that the actual CharSequence contains the given regular expression pattern, then accepts the given Consumer<Matcher> for further verification on the matcher.

      Example : 

       Pattern pattern = Pattern.compile(".o(.o)");

 // assertion succeeds:
 assertThat("Frodo").containsPatternSatisfying(pattern, matcher -> assertThat(matcher.group(1)).isEqualTo("do"));
      Parameters:
      pattern - the regular expression to find in the actual CharSequence.
      matchSatisfies - a consumer for further verifying the Matcher.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given pattern is null.
      AssertionError - if the actual CharSequence is null.
      AssertionError - if the given regular expression cannot be found in the actual CharSequence.

    • isEqualToNormalizingNewlines

      public SELF isEqualToNormalizingNewlines(CharSequence expected)
      Verifies that the actual CharSequence is equals to another CharSequence after normalizing new line characters (i.e. '\r\n' == '\n').

      This assertion will succeed: 

       String bookName = "Lord of the Rings\r\n";
 assertThat(bookName).isEqualToNormalizingNewlines("Lord of the Rings\n");
      Whereas this assertion will fail: 
       String singleLine = "\n";
 assertThat(singleLine).isEqualToNormalizingNewlines("");
      Parameters:
      expected - the given CharSequence to compare the actual CharSequence to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence and the given CharSequence are different after new lines are normalized.
      Since:
      2.7.0 / 3.7.0

    • isEqualToIgnoringNewLines

      public SELF isEqualToIgnoringNewLines(CharSequence expected)
      Verifies that the actual CharSequence is equal to the given one after both strings new lines (\n, \r\n) have been removed.

      Example: 

       // assertions will pass
 assertThat("Some textWith new lines").isEqualToIgnoringNewLines("Some text\nWith new lines")
                                      .isEqualToIgnoringNewLines("Some text\r\nWith new lines")
                                      .isEqualToIgnoringNewLines("Some text\n\nWith new lines");

 assertThat("Some text\nWith new lines").isEqualToIgnoringNewLines("Some text\nWith new lines")
                                        .isEqualToIgnoringNewLines("Some text\r\nWith new lines")
                                        .isEqualToIgnoringNewLines("Some text\n\nWith new lines");

 // assertions will fail
 assertThat("Some text\nWith new lines").isEqualToIgnoringNewLines("Some text With new lines");
 assertThat("Some text\r\nWith new lines").isEqualToIgnoringNewLines("Some text With new lines");
      Parameters:
      expected - the given CharSequence to compare the actual CharSequence to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not equal to the given one after new lines have been removed.

    • isLowerCase

      public SELF isLowerCase()
      Verifies that the actual CharSequence is a lowercase CharSequence by comparing it to a lowercase actual built with String.toLowerCase().

      Example: 

       // assertions will pass
 assertThat("lego").isLowerCase();
 assertThat("").isLowerCase();
 assertThat(" ").isLowerCase();
 assertThat(".").isLowerCase();
 assertThat("7").isLowerCase();
 assertThat("a.7").isLowerCase();

 // assertions will fail
 assertThat("Lego").isLowerCase();
 assertThat("LEGO").isLowerCase();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not lowercase.
      See Also:

    • isMixedCase

      public SELF isMixedCase()
      Verifies that the actual CharSequence is a mixed case CharSequence, i.e., neither uppercase nor lowercase.

      If actual is empty or contains only case-independent characters, the assertion will pass.

      Example: 

       // assertions will pass
 assertThat("Capitalized").isMixedCase();
 assertThat("camelCase").isMixedCase();
 assertThat("rAndOMcAse1234").isMixedCase();
 assertThat("1@3$567").isMixedCase();
 assertThat("").isMixedCase();

 // assertions will fail
 assertThat("I AM GROOT!").isMixedCase();
 assertThat("please be quiet").isMixedCase();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not mixed case.
      Since:
      3.21.0
      See Also:

    • isUpperCase

      public SELF isUpperCase()
      Verifies that the actual CharSequence is an uppercase CharSequence by comparing it to an uppercase actual built with String.toUpperCase().

      Example: 

       // assertions will pass
 assertThat("LEGO").isUpperCase();
 assertThat("").isUpperCase();
 assertThat(" ").isUpperCase();
 assertThat(".").isUpperCase();
 assertThat("7").isUpperCase();
 assertThat("A.7").isUpperCase();

 // assertions will fail
 assertThat("Lego").isUpperCase();
 assertThat("lego").isUpperCase();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not uppercase.
      See Also:

    • isEqualToNormalizingUnicode

      public SELF isEqualToNormalizingUnicode(CharSequence expected)
      Verifies that the actual CharSequence is equal to the given one after they have been normalized according to the Normalizer.Form.NFC form, which is a canonical decomposition followed by canonical composition.

      Example: 

       // assertions succeed:

 // Ä = \u00C4 - Ä = \u0041\u0308
 assertThat("Ä").isEqualToNormalizingUnicode("Ä");
 assertThat("\u00C4").isEqualToNormalizingUnicode("\u0041\u0308");

 // Amélie = u0041\u006d\u00e9\u006c\u0069\u0065 - Amélie = \u0041\u006d\u0065\u0301\u006c\u0069\u0065
 assertThat("Amélie").isEqualToNormalizingUnicode("Amélie");

 // assertions fail:
 assertThat("ñ").isEqualToNormalizingUnicode("n");
 assertThat("Ä").isEqualToNormalizingUnicode("b");
      Parameters:
      expected - the given CharSequence to compare the actual CharSequence to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not equal to the given one after both strings have been normalized to according to the Normalizer.Form.NFC form .
      NullPointerException - if the actual CharSequence is not null and the given is.
      Since:
      3.19.0

    • isAlphabetic

      public SELF isAlphabetic()
      Verifies that the actual CharSequence is alphabetic by checking it against the \p{Alpha}+ regex pattern POSIX character classes (US-ASCII only).

      Example: 

       // assertions will pass
 assertThat("lego").isAlphabetic();
 assertThat("a").isAlphabetic();
 assertThat("Lego").isAlphabetic();

 // assertions will fail
 assertThat("1").isAlphabetic();
 assertThat(" ").isAlphabetic();
 assertThat("").isAlphabetic();
 assertThat("L3go").isAlphabetic();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not alphabetic.
      See Also:

    • isAlphanumeric

      public SELF isAlphanumeric()
      Verifies that the actual CharSequence is alphanumeric by checking it against the \p{Alnum}+ regex pattern POSIX character classes (US-ASCII only).

      Example: 

       // assertions will pass
 assertThat("lego").isAlphanumeric();
 assertThat("a1").isAlphanumeric();
 assertThat("L3go").isAlphanumeric();

 // assertions will fail
 assertThat("!").isAlphanumeric();
 assertThat("").isAlphanumeric();
 assertThat(" ").isAlphanumeric();
 assertThat("L3go!").isAlphanumeric();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not alphanumeric.
      See Also:

    • isASCII

      public SELF isASCII()
      Verifies that the actual CharSequence is ASCII by checking it against the \p{ASCII}+ regex pattern POSIX character classes (US-ASCII only).

      Example: 

       // assertions will pass
 assertThat("lego").isASCII();
 assertThat("a1").isASCII();
 assertThat("L3go").isASCII();

 // assertions will fail
 assertThat("").isASCII();
 assertThat("♪").isASCII();
 assertThat("⌃").isASCII();
 assertThat("L3go123⌃00abc").isASCII();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not ASCII.
      See Also:

    • isHexadecimal

      public SELF isHexadecimal()
      Verifies that the actual CharSequence is hexadecimal by checking it against the \p{XDigit}+ regex pattern POSIX character classes (US-ASCII only).

      Example: 

       // assertions will pass
 assertThat("A").isHexadecimal();
 assertThat("2").isHexadecimal();

 // assertions will fail
 assertThat("!").isHexadecimal();
 assertThat("").isHexadecimal();
 assertThat(" ").isHexadecimal();
 assertThat("Z").isHexadecimal();
 assertThat("L3go!").isHexadecimal();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not hexadecimal.
      See Also:

    • isPrintable

      public SELF isPrintable()
      Verifies that the actual CharSequence is printable by checking it against the \p{Print}+ regex pattern POSIX character classes (US-ASCII only).

      Example: 

       // assertions will pass
 assertThat("2").isPrintable();
 assertThat("a").isPrintable();
 assertThat("~").isPrintable();
 assertThat("").isPrintable();

 // assertions will fail
 assertThat("\t").isPrintable();
 assertThat("§").isPrintable();
 assertThat("©").isPrintable();
 assertThat("\n").isPrintable();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not printable.
      See Also:

    • isVisible

      public SELF isVisible()
      Verifies that the actual CharSequence is visible by checking it against the \p{Graph}+ regex pattern POSIX character classes (US-ASCII only).

      Example: 

       // assertions will pass
 assertThat("2").isVisible();
 assertThat("a").isVisible();
 assertThat(".").isVisible();

 // assertions will fail
 assertThat("\t").isVisible();
 assertThat("\n").isVisible();
 assertThat("").isVisible();
 assertThat(" ").isVisible();
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual CharSequence is not visible.
      See Also: