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
All Methods Instance Methods Concrete Methods Modifier and Type Method Description AbstractByteArrayAssert<?>
decodedAsBase64()
Decodes the actual value as a Base64 encoded string, the decoded bytes becoming the new array under test.SELF
isBase64()
Verifies that the actual value is a valid Base64 encoded string.SELF
isBetween(String startInclusive, String endInclusive)
Verifies that the actual value is in [start, end] range (start included, end included) according toString.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 usingString.format(String stringTemplate, Object... args)
.SELF
isGreaterThan(String other)
Verifies that the actual value is greater than the givenString
according toString.compareTo(String)
.SELF
isGreaterThanOrEqualTo(String other)
Verifies that the actual value is greater than or equal to the givenString
according toString.compareTo(String)
.SELF
isLessThan(String other)
Verifies that the actual value is less than the givenString
according toString.compareTo(String)
.SELF
isLessThanOrEqualTo(String other)
Verifies that the actual value is less than or equal to the givenString
according toString.compareTo(String)
.SELF
isStrictlyBetween(String startExclusive, String endExclusive)
Verifies that the actual value is strictly in ]start, end[ range (start excluded, end excluded) according toString.compareTo(String)
.SELF
usingComparator(Comparator<? super String> customComparator)
Use the given custom comparator instead of relying onString
natural comparator for the incoming assertions.SELF
usingComparator(Comparator<? super String> customComparator, String customComparatorDescription)
Use the given custom comparator instead of relying onString
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, isEqualToNormalizingPunctuationAndWhitespace, 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
asInstanceOf, asList, assertionError, asString, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, equals, extracting, extracting, failWithActualExpectedAndMessage, 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, satisfiesAnyOf, setCustomRepresentation, throwAssertionError, usingRecursiveComparison, usingRecursiveComparison, withAssertionState, withFailMessage, withRepresentation, withThreadDumpOnError
-
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait
-
Methods inherited from interface org.assertj.core.api.Descriptable
as, as, describedAs
-
-
-
-
Field Detail
-
comparables
Comparables comparables
-
-
Method Detail
-
isLessThan
public SELF isLessThan(String other)
Verifies that the actual value is less than the givenString
according toString.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
- theString
to compare the actual value to.- Returns:
this
assertion object.- Throws:
AssertionError
- if the actual value isnull
.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 givenString
according toString.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
- theString
to compare the actual value to.- Returns:
this
assertion object.- Throws:
AssertionError
- if the actual value isnull
.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 givenString
according toString.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
- theString
to compare the actual value to.- Returns:
this
assertion object.- Throws:
AssertionError
- if the actual value isnull
.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 givenString
according toString.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
- theString
to compare the actual value to.- Returns:
this
assertion object.- Throws:
AssertionError
- if the actual value isnull
.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 toString.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 isnull
.NullPointerException
- if start value isnull
.NullPointerException
- if end value isnull
.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 toString.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 isnull
.NullPointerException
- if start value isnull
.NullPointerException
- if end value isnull
.AssertionError
- if the actual value is not in ]start, end[ range.- Since:
- 3.11.0
-
isBase64
public SELF isBase64()
Verifies that the actual value is a valid Base64 encoded string.Examples:
// assertion succeeds assertThat("QXNzZXJ0Sg==").isBase64(); // assertion succeeds even without padding as it is optional by specification assertThat("QXNzZXJ0Sg").isBase64(); // assertion fails as it has invalid Base64 characters assertThat("inv@lid").isBase64();
- Returns:
- this assertion object.
- Throws:
AssertionError
- if the actual value isnull
.AssertionError
- if the actual value is not a valid Base64 encoded string.- Since:
- 3.16.0
-
decodedAsBase64
public AbstractByteArrayAssert<?> decodedAsBase64()
Decodes the actual value as a Base64 encoded string, the decoded bytes becoming the new array under test.Examples:
// assertion succeeds assertThat("QXNzZXJ0Sg==").decodedAsBase64().containsExactly("AssertJ".getBytes()); // assertion succeeds even without padding as it is optional by specification assertThat("QXNzZXJ0Sg").decodedAsBase64().containsExactly("AssertJ".getBytes()); // assertion fails as it has invalid Base64 characters assertThat("inv@lid").decodedAsBase64();
- Returns:
- a new
ByteArrayAssert
instance whose array under test is the result of the decoding. - Throws:
AssertionError
- if the actual value isnull
.AssertionError
- if the actual value is not a valid Base64 encoded string.- Since:
- 3.16.0
-
usingComparator
public SELF usingComparator(Comparator<? super String> customComparator)
Use the given custom comparator instead of relying onString
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 interfaceAssert<SELF extends AbstractStringAssert<SELF>,String>
- Overrides:
usingComparator
in classAbstractCharSequenceAssert<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 isnull
.
-
usingComparator
public SELF usingComparator(Comparator<? super String> customComparator, String customComparatorDescription)
Use the given custom comparator instead of relying onString
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 interfaceAssert<SELF extends AbstractStringAssert<SELF>,String>
- Overrides:
usingComparator
in classAbstractCharSequenceAssert<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 isnull
.
-
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 interfaceAssert<SELF extends AbstractStringAssert<SELF>,String>
- Overrides:
usingDefaultComparator
in classAbstractCharSequenceAssert<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 usingString.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 called 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 withIllegalFormatException
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 isnull
.AssertionError
- if the actual value isnull
as the template you provide must not benull
.IllegalFormatException
- as inString.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 givenString
to compare the actual to.- Returns:
- this assertion object.
- Since:
- 3.13.0
- See Also:
Assert.isEqualTo(java.lang.Object)
-
-