CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-org-assertj--assertj-core

Fluent assertion library providing rich assertions for Java tests with expressive failure messages

—

Pending
Overview
Eval results
Files

strings.mddocs/

Strings

String and CharSequence assertions for content validation, format checking, pattern matching, and text analysis.

Core Imports

import static org.assertj.core.api.Assertions.*;

Capabilities

String Assertions

Comprehensive assertions for String objects.

StringAssert assertThat(String actual)

// Content assertions
StringAssert isEmpty()
StringAssert isNotEmpty()
StringAssert isBlank()
StringAssert isNotBlank()
StringAssert isNullOrEmpty()
StringAssert isNotNull()

// Length assertions
StringAssert hasLength(int expected)
StringAssert hasSizeLessThan(int expected)
StringAssert hasSizeGreaterThan(int expected)
StringAssert hasSizeBetween(int lowerBoundary, int higherBoundary)

// Prefix and suffix
StringAssert startsWith(String prefix)
StringAssert startsWithIgnoringCase(String prefix)
StringAssert doesNotStartWith(String prefix)
StringAssert endsWith(String suffix)
StringAssert endsWithIgnoringCase(String suffix)
StringAssert doesNotEndWith(String suffix)

// Content matching
StringAssert contains(String... values)
StringAssert containsIgnoringCase(String sequence)
StringAssert containsOnlyOnce(String sequence)
StringAssert containsSequence(String... values)
StringAssert containsSubsequence(String... values)
StringAssert doesNotContain(String... values)
StringAssert doesNotContainAnyWhitespaces()
StringAssert containsOnlyWhitespaces()

// Pattern matching
StringAssert matches(String regex)
StringAssert matches(Pattern pattern)
StringAssert doesNotMatch(String regex)
StringAssert doesNotMatch(Pattern pattern)
StringAssert matchesPattern(String pattern)
StringAssert matchesPattern(Pattern pattern)

// Case assertions
StringAssert isUpperCase()
StringAssert isLowerCase()
StringAssert isMixedCase()

// Equality with options
StringAssert isEqualTo(String expected)
StringAssert isEqualToIgnoringCase(String expected)
StringAssert isEqualToIgnoringWhitespace(String expected)
StringAssert isEqualToIgnoringNewLines(String expected)
StringAssert isEqualToNormalizingNewlines(String expected)
StringAssert isNotEqualTo(String other)
StringAssert isNotEqualToIgnoringCase(String other)

Usage examples:

String message = "Hello World!";
assertThat(message)
    .isNotEmpty()
    .hasLength(12)
    .startsWith("Hello")
    .endsWith("!")
    .contains("World")
    .matches("Hello.*!");

String email = "user@domain.com";
assertThat(email)
    .matches("\\w+@\\w+\\.\\w+")
    .contains("@")
    .doesNotContain(" ");

String input = "   ";
assertThat(input).isBlank().containsOnlyWhitespaces();

String code = "PUBLIC STATIC VOID";
assertThat(code).isUpperCase();

CharSequence Assertions

Generic assertions for any CharSequence implementation.

CharSequenceAssert assertThat(CharSequence actual)

// CharSequence methods (similar to String but more generic)
CharSequenceAssert isEmpty()
CharSequenceAssert isNotEmpty()
CharSequenceAssert isBlank()
CharSequenceAssert isNotBlank()
CharSequenceAssert hasLength(int expected)
CharSequenceAssert startsWith(CharSequence prefix)
CharSequenceAssert endsWith(CharSequence suffix)
CharSequenceAssert contains(CharSequence... values)
CharSequenceAssert doesNotContain(CharSequence... values)
CharSequenceAssert isEqualTo(CharSequence expected)
CharSequenceAssert isEqualToIgnoringCase(CharSequence expected)

Usage examples:

StringBuilder builder = new StringBuilder("Hello");
assertThat(builder)
    .hasLength(5)
    .startsWith("Hel")
    .isNotEmpty();

StringBuffer buffer = new StringBuffer("Test Data");
assertThat(buffer)
    .contains("Data")
    .endsWith("Data");

Character Array Assertions

Assertions for character arrays.

CharArrayAssert assertThat(char[] actual)

// Character array methods
CharArrayAssert hasSize(int expected)
CharArrayAssert isEmpty()
CharArrayAssert isNotEmpty()
CharArrayAssert contains(char... values)
CharArrayAssert containsOnly(char... values)
CharArrayAssert containsSequence(char... sequence)
CharArrayAssert doesNotContain(char... values)
CharArrayAssert startsWith(char... sequence)
CharArrayAssert endsWith(char... sequence)

Usage examples:

char[] chars = {'h', 'e', 'l', 'l', 'o'};
assertThat(chars)
    .hasSize(5)
    .contains('e', 'l')
    .startsWith('h')
    .endsWith('o');

Advanced String Matching

Pattern-based and complex string validations.

