org.apache.juneau.junit.bct.BctAssertions

public class BctAssertions extends Object

Comprehensive utility class for Bean-Centric Tests (BCT) and general testing operations.

This class extends the functionality provided by the JUnit Assertions class, with particular emphasis on the Bean-Centric Testing (BCT) framework. BCT enables sophisticated assertion patterns for testing object properties, collections, maps, and complex nested structures with minimal code.

Bean-Centric Testing (BCT) Framework:

The BCT framework consists of several key components:

BeanConverter: Core interface for object conversion and property access
BasicBeanConverter: Default implementation with extensible type handlers
Assertion Methods: High-level testing methods that leverage the converter framework

Primary BCT Assertion Methods:

assertBean(Object, String, String): Tests object properties with nested syntax support and collection iteration
assertBeans(Collection, String, String...): Tests collections of objects by extracting and comparing specific fields
assertMapped(Object, java.util.function.BiFunction, String, String): Tests custom property access using BiFunction for non-standard objects
assertList(List, Object...): Tests list/collection elements with varargs for expected values

BCT Advanced Features:

Nested Property Syntax: "address{street,city}" for testing nested objects
Collection Iteration: "#{address{street,city}}" syntax for testing all elements
Universal Size Properties: "length" and "size" work on all collection types
Array/List Access: Numeric indices for element-specific testing
Method Chaining: Fluent setters can be tested directly
Direct Field Access: Public fields accessed without getters
Map Key Access: Including special "<null>" syntax for null keys

Converter Extensibility:

The BCT framework is built on the extensible BasicBeanConverter which allows:

Custom Stringifiers: Type-specific string conversion logic
Custom Listifiers: Collection-type conversion for iteration
Custom Swappers: Object transformation before conversion
Custom PropertyExtractors: Property extraction
Configurable Settings: Formatting, delimiters, and display options

Usage Examples:

Basic Property Testing:

// Test multiple properties assertBean(user, "name,age,active", "John,30,true"); // Test nested properties - user has getAddress() returning Address with getStreet() and getCity() assertBean(user, "name,address{street,city}", "John,{123 Main St,Springfield}");

Collection and Array Testing:

// Test collection size and iterate over all elements - order has getItems() returning List<Product> where Product has getName() assertBean(order, "items{length,#{name}}", "{3,[{Laptop},{Phone},{Tablet}]}"); // Test specific array elements - listOfData is a List<DataObject> where DataObject has getData() assertBean(listOfData, "0{data},1{data}", "{100},{200}");

Collection Testing:

// Test list elements assertList(tags, "red", "green", "blue"); // Test map entries using assertBean assertBean(config, "timeout,retries", "30000,3");

Custom Property Access:

// Test with custom accessor function assertMapped(myObject, (obj, prop) -> obj.getProperty(prop), "prop1,prop2", "value1,value2");

Customizing the Default Converter:

The default bean converter can be customized on a per-thread basis using:

BctConfiguration.set(BeanConverter): Set a custom converter for the current thread
BctConfiguration.clear(): Reset to the system default converter

// Example: Set custom converter in @BeforeEach method @BeforeEach void setUp() { var customConverter = BasicBeanConverter.builder() .defaultSettings() .addStringifier(LocalDate.class, date -> date.format(DateTimeFormatter.ISO_LOCAL_DATE)) .addStringifier(MyType.class, obj -> obj.customFormat()) .build(); BctAssertions.setConverter(customConverter); } // All assertions in this test class now use the custom converter @Test void testWithCustomConverter() { assertBean(myObject, "date,property", "2023-12-01,value"); } // Clean up in @AfterEach method @AfterEach void tearDown() { BctAssertions.resetConverter(); }

// Example: Per-test method converter override @Test void testSpecificFormat() { var dateConverter = BasicBeanConverter.builder() .defaultSettings() .addStringifier(LocalDateTime.class, dt -> dt.format(DateTimeFormatter.ISO_DATE_TIME)) .build(); BctAssertions.setConverter(dateConverter); try { assertBean(event, "timestamp", "2023-12-01T10:30:00"); } finally { BctAssertions.resetConverter(); } }

Performance and Thread Safety:

The BCT framework is designed for high performance with:

Caching: Type-to-handler mappings cached for fast lookup
Thread Safety: All operations are thread-safe for concurrent testing
Thread-Local Storage: Default converter is stored per-thread, allowing parallel test execution
Minimal Allocation: Efficient object reuse and minimal temporary objects

See Also:

Method Summary

Modifier and Type

Method

Description

static void

assertBean(Object actual, String fields, String expected)

Asserts that the fields/properties on the specified bean are the specified values after being converted to strings.

static void

assertBean(Supplier<String> message, Object actual, String fields, String expected)

Asserts that the fields/properties on the specified bean are the specified values after being converted to strings.

static void

assertBeans(Object actual, String fields, String... expected)

Asserts that multiple beans in a collection have the expected property values.

