org.assertj.core.api

Class StringAssert

java.lang.Object

org.assertj.core.api.AbstractAssert<StringAssert,String>

org.assertj.core.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

Field Summary

Fields inherited from class org.assertj.core.api.AbstractAssert

actual, info, myself

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	StringAssert(String actual)

Method Summary

Methods

Modifier and Type	Method and Description
StringAssert	contains(String... values) Verifies that the actual String contains all the given strings.
StringAssert	containsIgnoringCase(String sequence) Verifies that the actual String contains the given sequence, ignoring case considerations.
StringAssert	containsOnlyOnce(String sequence) Verifies that the actual String contains only once the given sequence.
StringAssert	containsSequence(String... values) Verifies that the actual String contains all the given strings in the given order.
StringAssert	doesNotContain(String sequence) Verifies that the actual String does not contain the given sequence.
StringAssert	doesNotMatch(Pattern pattern) Verifies that the actual String does not match the given regular expression.
StringAssert	doesNotMatch(String regex) Verifies that the actual String does not match the given regular expression.
StringAssert	endsWith(String suffix) Verifies that the actual String ends with the given suffix.
StringAssert	hasSameSizeAs(Iterable<?> other) Verifies that the actual group has the same size as given Iterable.
StringAssert	hasSameSizeAs(Object[] other) Verifies that the actual group has the same size as given array.
StringAssert	hasSize(int expected) Verifies that the number of values in the actual group is equal to the given one.
void	isEmpty() Verifies that the actual group of values is empty.
StringAssert	isEqualToIgnoringCase(String expected) Verifies that the actual String is equal to the given one, ignoring case considerations.
StringAssert	isNotEmpty() Verifies that the actual group of values is not empty.
void	isNullOrEmpty() Verifies that the actual group of values is null or empty.
StringAssert	matches(Pattern pattern) Verifies that the actual String matches the given regular expression.
StringAssert	matches(String regex) Verifies that the actual String matches the given regular expression.
StringAssert	startsWith(String prefix) Verifies that the actual String starts with the given prefix.
StringAssert	usingComparator(Comparator<? super String> customComparator) Use given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
StringAssert	usingDefaultComparator() Revert to standard comparison for incoming assertion checks.
StringAssert	usingDefaultElementComparator() Revert to standard comparison for incoming assertion group element checks.
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.

Methods inherited from class org.assertj.core.api.AbstractAssert

as, as, describedAs, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, equals, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, is, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, overridingErrorMessage

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

StringAssert

protected StringAssert(String actual)

Method Detail

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... values)

Verifies that the actual String contains all the given strings.

You can use one or several strings as in the example below

 assertThat("Gandalf the grey").contains("alf");
 assertThat("Gandalf the grey").contains("alf", "grey");
 

Parameters:

values - the Strings to look for.

Returns:

this assertion object.

Throws:

NullPointerException - if the given values is null.

IllegalArgumentException - if the given values is empty.

AssertionError - if the actual String is null.

AssertionError - if the actual String does not contain all the given strings.

containsSequence

public StringAssert containsSequence(String... values)

Verifies that the actual String contains all the given strings in the given order.

Example :

 String book = "{ 'title':'A Game of Thrones', 'author':'George Martin'}";
 
 // this assertion succeeds ... 
 assertThat(book).containsSequence("{", "title", "A Game of Thrones", "}");
 
 // ... but this one fails as "author" must come after "A Game of Thrones"
 assertThat(book).containsSequence("{", "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 String is null.

AssertionError - if the actual String does not contain all the given strings in the given order.

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.