// Regular expression matching
StringAssert containsPattern(String regex)
StringAssert containsPattern(Pattern pattern)
StringAssert doesNotContainPattern(String regex)
StringAssert doesNotContainPattern(Pattern pattern)

// Line-based assertions
StringAssert hasLineCount(int expected)
StringAssert hasLinesCount(int expected)

// Normalization and comparison
StringAssert isEqualToNormalizingPunctuationAndWhitespace(String expected)
StringAssert isEqualToIgnoringNewLines(String expected)
StringAssert isSubstringOf(String sequence)
StringAssert isNotSubstringOf(String sequence)

// Encoding assertions
StringAssert asBase64Decoded()
StringAssert asHexString()

Usage examples:

String multiLine = "Line 1\nLine 2\nLine 3";
assertThat(multiLine)
    .hasLineCount(3)
    .containsPattern("Line \\d");

String json = "{\"name\":\"John\",\"age\":30}";
assertThat(json)
    .containsPattern("\"\\w+\":\\w+")
    .startsWith("{")
    .endsWith("}");

String normalizeTest = "Hello,  World!";
assertThat(normalizeTest)
    .isEqualToNormalizingPunctuationAndWhitespace("Hello World");

String Transformations and Extractions

Transform strings for specialized assertions.

// Case transformations
StringAssert asLowerCase()
StringAssert asUpperCase()

// Trimming
StringAssert trimmed()

// Decoding
StringAssert asBase64Decoded()
StringAssert asHexString()
StringAssert asUUID()

// Date parsing
DateAssert asDate()
LocalDateAssert asLocalDate()
LocalDateTimeAssert asLocalDateTime()
InstantAssert asInstant()

Usage examples:

String upperText = "HELLO WORLD";
assertThat(upperText)
    .asLowerCase()
    .isEqualTo("hello world");

String paddedText = "  trimmed  ";
assertThat(paddedText)
    .trimmed()
    .isEqualTo("trimmed");

String dateString = "2023-12-25";
assertThat(dateString)
    .asLocalDate()
    .isAfter(LocalDate.of(2023, 12, 20));

String base64 = "SGVsbG8gV29ybGQ="; // "Hello World" encoded
assertThat(base64)
    .asBase64Decoded()
    .isEqualTo("Hello World");

Unicode and Character Properties

Assertions for Unicode properties and character analysis.

// Character content analysis
StringAssert containsOnlyDigits()
StringAssert containsOnlyLetters() 
StringAssert containsOnlyLettersOrDigits()
StringAssert containsWhitespaces()
StringAssert doesNotContainAnyWhitespaces()
StringAssert containsOnlyWhitespaces()

// Unicode normalization
StringAssert isEqualToNormalizingUnicode(String expected)

Usage examples:

String digits = "12345";
assertThat(digits).containsOnlyDigits();

String letters = "HelloWorld";
assertThat(letters).containsOnlyLetters();

String alphanumeric = "Hello123";
assertThat(alphanumeric).containsOnlyLettersOrDigits();

String withSpaces = "Hello World";
assertThat(withSpaces).containsWhitespaces();

String noSpaces = "HelloWorld";
assertThat(noSpaces).doesNotContainAnyWhitespaces();

String Satisfies and Custom Validation

Custom validation logic for complex string requirements.

// Custom string validation
StringAssert satisfies(Consumer<String> requirements)
StringAssert satisfiesAnyOf(Consumer<String>... requirements)

// String predicates
StringAssert matches(Predicate<String> predicate)

Usage examples:

String password = "MySecurePass123!";
assertThat(password)
    .satisfies(pwd -> {
        assertThat(pwd.length()).isGreaterThanOrEqualTo(8);
        assertThat(pwd).containsPattern("[A-Z]"); // uppercase
        assertThat(pwd).containsPattern("[a-z]"); // lowercase  
        assertThat(pwd).containsPattern("\\d");   // digit
        assertThat(pwd).containsPattern("[!@#$%^&*]"); // special
    });

String filename = "document.pdf";
assertThat(filename)
    .satisfies(name -> assertThat(name).endsWith(".pdf"))
    .matches(name -> name.length() > 4);

Types

// Pattern for regex matching
class Pattern {
    static Pattern compile(String regex)
    static Pattern compile(String regex, int flags)
}

// Consumer for custom validation
interface Consumer<T> {
    void accept(T t);
}

// Predicate for matching
interface Predicate<T> {
    boolean test(T t);
}

// Character sequence interface
interface CharSequence {
    int length()
    char charAt(int index)
    CharSequence subSequence(int start, int end)
    String toString()
}

Install with Tessl CLI

npx tessl i tessl/maven-org-assertj--assertj-core

docs

advanced.md

basic-assertions.md

collections.md

conditions.md

dates-times.md

exceptions.md

index.md

soft-assertions.md

strings.md

tile.json