static void

assertBeans(Supplier<String> message, Object actual, String fields, String... expected)

Asserts that multiple beans in a collection have the expected property values.

static void

assertContains(String expected, Object actual)

Asserts that the string representation of an object contains the expected substring.

static void

assertContains(Supplier<String> message, String expected, Object actual)

Asserts that the string representation of an object contains the expected substring.

static void

assertContainsAll(Object actual, String... expected)

Asserts that the string representation of an object contains all specified substrings.

static void

assertContainsAll(Supplier<String> message, Object actual, String... expected)

Asserts that the string representation of an object contains all specified substrings.

static void

assertEmpty(Object value)

Asserts that a collection-like object, Optional, Value, String, or array is not null and empty.

static void

assertEmpty(Supplier<String> message, Object value)

Asserts that a collection-like object, Optional, Value, String, or array is not null and empty.

static void

assertList(Object actual, Object... expected)

Asserts that a List or List-like object contains the expected values using flexible comparison logic.

static void

assertList(Supplier<String> message, Object actual, Object... expected)

Asserts that a List or List-like object contains the expected values using flexible comparison logic.

static void

assertMap(Supplier<String> message, Map<?,?> actual, Object... expected)

Asserts that a Map contains the expected key/value pairs using flexible comparison logic.

static void

assertMap(Map<?,?> actual, Object... expected)

Asserts that a Map contains the expected key/value pairs using flexible comparison logic.

static <T> void

assertMapped(Supplier<String> message, T actual, BiFunction<T,String,Object> function, String properties, String expected)

Asserts that mapped property access on an object returns expected values using a custom BiFunction.

static <T> void

assertMapped(T actual, BiFunction<T,String,Object> function, String properties, String expected)

Asserts that mapped property access on an object returns expected values using a custom BiFunction.

static void

assertMatchesGlob(String pattern, Object value)

Asserts that an object's string representation matches the specified glob-style pattern.

static void

assertMatchesGlob(Supplier<String> message, String pattern, Object value)

Asserts that an object's string representation matches the specified glob-style pattern.

static void

assertNotEmpty(Object value)

Asserts that a collection-like object, Optional, Value, String, or array is not null and not empty.

static void

assertNotEmpty(Supplier<String> message, Object value)

Asserts that a collection-like object, Optional, Value, String, or array is not null and not empty.

static void

assertSize(int expected, Object actual)

Asserts that a collection-like object or string is not null and of the specified size.

static void

assertSize(Supplier<String> message, int expected, Object actual)

Asserts that a collection-like object or string is not null and of the specified size.

static void

assertString(String expected, Object actual)

Asserts that an object's string representation exactly matches the expected value.

static void

assertString(Supplier<String> message, String expected, Object actual)

Asserts that an object's string representation exactly matches the expected value.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Details
- assertBean
  
  public static void assertBean(Object actual, String fields, String expected)
  
  Asserts that the fields/properties on the specified bean are the specified values after being converted to strings.
  Same as assertBean(Supplier, Object, String, String) but without a custom message.
  Parameters:
  
  actual - The bean object to test. Must not be null.
  
  fields - Comma-delimited list of property names to test. Supports nested syntax with {}.
  
  expected - Comma-delimited list of expected values. Must match the order of fields.
  
  Throws:
  
  NullPointerException - if the bean is null
  
  AssertionError - if any property values don't match expected values
  
  See Also:
  
  assertBean(Supplier, Object, String, String)
