Package 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

Modifier and Type	Field	Description
(package private) Comparables	comparables

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

strings

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

actual, assertionErrorCreator, conditions, info, myself, objects, throwUnsupportedExceptionOnEquals

Constructor Summary

Constructors

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

Method Summary

Modifier and Type	Method	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 expected)	Verifies that the actual value is equal to expected.
SELF	isEqualTo(String expectedStringTemplate, Object... args)	Verifies that the actual value is equal to expected build using String.format(String stringTemplate, Object... args).
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, asInstanceOf, 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, withAssertionState, withFailMessage, withRepresentation, withThreadDumpOnError

Methods inherited from class java.lang.Object

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

Field Detail

comparables

Comparables comparables

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

isEqualTo

public SELF isEqualTo(String expected)

Verifies that the actual value is equal to expected.

This method needs to be overridden because otherwise isEqualTo(String, Object...) is called from tests in Kotlin without args which breaks whenever the is % in the string.

Parameters:

expected - the given String to compare the actual to.

Returns:

this assertion object.

Since:

3.13.0

See Also:

Assert.isEqualTo(java.lang.Object)