org.assertj.core.api

Class AbstractStringAssert<SELF extends AbstractStringAssert<SELF>>

java.lang.Object

org.assertj.core.api.AbstractAssert<SELF,ACTUAL>

org.assertj.core.api.AbstractCharSequenceAssert<SELF,String>

org.assertj.core.api.AbstractStringAssert<SELF>

All Implemented Interfaces:

Assert<SELF,String>, Descriptable<SELF>, EnumerableAssert<SELF,Character>, ExtensionPoints<SELF,String>

Direct Known Subclasses:

StringAssert

public class AbstractStringAssert<SELF extends AbstractStringAssert<SELF>>
extends AbstractCharSequenceAssert<SELF,String>

Field Summary

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

actual, info, myself, throwUnsupportedExceptionOnEquals

Constructor Summary

Constructors

Constructor and Description
AbstractStringAssert(String actual, Class<?> selfType)

Method Summary

Modifier and Type	Method and Description
SELF	isBetween(String startInclusive, String endInclusive) Verifies that the actual value is in [start, end] range (start included, end included) according to String.compareTo(String).
SELF	isEqualTo(String expectedStringTemplate, Object... args) Verifies that the actual value is equal to expected build using {@link String#format(String stringTemplate, Object...
SELF	isGreaterThan(String other) Verifies that the actual value is greater than the given String according to String.compareTo(String).
SELF	isGreaterThanOrEqualTo(String other) Verifies that the actual value is greater than or equal to the given String according to String.compareTo(String).
SELF	isLessThan(String other) Verifies that the actual value is less than the given String according to String.compareTo(String).
SELF	isLessThanOrEqualTo(String other) Verifies that the actual value is less than or equal to the given String according to String.compareTo(String).
SELF	isStrictlyBetween(String startExclusive, String endExclusive) Verifies that the actual value is strictly in ]start, end[ range (start excluded, end excluded) according to String.compareTo(String).
SELF	usingComparator(Comparator<? super String> customComparator) Use the given custom comparator instead of relying on String natural comparator for the incoming assertions.
SELF	usingComparator(Comparator<? super String> customComparator, String customComparatorDescription) Use the given custom comparator instead of relying on String natural comparator for the incoming assertions.
SELF	usingDefaultComparator() Revert to standard comparison for the incoming assertion checks.

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

contains, contains, containsIgnoringCase, containsOnlyDigits, containsOnlyOnce, containsOnlyWhitespaces, containsPattern, containsPattern, containsSequence, containsSequence, containsSubsequence, containsSubsequence, containsWhitespaces, doesNotContain, doesNotContain, doesNotContainAnyWhitespaces, doesNotContainOnlyWhitespaces, doesNotContainPattern, doesNotContainPattern, doesNotEndWith, doesNotMatch, doesNotMatch, doesNotStartWith, endsWith, hasLineCount, hasSameSizeAs, hasSameSizeAs, hasSameSizeAs, hasSize, hasSizeBetween, hasSizeGreaterThan, hasSizeGreaterThanOrEqualTo, hasSizeLessThan, hasSizeLessThanOrEqualTo, inHexadecimal, inUnicode, isBlank, isEmpty, isEqualToIgnoringCase, isEqualToIgnoringNewLines, isEqualToIgnoringWhitespace, isEqualToNormalizingNewlines, isEqualToNormalizingWhitespace, isJavaBlank, isLowerCase, isNotBlank, isNotEmpty, isNotEqualToIgnoringCase, isNotEqualToIgnoringWhitespace, isNotEqualToNormalizingWhitespace, isNotJavaBlank, isNullOrEmpty, isSubstringOf, isUpperCase, isXmlEqualTo, isXmlEqualToContentOf, matches, matches, startsWith, usingDefaultElementComparator, usingElementComparator

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

as, as, asList, asString, describedAs, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, equals, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, hasToString, inBinary, is, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, newListAssertInstance, overridingErrorMessage, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, setCustomRepresentation, throwAssertionError, withFailMessage, withRepresentation, withThreadDumpOnError

Methods inherited from class java.lang.Object

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

Constructor Detail

AbstractStringAssert

public AbstractStringAssert(String actual,
                            Class<?> selfType)

Method Detail

isLessThan

public SELF isLessThan(String other)

Verifies that the actual value is less than the given String according to String.compareTo(String).

Note that it is possible to change the comparison strategy with usingComparator.

Examples:

 // assertions succeed
 assertThat("abc").isLessThan("bcd")
                  .isLessThan("b")
                  .isLessThan("abca")
                  .usingComparator(CASE_INSENSITIVE)
                  .isLessThan("BCD");

 // assertions fail
 assertThat("abc").isLessThan("ab");
 assertThat("abc").isLessThan("abc");
 assertThat("abc").isLessThan("ABC");

Parameters:

other - the String to compare the actual value to.

Returns:

this assertion object.

Throws:

AssertionError - if the actual value is null.

AssertionError - if the actual value is greater than or equal to the given one.

Since:

3.11.0

isLessThanOrEqualTo

public SELF isLessThanOrEqualTo(String other)

Verifies that the actual value is less than or equal to the given String according to String.compareTo(String).

Note that it is possible to change the comparison strategy with usingComparator.

Examples:

 // assertions succeed
 assertThat("abc").isLessThanOrEqualTo("bcd")
                  .isLessThanOrEqualTo("abc")
                  .isLessThanOrEqualTo("b")
                  .isLessThanOrEqualTo("abca")
                  .usingComparator(CASE_INSENSITIVE)
                  .isLessThanOrEqualTo("ABC");

 // assertions fail
 assertThat("abc").isLessThanOrEqualTo("ab");
 assertThat("abc").isLessThanOrEqualTo("ABC");

Parameters:

other - the String to compare the actual value to.

Returns:

this assertion object.

Throws:

AssertionError - if the actual value is null.

AssertionError - if the actual value is greater than the given one.

Since:

3.11.0

isGreaterThan

public SELF isGreaterThan(String other)

Verifies that the actual value is greater than the given String according to String.compareTo(String).

Note that it is possible to change the comparison strategy with usingComparator.

Examples:

 // assertions succeed
 assertThat("xyz").isGreaterThan("abc")
                  .isGreaterThan("xy")
                  .isGreaterThan("ABC");
 assertThat("XYZ").usingComparator(CASE_INSENSITIVE)
                  .isGreaterThan("abc");

 // assertions fail
 assertThat("xyz").isGreaterThan("xyzz");
 assertThat("xyz").isGreaterThan("xyz");
 assertThat("xyz").isGreaterThan("z");

Parameters:

other - the String to compare the actual value to.

Returns:

this assertion object.

Throws:

AssertionError - if the actual value is null.

AssertionError - if the actual value is less than or equal to the given one.

Since:

3.11.0

isGreaterThanOrEqualTo

public SELF isGreaterThanOrEqualTo(String other)

Verifies that the actual value is greater than or equal to the given String according to String.compareTo(String).

Note that it is possible to change the comparison strategy with usingComparator.

Examples:

 // assertions succeed
 assertThat("xyz").isGreaterThanOrEqualTo("abc")
                  .isGreaterThanOrEqualTo("xyz")
                  .isGreaterThanOrEqualTo("xy")
                  .isGreaterThanOrEqualTo("ABC");
 assertThat("XYZ").usingComparator(CASE_INSENSITIVE)
                  .isGreaterThanOrEqualTo("abc");

 // assertions fail
 assertThat("xyz").isGreaterThanOrEqualTo("xyzz");
 assertThat("xyz").isGreaterThanOrEqualTo("z");

Parameters:

other - the String to compare the actual value to.

Returns:

this assertion object.

Throws:

AssertionError - if the actual value is null.

AssertionError - if the actual value is less than the given one.

Since:

3.11.0

isBetween

public SELF isBetween(String startInclusive,
                      String endInclusive)

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

Note that it is possible to change the comparison strategy with usingComparator.

Examples:

 // assertions succeed
 assertThat("ab").isBetween("aa", "ac")
                 .isBetween("ab", "ac")
                 .isBetween("aa", "ab")
                 .isBetween("ab", "ab")
                 .isBetween("a", "c")
                 .usingComparator(CASE_INSENSITIVE)
                 .isBetween("AA", "AC");

 // assertions fail
 assertThat("ab").isBetween("ac", "bc");
 assertThat("ab").isBetween("abc", "ac");

Parameters:

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

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

Returns:

this assertion object.

Throws:

AssertionError - if the actual value is null.

NullPointerException - if start value is null.

NullPointerException - if end value is null.

AssertionError - if the actual value is not in the [start, end] range.

Since:

3.11.0

isStrictlyBetween

public SELF isStrictlyBetween(String startExclusive,
                              String endExclusive)

Verifies that the actual value is strictly in ]start, end[ range (start excluded, end excluded) according to String.compareTo(String).

Note that it is possible to change the comparison strategy with usingComparator.

Examples:

 // assertions succeed
 assertThat("ab").isStrictlyBetween("aa", "ac")
                 .isStrictlyBetween("a", "c")
                 .usingComparator(CASE_INSENSITIVE)
                 .isStrictlyBetween("AA", "AC");

 // assertions fail
 assertThat("ab").isStrictlyBetween("ac", "bc");
 assertThat("ab").isStrictlyBetween("ab", "ac");
 assertThat("ab").isStrictlyBetween("aa", "ab");
 assertThat("ab").isStrictlyBetween("abc", "ac");

Parameters:

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

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

Returns:

this assertion object.

Throws:

AssertionError - if the actual value is null.

NullPointerException - if start value is null.

NullPointerException - if end value is null.

AssertionError - if the actual value is not in ]start, end[ range.

Since:

3.11.0

usingComparator

public SELF usingComparator(Comparator<? super String> customComparator)

Use the given custom comparator instead of relying on String natural comparator for the incoming assertions.

The custom comparator is bound to an assertion instance, meaning that if a new assertion instance is created it is forgotten and the default (String natural comparator) is used.

Examples :

 // assertions succeed
 assertThat("abc").usingComparator(CASE_INSENSITIVE)
                  .isEqualTo("Abc")
                  .isEqualTo("ABC");

 // assertion fails as it relies on String natural comparator
 assertThat("abc").isEqualTo("ABC");

Specified by:

usingComparator in interface Assert<SELF extends AbstractStringAssert<SELF>,String>

Overrides:

usingComparator in class AbstractCharSequenceAssert<SELF extends AbstractStringAssert<SELF>,String>

Parameters:

customComparator - the comparator to use for the incoming assertions.

Returns:

this assertion object.

Throws:

NullPointerException - if the given comparator is null.

usingComparator

public SELF usingComparator(Comparator<? super String> customComparator,
                            String customComparatorDescription)

Use the given custom comparator instead of relying on String natural comparator for the incoming assertions.

The custom comparator is bound to an assertion instance, meaning that if a new assertion instance is created it is forgotten and the default (String natural comparator) is used.

Examples :

 // assertions succeed
 assertThat("abc").usingComparator(CASE_INSENSITIVE, "String case insensitive comparator")
                  .isEqualTo("Abc")
                  .isEqualTo("ABC");

 // assertion fails as it relies on String natural comparator
 assertThat("abc").isEqualTo("ABC");

Specified by:

usingComparator in interface Assert<SELF extends AbstractStringAssert<SELF>,String>

Overrides:

usingComparator in class AbstractCharSequenceAssert<SELF extends AbstractStringAssert<SELF>,String>

Parameters:

customComparator - the comparator to use for the incoming assertions.

customComparatorDescription - comparator description to be used in assertion error messages

Returns:

this assertion object.

Throws:

NullPointerException - if the given comparator is null.

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 AbstractStringAssert<SELF>,String>

Overrides:

usingDefaultComparator in class AbstractCharSequenceAssert<SELF extends AbstractStringAssert<SELF>,String>

Returns:

this assertion object.

isEqualTo

public SELF isEqualTo(String expectedStringTemplate,
                      Object... args)

Verifies that the actual value is equal to expected build using String.format(String stringTemplate, Object... args).

Note that for this assertion to be called, you must use a format template with parameters otherwise AbstractAssert.isEqualTo(Object) is callled which does not perform any formatting. For example, it you only use %n in the template they won't be replaced.

Examples:

 // assertion succeeds
 assertThat("R2D2").isEqualTo("%d%s%d%s", "R", 2, "D", 2);

 // assertion fails
 assertThat("C6PO").isEqualTo("%d%s%d%s", "R", 2, "D", 2);

 // assertion fails with NullPointerException
 assertThat("1,A,2").isEqualTo(null, 1, "A", 2);

 // assertion fails with IllegalFormatException
 assertThat("1").isEqualTo("%s%s", 1); 

Parameters:

expectedStringTemplate - the format template used to build the expected String.

args - the arguments referenced by the format specifiers in the format string.

Returns:

this assertion object.

Throws:

NullPointerException - if stringTemplate parameter is null.

AssertionError - if the actual value is null as the template you provide must not be null.

IllegalFormatException - as in String.format(String, Object...), see Details section of the formatter class specification.

Since:

3.12.0