- assertBean
  
  public static void assertBean(Supplier<String> message, Object actual, String fields, String expected)
  Asserts that the fields/properties on the specified bean are the specified values after being converted to strings.
  This is the primary method for Bean-Centric Tests (BCT), supporting extensive property validation patterns including nested objects, collections, arrays, method chaining, direct field access, collection iteration with "#{property}" syntax, and universal "length"/"size" properties for all collection types.
  
  The method uses the default converter (set via BctConfiguration.set(BeanConverter)) for object introspection and value extraction. The converter provides sophisticated property access through the BeanConverter interface, supporting multiple fallback mechanisms for accessing object properties and values.
  
  Basic Usage:
  
  // Test multiple properties assertBean(myBean, "prop1,prop2,prop3", "val1,val2,val3"); // Test single property assertBean(myBean, "name", "John"); // With custom error message assertBean(myBean, "name,age", "John,30", () -> "User validation failed"); // With formatted message using Utils.fs() for convenient message suppliers with arguments assertBean(myBean, "name,age", "John,30", fs("User {0} validation failed", "John"));
  
  Nested Property Testing:
  
  // Test nested bean properties assertBean(myBean, "name,address{street,city,state}", "John,{123 Main St,Springfield,IL}"); // Test arbitrarily deep nesting assertBean(myBean, "name,person{address{geo{lat,lon}}}", "John,{{{40.7,-74.0}}}");
  
  Array, List, and Stream Testing:
  
  // Test array/list elements by index - items is a String[] or List<String> assertBean(myBean, "items{0,1,2}", "{item1,item2,item3}"); // Test nested properties within array elements - orders is a List<Order> where Order has getId() and getTotal() assertBean(myBean, "orders{0{id,total}}", "{{123,99.95}}"); // Test array length property - items can be any array or collection type assertBean(myBean, "items{length}", "{5}"); // Works with any iterable type including Streams - userStream returns a Stream<User> where User has getName() assertBean(myBean, "userStream{#{name}}", "[{Alice},{Bob}]");
  
  Collection Iteration Syntax:
  
  // Test properties across ALL elements in a collection using #{...} syntax - userList is a List<User> where User has getName() assertBean(myBean, "userList{#{name}}", "[{John},{Jane},{Bob}]"); // Test multiple properties from each element - orderList is a List<Order> where Order has getId() and getStatus() assertBean(myBean, "orderList{#{id,status}}", "[{123,ACTIVE},{124,PENDING}]"); // Works with nested properties within each element - customers is a List<Customer> where Customer has getAddress() returning Address with getCity() assertBean(myBean, "customers{#{address{city}}}", "[{{New York}},{{Los Angeles}}]"); // Works with arrays and any iterable collection type (including Streams) assertBean(config, "itemArray{#{type}}", "[{String},{Integer},{Boolean}]"); assertBean(data, "statusSet{#{name}}", "[{ACTIVE},{PENDING},{CANCELLED}]"); assertBean(processor, "dataStream{#{value}}", "[{A},{B},{C}]");
  
  Universal Collection Size Properties:
  
  // Both 'length' and 'size' work universally across all collection types assertBean(myBean, "myArray{length}", "{5}"); // Arrays assertBean(myBean, "myArray{size}", "{5}"); // Also works for arrays assertBean(myBean, "myList{size}", "{3}"); // Collections assertBean(myBean, "myList{length}", "{3}"); // Also works for collections assertBean(myBean, "myMap{size}", "{7}"); // Maps assertBean(myBean, "myMap{length}", "{7}"); // Also works for maps
  
  Class Name Testing:
  
  // Test class properties (prefer simple names for maintainability) assertBean(myBean, "obj{class{simpleName}}", "{{MyClass}}"); // Test full class names when needed assertBean(myBean, "obj{class{name}}", "{{com.example.MyClass}}");
  
  Method Chaining Support:
  
  // Test fluent setter chains (returns same object) assertBean( item.setType("foo").setFormat("bar").setDefault("baz"), "type,format,default", "foo,bar,baz" );
  
  Advanced Collection Analysis:
  
  // Combine size/length, metadata, and content iteration in single assertions - users is a List<User> assertBean(myBean, "users{length,class{simpleName},#{name}}", "{3,{ArrayList},[{John},{Jane},{Bob}]}"); // Comprehensive collection validation with multiple iteration patterns - items is a List<Product> where Product has getName() and getPrice() assertBean(order, "items{size,#{name},#{price}}", "{3,[{Laptop},{Phone},{Tablet}],[{999.99},{599.99},{399.99}]}"); // Perfect for validation testing - verify error count and details; errors is a List<ValidationError> where ValidationError has getField() and getCode() assertBean(result, "errors{length,#{field},#{code}}", "{2,[{email},{password}],[{E001},{E002}]}"); // Mixed collection types with consistent syntax - results and metadata are different collection types assertBean(response, "results{size},metadata{length}", "{25},{4}");
  
  Direct Field Access:
  
  // Test public fields directly (no getters required) assertBean(myBean, "f1,f2,f3", "val1,val2,val3"); // Test field properties with chaining assertBean(myBean, "f1{length},f2{class{simpleName}}", "{5},{{String}}");
  
  Map Testing:
  
  // Test map values by key assertBean(myBean, "configMap{timeout,retries}", "{30000,3}"); // Test map size assertBean(myBean, "settings{size}", "{5}"); // Test null keys using special <null> syntax assertBean(myBean, "mapWithNullKey{<null>}", "{nullKeyValue}");
  
  Collection and Boolean Values:
  
  // Test boolean values assertBean(myBean, "enabled,visible", "true,false"); // Test enum collections assertBean(myBean, "statuses", "[ACTIVE,PENDING]");
  
  Value Syntax Rules:
  
  Simple values: "value" for direct property values
  
  Nested values: "{value}" for single-level nested properties
  
  Deep nested values: "{{value}}", "{{{value}}}" for multiple nesting levels
  
  Array/Collection values: "[item1,item2]" for collections
  
  Collection iteration: "#{property}" iterates over ALL collection elements, returns "[{val1},{val2}]"
  
  Universal size properties: "length" and "size" work on arrays, collections, and maps
  
  Boolean values: "true", "false"
  
  Null values: "null"
  
  Property Access Priority:
  
  Collection/Array access: Numeric indices for arrays/lists (e.g., "0", "1")
  
  Universal size properties: "length" and "size" for arrays, collections, and maps
  
  Map key access: Direct key lookup for Map objects (including "<null>" for null keys)
  
  is{Property}() methods (for boolean properties)
  
  get{Property}() methods
  
  Public fields (direct field access)
  Parameters:
  
  message - Optional custom error message supplier. If provided, will be composed with the default assertion message. Use Utils.fs() to conveniently create message suppliers with format arguments (e.g., fs("User {0} validation failed", userName)).
  
  actual - The bean object to test. Must not be null.
  
  fields - Comma-delimited list of property names to test. Supports nested syntax with {}.
  
  expected - Comma-delimited list of expected values. Must match the order of fields.
  
  Throws:
  
  NullPointerException - if the bean is null
  
  AssertionError - if any property values don't match expected values
  
  See Also:
  
  BeanConverter
  
  BasicBeanConverter
  
  BctConfiguration.set(BeanConverter)
  
  Utils.fs(String, Object...)
