Package org.assertj.core.api

Class AbstractStringAssert<SELF extends AbstractStringAssert<SELF>>

    • Constructor Detail

      • AbstractStringAssert

        protected 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

      • 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 is null.
        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 is null.
        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 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.

      • 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 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 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)