Package org.fest.assertions.api

Class StringAssert

java.lang.Object
org.fest.assertions.api.AbstractAssert<StringAssert,String>
org.fest.assertions.api.StringAssert
All Implemented Interfaces:
Assert<StringAssert,String>, Descriptable<StringAssert>, EnumerableAssert<StringAssert,String>, ExtensionPoints<StringAssert,String>
public class StringAssert extends AbstractAssert<StringAssert,String> implements EnumerableAssert<StringAssert,String>
Assertion methods for Strings.

To create a new instance of this class, invoke Assertions.assertThat(String).

Author:
Yvonne Wang, David DIDIER, Alex Ruiz, Joel Costigliola, Mikhail Mazursky, Nicolas Francois

  • Constructor Details

    • StringAssert

      protected StringAssert(String actual)

  • Method Details

    • isNullOrEmpty

      public void isNullOrEmpty()
      Verifies that the actual group of values is null or empty.
      Specified by:
      isNullOrEmpty in interface EnumerableAssert<StringAssert,String>

    • isEmpty

      public void isEmpty()
      Verifies that the actual group of values is empty.
      Specified by:
      isEmpty in interface EnumerableAssert<StringAssert,String>

    • isNotEmpty

      public StringAssert isNotEmpty()
      Verifies that the actual group of values is not empty.
      Specified by:
      isNotEmpty in interface EnumerableAssert<StringAssert,String>
      Returns:
      this assertion object.

    • hasSize

      public StringAssert hasSize(int expected)
      Verifies that the number of values in the actual group is equal to the given one.
      Specified by:
      hasSize in interface EnumerableAssert<StringAssert,String>
      Parameters:
      expected - the expected number of values in the actual group.
      Returns:
      this assertion object.

    • hasSameSizeAs

      public StringAssert hasSameSizeAs(Object[] other)
      Verifies that the actual group has the same size as given array.
      Specified by:
      hasSameSizeAs in interface EnumerableAssert<StringAssert,String>
      Parameters:
      other - the array to compare size with actual group.
      Returns:
      this assertion object.

    • hasSameSizeAs

      public StringAssert hasSameSizeAs(Iterable<?> other)
      Verifies that the actual group has the same size as given Iterable.
      Specified by:
      hasSameSizeAs in interface EnumerableAssert<StringAssert,String>
      Parameters:
      other - the Iterable to compare size with actual group.
      Returns:
      this assertion object.

    • isEqualToIgnoringCase

      public StringAssert isEqualToIgnoringCase(String expected)
      Verifies that the actual String is equal to the given one, ignoring case considerations.
      Parameters:
      expected - the given String to compare the actual String to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual String is not equal to the given one.

    • containsOnlyOnce

      public StringAssert containsOnlyOnce(String sequence)
      Verifies that the actual String contains only once the given sequence.
      Parameters:
      sequence - the sequence to search for.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual String does not contain the given one, or contain it multiple times.

    • contains

      public StringAssert contains(String sequence)
      Verifies that the actual String contains the given sequence.
      Parameters:
      sequence - the sequence to search for.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given sequence is null.
      AssertionError - if the actual String is null.
      AssertionError - if the actual String does not contain the given one.

    • containsIgnoringCase

      public StringAssert containsIgnoringCase(String sequence)
      Verifies that the actual String contains the given sequence, ignoring case considerations.
      Parameters:
      sequence - the sequence to search for.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given sequence is null.
      AssertionError - if the actual String is null.
      AssertionError - if the actual String does not contain the given one.

    • doesNotContain

      public StringAssert doesNotContain(String sequence)
      Verifies that the actual String does not contain the given sequence.
      Parameters:
      sequence - the sequence to search for.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given sequence is null.
      AssertionError - if the actual String is null.
      AssertionError - if the actual String contains the given one.

    • startsWith

      public StringAssert startsWith(String prefix)
      Verifies that the actual String starts with the given prefix.
      Parameters:
      prefix - the given prefix.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given prefix is null.
      AssertionError - if the actual String is null.
      AssertionError - if the actual String does not start with the given prefix.

    • endsWith

      public StringAssert endsWith(String suffix)
      Verifies that the actual String ends with the given suffix.
      Parameters:
      suffix - the given suffix.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given suffix is null.
      AssertionError - if the actual String is null.
      AssertionError - if the actual String does not end with the given suffix.

    • matches

      public StringAssert matches(String regex)
      Verifies that the actual String matches the given regular expression.
      Parameters:
      regex - the regular expression to which the actual String 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 String is null.
      AssertionError - if the actual String does not match the given regular expression.

    • doesNotMatch

      public StringAssert doesNotMatch(String regex)
      Verifies that the actual String does not match the given regular expression.
      Parameters:
      regex - the regular expression to which the actual String 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 String is null.
      AssertionError - if the actual String matches the given regular expression.

    • matches

      public StringAssert matches(Pattern pattern)
      Verifies that the actual String matches the given regular expression.
      Parameters:
      pattern - the regular expression to which the actual String is to be matched.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given pattern is null.
      AssertionError - if the actual String is null.
      AssertionError - if the actual String does not match the given regular expression.

    • doesNotMatch

      public StringAssert doesNotMatch(Pattern pattern)
      Verifies that the actual String does not match the given regular expression.
      Parameters:
      pattern - the regular expression to which the actual String is to be matched.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if the given pattern is null.
      AssertionError - if the actual String does not match the given regular expression.

    • usingElementComparator

      public StringAssert usingElementComparator(Comparator<? super String> customComparator)
      Use given custom comparator instead of relying on actual type A equals method to compare group elements for incoming assertion checks.

      Custom comparator is bound to assertion instance, meaning that if a new assertion is created, it will use default comparison strategy.

      Examples : 

       // compares invoices by payee 
 assertThat(invoiceList).usingComparator(invoicePayeeComparator).isEqualTo(expectedInvoiceList).
 
 // compares invoices by date, doesNotHaveDuplicates and contains both use the given invoice date comparator
 assertThat(invoiceList).usingComparator(invoiceDateComparator).doesNotHaveDuplicates().contains(may2010Invoice)
 
 // as assertThat(invoiceList) creates a new assertion, it falls back to standard comparison strategy 
 // based on Invoice's equal method to compare invoiceList elements to lowestInvoice.                                                      
 assertThat(invoiceList).contains(lowestInvoice).
 
 // standard comparison : the fellowshipOfTheRing includes Gandalf but not Sauron (believe me) ...
 assertThat(fellowshipOfTheRing).contains(gandalf)
                                .doesNotContain(sauron);
 
 // ... but if we compare only races, Sauron is in fellowshipOfTheRing because he's a Maia like Gandalf.
 assertThat(fellowshipOfTheRing).usingElementComparator(raceComparator)
                                .contains(sauron);
      Specified by:
      usingElementComparator in interface EnumerableAssert<StringAssert,String>
      Parameters:
      customComparator - the comparator to use for incoming assertion checks.
      Returns:
      this assertion object.

    • usingDefaultElementComparator

      public StringAssert usingDefaultElementComparator()
      Revert to standard comparison for incoming assertion group element checks.

      This method should be used to disable a custom comparison strategy set by calling EnumerableAssert.usingElementComparator(Comparator).

      Specified by:
      usingDefaultElementComparator in interface EnumerableAssert<StringAssert,String>
      Returns:
      this assertion object.

    • usingComparator

      public StringAssert usingComparator(Comparator<? super String> customComparator)
      Description copied from class: AbstractAssert
      Use given custom comparator instead of relying on actual type A equals method for incoming assertion checks.

      Custom comparator is bound to assertion instance, meaning that if a new assertion is created, it will use default comparison strategy.

      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<StringAssert,String>
      Overrides:
      usingComparator in class AbstractAssert<StringAssert,String>
      Parameters:
      customComparator - the comparator to use for incoming assertion checks.
      Returns:
      this assertion object.

    • usingDefaultComparator

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

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

      Specified by:
      usingDefaultComparator in interface Assert<StringAssert,String>
      Overrides:
      usingDefaultComparator in class AbstractAssert<StringAssert,String>
      Returns:
      this assertion object.