- assertBeans
  
  public static void assertBeans(Object actual, String fields, String... expected)
  
  Asserts that multiple beans in a collection have the expected property values.
  This method validates that each bean in a collection has the specified property values, using the same property access logic as assertBean(Object, String, String). It's perfect for testing collections of similar objects or validation results.
  
  Basic Usage:
  
  // Test list of user beans assertBeans(userList, "name,age", "John,25", "Jane,30", "Bob,35");
  
  Complex Property Testing:
  
  // Test nested properties across multiple beans - orderList is a List<Order> where Order has getId() and getCustomer() returning Customer with getName() and getEmail() assertBeans(orderList, "id,customer{name,email}", "1,{John,john@example.com}", "2,{Jane,jane@example.com}"); // Test collection properties within beans - cartList is a List<ShoppingCart> where ShoppingCart has getItems() returning List<Product> and getTotal() assertBeans(cartList, "items{0{name}},total", "{{Laptop}},999.99", "{{Phone}},599.99");
  
  Validation Testing:
  
  // Test validation results assertBeans(validationErrors, "field,message,code", "email,Invalid email format,E001", "age,Must be 18 or older,E002");
  
  Collection Iteration Testing:
  
  // Test collection iteration within beans (#{...} syntax) assertBeans(departmentList, "name,employees{#{name}}", "Engineering,[{Alice},{Bob},{Charlie}]", "Marketing,[{David},{Eve}]");
  
  Parser Result Testing:
  
  // Test parsed object collections var parsed = JsonParser.DEFAULT.parse(jsonArray, MyBean[].class); assertBeans(l(parsed), "prop1,prop2", "val1,val2", "val3,val4");
  Parameters:
  
  actual - The collection of beans to check. Must not be null.
  
  fields - A comma-delimited list of bean property names (supports nested syntax).
  
  expected - Array of expected value strings, one per bean. Each string contains comma-delimited values matching the fields.
  
  Throws:
  
  AssertionError - if the collection size doesn't match values array length or if any bean properties don't match
  
  See Also:
  
  assertBean(Object, String, String)
- assertBeans
  
  public static void assertBeans(Supplier<String> message, Object actual, String fields, String... expected)
  
  Asserts that multiple beans in a collection have the expected property values.
  Same as assertBeans(Object, String, String...) but with a custom error message.
  Parameters:
  
  message - Optional custom error message supplier. If provided, will be composed with the default assertion message.
  
  actual - The collection of beans to check. Must not be null.
  
  fields - A comma-delimited list of bean property names (supports nested syntax).
  
  expected - Array of expected value strings, one per bean. Each string contains comma-delimited values matching the fields.
  
  Throws:
  
  AssertionError - if the collection size doesn't match values array length or if any bean properties don't match
  
  See Also:
  
  assertBean(Object, String, String)
- assertContains
  
  public static void assertContains(String expected, Object actual)
  
  Asserts that the string representation of an object contains the expected substring.
  Same as assertContains(Supplier, String, Object) but without a custom message.
  Parameters:
  
  expected - The substring that must be present in the actual object's string representation
  
  actual - The object to test. Must not be null.
  
  Throws:
  
  AssertionError - if the actual object is null or its string representation doesn't contain the expected substring
  
  See Also:
  
  assertContains(Supplier, String, Object)
- assertContains
  
  public static void assertContains(Supplier<String> message, String expected, Object actual)
  
  Asserts that the string representation of an object contains the expected substring.
  This method converts the actual object to its string representation using the current BeanConverter and then checks if it contains the expected substring. This is useful for testing partial content matches without requiring exact string equality.
  
  Usage Examples:
  
  // Test that error message contains key information assertContains("FileNotFoundException", exception); // Test that object string representation contains expected data assertContains("status=ACTIVE", user); // Test partial JSON/XML content assertContains("\"name\":\"John\"", jsonResponse);
  Parameters:
  
  message - Optional custom error message supplier. If provided, will be composed with the default assertion message.
  
  expected - The substring that must be present in the actual object's string representation
  
  actual - The object to test. Must not be null.
  
  Throws:
  
  AssertionError - if the actual object is null or its string representation doesn't contain the expected substring
  
  See Also:
  
  for multiple substring assertions
  
  for exact string matching
- assertContainsAll
  
  public static void assertContainsAll(Object actual, String... expected)
  
  Asserts that the string representation of an object contains all specified substrings.
  Same as assertContainsAll(Supplier, Object, String...) but without a custom message.
  Parameters:
  
  actual - The object to test. Must not be null.
  
  expected - Multiple substrings that must all be present in the actual object's string representation
  
  Throws:
  
  AssertionError - if the actual object is null or its string representation doesn't contain all expected substrings
  
  See Also:
  
  assertContainsAll(Supplier, Object, String...)
- assertContainsAll
  
  public static void assertContainsAll(Supplier<String> message, Object actual, String... expected)
  
  Asserts that the string representation of an object contains all specified substrings.
  This method is similar to assertContains(String, Object) but tests for multiple required substrings. All provided substrings must be present in the actual object's string representation for the assertion to pass.
  
  Usage Examples:
  
  // Test that error contains multiple pieces of information assertContainsAll(exception, "FileNotFoundException", "config.xml", "/etc"); // Test that user object contains expected fields assertContainsAll(user, "name=John", "age=30", "status=ACTIVE"); // Test log output contains all required entries assertContainsAll(logOutput, "INFO", "Started", "Successfully");
  Parameters:
  
  message - Optional custom error message supplier. If provided, will be composed with the default assertion message.
  
  actual - The object to test. Must not be null.
  
  expected - Multiple substrings that must all be present in the actual object's string representation
  
  Throws:
  
  AssertionError - if the actual object is null or its string representation doesn't contain all expected substrings
  
  See Also:
  
  for single substring assertions
- assertEmpty
  
  public static void assertEmpty(Object value)
  
  Asserts that a collection-like object, Optional, Value, String, or array is not null and empty.
  Same as assertEmpty(Supplier, Object) but without a custom message.
  Parameters:
  
  value - The object to test. Must not be null.
  
  Throws:
  
  AssertionError - if the object is null or not empty
  
  See Also:
  
  assertEmpty(Supplier, Object)
- assertEmpty
  
  public static void assertEmpty(Supplier<String> message, Object value)
  Asserts that a collection-like object, Optional, Value, String, or array is not null and empty.
  This method validates that the provided object is empty according to its type:
  
  String: Must have length 0
  
  Optional: Must be empty (not present)
  
  Value: Must be empty (value is null)
  
  Map: Must have no entries
  
  Collection: Must have no elements
  
  Array: Must have length 0
  
  Other objects: Must be convertible to an empty List via BeanConverter.listify(Object)
  
  Supported Types:
  
  Any object that can be converted to a List, including:
  
  Collections (List, Set, Queue, etc.)
  
  Arrays (primitive and object arrays)
  
  Iterables, Iterators, Streams
  
  Maps (converted to list of entries)
  
  Optional objects
  
  Usage Examples:
  
  // Test empty collections assertEmpty(Collections.emptyList()); assertEmpty(new ArrayList<>()); // Test empty arrays assertEmpty(new String[0]); // Test empty Optional assertEmpty(Optional.empty()); // Test empty Map assertEmpty(new HashMap<>());
  Parameters:
  
  message - Optional custom error message supplier. If provided, will be composed with the default assertion message.
  
  value - The object to test. Must not be null.
  
  Throws:
  
  AssertionError - if the object is null or not empty
  
  See Also:
  
  for testing non-empty collections
  
  for testing specific sizes
- assertList
  
  public static void assertList(Object actual, Object... expected)
  
  Asserts that a List or List-like object contains the expected values using flexible comparison logic.
  Same as assertList(Supplier, Object, Object...) but without a custom message.
  Parameters:
  
  actual - The List to test. Must not be null.
  
  expected - Multiple arguments of expected values. Can be Strings (readable format comparison), Predicates (functional testing), or Objects (direct equality).
  
  Throws:
  
  IllegalArgumentException - if actual is null
  
  AssertionError - if the List size or contents don't match expected values
  
  See Also:
  
  assertList(Supplier, Object, Object...)
- assertList
  
  public static void assertList(Supplier<String> message, Object actual, Object... expected)
  
  Asserts that a List or List-like object contains the expected values using flexible comparison logic.
  Testing Non-List Collections:
  
  // Test a Set using l() conversion Set<String> mySet = new TreeSet<>(Arrays.asList("a", "b", "c")); assertList(l(mySet), "a", "b", "c"); // Test an array using l() conversion String[] myArray = {"x", "y", "z"}; assertList(l(myArray), "x", "y", "z"); // Test a Stream using l() conversion Stream<String> myStream = Stream.of("foo", "bar"); assertList(l(myStream), "foo", "bar");
  
  Comparison Modes:
  
  The method supports three different ways to compare expected vs actual values:
  
  1. String Comparison (Readable Format):
  
  // Elements are converted to strings using the bean converter and compared as strings assertList(List.of(1, 2, 3), "1", "2", "3"); assertList(List.of("a", "b"), "a", "b");
  
  2. Predicate Testing (Functional Validation):
  
  // Use Predicate<T> for functional testing Predicate<Integer> greaterThanOne = x -> x > 1; assertList(List.of(2, 3, 4), greaterThanOne, greaterThanOne, greaterThanOne); // Mix predicates with other comparison types Predicate<String> startsWithA = s -> s.startsWith("a"); assertList(List.of("apple", "banana"), startsWithA, "banana");
  
  3. Object Equality (Direct Comparison):
  
  // Non-String, non-Predicate objects use Objects.equals() comparison assertList(List.of(1, 2, 3), 1, 2, 3); // Integer objects assertList(List.of(myBean1, myBean2), myBean1, myBean2); // Custom objects
  
  Parameters:
  
  message - Optional custom error message supplier. If provided, will be composed with the default assertion message.
  
  actual - The List to test. Must not be null.
  
  expected - Multiple arguments of expected values. Can be Strings (readable format comparison), Predicates (functional testing), or Objects (direct equality).
  
  Throws:
  
  AssertionError - if the List size or contents don't match expected values
- assertMap
  
  public static void assertMap(Map<?,?> actual, Object... expected)
  
  Asserts that a Map contains the expected key/value pairs using flexible comparison logic.
  Same as assertMap(Supplier, Map, Object...) but without a custom message.
  Parameters:
  
  actual - The Map to test. Must not be null.
  
  expected - Multiple arguments of expected map entries. Can be Strings (readable format comparison), Predicates (functional testing), or Objects (direct equality).
  
  Throws:
  
  AssertionError - if the Map size or contents don't match expected values
  
  See Also:
  
  assertMap(Supplier, Map, Object...)
- assertMap
  
  public static void assertMap(Supplier<String> message, Map<?,?> actual, Object... expected)
  Asserts that a Map contains the expected key/value pairs using flexible comparison logic.
  Map Entry Serialization:
  
  Map entries are serialized to strings as key/value pairs in the format "key=value". Nested maps and collections are supported with appropriate formatting.
  
  Testing Nested Maps and Collections:
  
  // Test simple map entries Map<String,String> simpleMap = Map.of("a", "1", "b", "2"); assertMap(simpleMap, "a=1", "b=2"); // Test nested maps Map<String,Map<String,Integer>> nestedMap = Map.of("a", Map.of("b", 1)); assertMap(nestedMap, "a={b=1}"); // Test maps with arrays/collections Map<String,Map<String,Integer[]>> mapWithArrays = Map.of("a", Map.of("b", new Integer[]{1,2})); assertMap(mapWithArrays, "a={b=[1,2]}");
  
  Comparison Modes:
  
  The method supports the same comparison modes as assertList(Object, Object...):
  
  1. String Comparison (Readable Format):
  
  // Map entries are converted to strings and compared as strings assertMap(Map.of("key1", "value1"), "key1=value1"); assertMap(Map.of("count", 42), "count=42");
  
  2. Predicate Testing (Functional Validation):
  
  // Use Predicate<Map.Entry<K,V>> for functional testing Predicate<Map.Entry<String,Integer>> valueGreaterThanTen = entry -> entry.getValue() > 10; assertMap(Map.of("count", 42), valueGreaterThanTen);
  
  3. Object Equality (Direct Comparison):
  
  // Non-String, non-Predicate objects use Objects.equals() comparison assertMap(Map.of("key", myObject), expectedEntry);
  
  Map Ordering Behavior:
  
  The Listifiers.mapListifier() method ensures deterministic ordering for map entries:
  
  SortedMap (TreeMap, etc.): Preserves existing sort order
  
  LinkedHashMap: Preserves insertion order
  
  HashMap and other unordered Maps: Converts to TreeMap for natural key ordering
  
  This ensures predictable test results regardless of the original map implementation.
  Parameters:
  
  message - Optional custom error message supplier. If provided, will be composed with the default assertion message.
  
  actual - The Map to test. Must not be null.
  
  expected - Multiple arguments of expected map entries. Can be Strings (readable format comparison), Predicates (functional testing), or Objects (direct equality).
  
  Throws:
  
  AssertionError - if the Map size or contents don't match expected values
  
  See Also:
  
  assertList(Supplier, Object, Object...)
- assertMapped
  
  public static <T> void assertMapped(Supplier<String> message, T actual, BiFunction<T,String,Object> function, String properties, String expected)
  
  Asserts that mapped property access on an object returns expected values using a custom BiFunction.
  This is designed for testing objects that don't follow standard JavaBean patterns or require custom property access logic. The BiFunction allows complete control over how properties are retrieved from the target object.
  
  This method creates an intermediate LinkedHashMap to collect all property values before using the same logic as assertBean for comparison. This ensures consistent ordering and supports the full nested property syntax. The BasicBeanConverter.DEFAULT is used for value stringification and nested property access.
  Type Parameters:
  
  T - The type of object being tested
  
  Parameters:
  
  message - Optional custom error message supplier. If provided, will be composed with the default assertion message.
  
  actual - The object to test properties on
  
  function - The BiFunction that extracts property values. Receives (object, propertyName) and returns the property value.
  
  properties - Comma-delimited list of property names to test
  
  expected - Comma-delimited list of expected values (exceptions become simple class names)
  
  Throws:
  
  AssertionError - if any mapped property values don't match expected values
  
  See Also:
  
  assertBean(Supplier, Object, String, String)
  
  BeanConverter
  
  BasicBeanConverter
- assertMapped
  
  public static <T> void assertMapped(T actual, BiFunction<T,String,Object> function, String properties, String expected)
  
  Asserts that mapped property access on an object returns expected values using a custom BiFunction.
  Same as assertMapped(Supplier, Object, BiFunction, String, String) but without a custom message.
  Type Parameters:
  
  T - The type of object being tested
  
  Parameters:
  
  actual - The object to test properties on
  
  function - The BiFunction that extracts property values. Receives (object, propertyName) and returns the property value.
  
  properties - Comma-delimited list of property names to test
  
  expected - Comma-delimited list of expected values (exceptions become simple class names)
  
  Throws:
  
  AssertionError - if any mapped property values don't match expected values
  
  See Also:
  
  assertMapped(Supplier, Object, BiFunction, String, String)
- assertMatchesGlob
  
  public static void assertMatchesGlob(String pattern, Object value)
  
  Asserts that an object's string representation matches the specified glob-style pattern.
  Same as assertMatchesGlob(Supplier, String, Object) but without a custom message.
  Parameters:
  
  pattern - The glob-style pattern to match against.
  
  value - The object to test. Must not be null.
  
  Throws:
  
  AssertionError - if the value is null or its string representation doesn't match the pattern
  
  See Also:
  
  assertMatchesGlob(Supplier, String, Object)
- assertMatchesGlob
  
  public static void assertMatchesGlob(Supplier<String> message, String pattern, Object value)
  Asserts that an object's string representation matches the specified glob-style pattern.
  This method converts the actual object to its string representation using the current BeanConverter and then tests it against the provided glob-style pattern. This is useful for testing string formats with simple wildcard patterns.
  
  Pattern Syntax:
  
  The pattern uses glob-style wildcards:
  
  * matches any sequence of characters (including none)
  
  ? matches exactly one character
  
  All other characters are treated literally
  
  Usage Examples:
  
  // Test filename patterns assertMatchesGlob("user_*_temp", filename); // Test single character wildcards assertMatchesGlob("file?.txt", fileName); // Test combined patterns assertMatchesGlob("log_*_?.txt", logFile);
  Parameters:
  
  message - Optional custom error message supplier. If provided, will be composed with the default assertion message.
  
  pattern - The glob-style pattern to match against.
  
  value - The object to test. Must not be null.
  
  Throws:
  
  AssertionError - if the value is null or its string representation doesn't match the pattern
  
  See Also:
  
  for exact string matching
  
  for substring matching
- assertNotEmpty
  
  public static void assertNotEmpty(Object value)
  
  Asserts that a collection-like object, Optional, Value, String, or array is not null and not empty.
  Same as assertNotEmpty(Supplier, Object) but without a custom message.
  Parameters:
  
  value - The object to test. Must not be null.
  
  Throws:
  
  AssertionError - if the object is null or empty
  
  See Also:
  
  assertNotEmpty(Supplier, Object)
- assertNotEmpty
  
  public static void assertNotEmpty(Supplier<String> message, Object value)
  Asserts that a collection-like object, Optional, Value, String, or array is not null and not empty.
  This method validates that the provided object is not empty according to its type:
  
  String: Must have length > 0
  
  Optional: Must be present (not empty)
  
  Value: Must not be empty (value is not null)
  
  Map: Must have at least one entry
  
  Collection: Must have at least one element
  
  Array: Must have length > 0
  
  Other objects: Must convert to a non-empty List via BeanConverter.listify(Object)
  
  Supported Types:
  
  Any object that can be converted to a List, including:
  
  Collections (List, Set, Queue, etc.)
  
  Arrays (primitive and object arrays)
  
  Iterables, Iterators, Streams
  
  Maps (converted to list of entries)
  
  Optional objects
  
  Usage Examples:
  
  // Test non-empty collections assertNotEmpty(List.of("item1", "item2")); assertNotEmpty(new ArrayList<>(Arrays.asList("a"))); // Test non-empty arrays assertNotEmpty(new String[]{"value"}); // Test present Optional assertNotEmpty(Optional.of("value")); // Test non-empty Map assertNotEmpty(Map.of("key", "value"));
  Parameters:
  
  message - Optional custom error message supplier. If provided, will be composed with the default assertion message.
  
  value - The object to test. Must not be null.
  
  Throws:
  
  AssertionError - if the object is null or empty
  
  See Also:
  
  for testing empty collections
  
  for testing specific sizes
- assertSize
  
  public static void assertSize(int expected, Object actual)
  
  Asserts that a collection-like object or string is not null and of the specified size.
  Same as assertSize(Supplier, int, Object) but without a custom message.
  Parameters:
  
  expected - The expected size/length.
  
  actual - The object to test. Must not be null.
  
  Throws:
  
  AssertionError - if the object is null or not the expected size.
  
  See Also:
  
  assertSize(Supplier, int, Object)
- assertSize
  
  public static void assertSize(Supplier<String> message, int expected, Object actual)
  Asserts that a collection-like object or string is not null and of the specified size.
  This method can validate the size of various types of objects:
  
  String: Validates character length
  
  Collection-like objects: Any object that can be converted to a List via the underlying converter
  
  Usage Examples:
  
  // Test string length assertSize(5, "hello"); // Test collection size assertSize(3, List.of("a", "b", "c")); // Test array size assertSize(2, new String[]{"x", "y"});
  Parameters:
  
  message - Optional custom error message supplier. If provided, will be composed with the default assertion message.
  
  expected - The expected size/length.
  
  actual - The object to test. Must not be null.
  
  Throws:
  
  AssertionError - if the object is null or not the expected size.
- assertString
  
  public static void assertString(String expected, Object actual)
  
  Asserts that an object's string representation exactly matches the expected value.
  Same as assertString(Supplier, String, Object) but without a custom message.
  Parameters:
  
  expected - The exact string that the actual object should convert to
  
  actual - The object to test. Must not be null.
  
  Throws:
  
  AssertionError - if the actual object is null or its string representation doesn't exactly match expected
  
  See Also:
  
  assertString(Supplier, String, Object)
- assertString
  
  public static void assertString(Supplier<String> message, String expected, Object actual)
  
  Asserts that an object's string representation exactly matches the expected value.
  This method converts the actual object to its string representation using the current BeanConverter and performs an exact equality comparison with the expected string. This is useful for testing complete string output, formatted objects, or converted values.
  
  Usage Examples:
  
  // Test exact string conversion assertString("John,30,true", user); // Assuming user converts to this format // Test formatted dates or numbers assertString("2023-12-01", localDate); // Test complex object serialization assertString("{name=John,age=30}", userMap); // Test array/collection formatting assertString("[red,green,blue]", colors);
  Parameters:
  
  message - Optional custom error message supplier. If provided, will be composed with the default assertion message.
  
  expected - The exact string that the actual object should convert to
  
  actual - The object to test. Must not be null.
  
  Throws:
  
  AssertionError - if the actual object is null or its string representation doesn't exactly match expected
  
  See Also:
  
  for partial string matching
  
  for pattern-based matching

Class BctAssertions

Bean-Centric Testing (BCT) Framework:

Primary BCT Assertion Methods:

BCT Advanced Features:

Converter Extensibility:

Usage Examples:

Customizing the Default Converter:

Performance and Thread Safety:

Method Summary

Methods inherited from class java.lang.Object

Method Details

assertBean

assertBean

Basic Usage:

Nested Property Testing:

Array, List, and Stream Testing:

Collection Iteration Syntax:

Universal Collection Size Properties:

Class Name Testing:

Method Chaining Support:

Advanced Collection Analysis:

Direct Field Access:

Map Testing:

Collection and Boolean Values:

Value Syntax Rules:

Property Access Priority:

assertBeans

Basic Usage:

Complex Property Testing:

Validation Testing:

Collection Iteration Testing:

Parser Result Testing:

assertBeans

assertContains

assertContains

Usage Examples:

assertContainsAll

assertContainsAll

Usage Examples:

assertEmpty

assertEmpty

Supported Types:

Usage Examples:

assertList

assertList

Testing Non-List Collections:

Comparison Modes:

1. String Comparison (Readable Format):

2. Predicate Testing (Functional Validation):

3. Object Equality (Direct Comparison):

assertMap

assertMap

Map Entry Serialization:

Testing Nested Maps and Collections:

Comparison Modes:

1. String Comparison (Readable Format):

2. Predicate Testing (Functional Validation):

3. Object Equality (Direct Comparison):

Map Ordering Behavior:

assertMapped

assertMapped

assertMatchesGlob

assertMatchesGlob

Pattern Syntax:

Usage Examples:

assertNotEmpty

assertNotEmpty

Supported Types:

Usage Examples:

assertSize

assertSize

Usage Examples:

assertString

assertString

Usage Examples: