Configuration API

/**
 * Creates a configuration object that can be reused with EqualsVerifier for multiple classes.
 * It has a fluent API.
 * @return A reusable configuration object with a fluent API
 */
public static ConfiguredEqualsVerifier configure();

/**
 * Creates a configuration object that is pre-configured so that it can be used with most
 * IDE-generated equals and hashCode methods without any further configuration.
 * @return A reusable configuration object with a fluent API
 */
public static ConfiguredEqualsVerifier simple();

import nl.jqno.equalsverifier.EqualsVerifier;
import nl.jqno.equalsverifier.ConfiguredEqualsVerifier;

// Create basic configuration
ConfiguredEqualsVerifier config = EqualsVerifier.configure()
    .suppress(Warning.STRICT_INHERITANCE)
    .withPrefabValues(ExternalDependency.class, redValue, blueValue);

// Create simple pre-configured setup
ConfiguredEqualsVerifier simpleConfig = EqualsVerifier.simple()
    .withPrefabValues(Database.class, mockDb1, mockDb2);

/**
 * Default constructor for creating new configuration
 */
public ConfiguredEqualsVerifier();

/**
 * Returns a copy of the configuration
 * @return a copy of the configuration
 */
public ConfiguredEqualsVerifier copy();

// Create base configuration
ConfiguredEqualsVerifier baseConfig = EqualsVerifier.configure()
    .suppress(Warning.STRICT_INHERITANCE);

// Create variations of the base configuration
ConfiguredEqualsVerifier entityConfig = baseConfig.copy()
    .suppress(Warning.SURROGATE_KEY);

ConfiguredEqualsVerifier dtoConfig = baseConfig.copy()
    .suppress(Warning.NONFINAL_FIELDS);

/**
 * Suppresses warnings given by EqualsVerifier. See Warning to see what warnings can be suppressed.
 * @param warnings A list of warnings to suppress in EqualsVerifier
 * @return this, for easy method chaining
 */
public ConfiguredEqualsVerifier suppress(Warning... warnings);

// Suppress multiple warnings
ConfiguredEqualsVerifier config = EqualsVerifier.configure()
    .suppress(Warning.STRICT_INHERITANCE, Warning.NONFINAL_FIELDS, Warning.NULL_FIELDS);

// Conditional warning suppression
ConfiguredEqualsVerifier.Builder configBuilder = EqualsVerifier.configure();
if (isLegacyCodebase()) {
    configBuilder.suppress(Warning.STRICT_HASHCODE);
}
ConfiguredEqualsVerifier config = configBuilder;

/**
 * Adds prefabricated values for instance fields of classes that EqualsVerifier cannot
 * instantiate by itself
 * @param otherType The class of the prefabricated values
 * @param red An instance of S
 * @param blue Another instance of S, not equal to red
 * @return this, for easy method chaining
 */
public <S> ConfiguredEqualsVerifier withPrefabValues(
    Class<S> otherType, 
    S red, 
    S blue
);

/**
 * Adds a factory to generate prefabricated values for instance fields of classes with 1 generic
 * type parameter that EqualsVerifier cannot instantiate by itself
 * @param otherType The class of the prefabricated values
 * @param factory A factory to generate an instance of S, given a value of its generic type parameter
 * @return this, for easy method chaining
 */
public <S> ConfiguredEqualsVerifier withGenericPrefabValues(
    Class<S> otherType, 
    Func1<?, S> factory
);

/**
 * Adds a factory to generate prefabricated values for instance fields of classes with 2 generic
 * type parameters that EqualsVerifier cannot instantiate by itself
 * @param otherType The class of the prefabricated values
 * @param factory A factory to generate an instance of S, given values of its generic type parameters
 * @return this, for easy method chaining
 */
public <S> ConfiguredEqualsVerifier withGenericPrefabValues(
    Class<S> otherType, 
    Func2<?, ?, S> factory
);

// Configure prefab values for complex types
ConfiguredEqualsVerifier config = EqualsVerifier.configure()
    .withPrefabValues(ExternalService.class, mockService1, mockService2)
    .withPrefabValues(Database.class, testDb1, testDb2)
    .withGenericPrefabValues(Optional.class, Optional::of)
    .withGenericPrefabValues(Map.class, Map::of);

// Use across multiple classes
config.forClass(UserService.class).verify();
config.forClass(OrderService.class).verify();
config.forClass(ProductService.class).verify();

/**
 * Signals that getClass is used in the implementation of the equals method,
 * instead of an instanceof check
 * @return this, for easy method chaining
 */
public ConfiguredEqualsVerifier usingGetClass();

/**
 * Determines how a getter name can be derived from a field name
 * @param converter A function that converts from field name to getter name
 * @return this, for easy method chaining
 */
public ConfiguredEqualsVerifier withFieldnameToGetterConverter(
    Function<String, String> converter
);

/**
 * Signals that all internal caches need to be reset
 * @return this, for easy method chaining
 * @deprecated No longer needed; this happens automatically
 */
@Deprecated
public ConfiguredEqualsVerifier withResetCaches();

// Configure for getClass usage
ConfiguredEqualsVerifier config = EqualsVerifier.configure()
    .usingGetClass()
    .suppress(Warning.STRICT_INHERITANCE);

// Configure custom getter naming convention
ConfiguredEqualsVerifier config = EqualsVerifier.configure()
    .withFieldnameToGetterConverter(fieldName -> 
        "retrieve" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1));

/**
 * Factory method for single class verification
 * @param type The class for which the equals method should be tested
 * @return A fluent API for EqualsVerifier
 */
public <T> SingleTypeEqualsVerifierApi<T> forClass(Class<T> type);

/**
 * Factory method for multiple class verification from iterable
 * @param classes An iterable containing the classes for which equals method should be tested
 * @return A fluent API for EqualsVerifier
 */
public MultipleTypeEqualsVerifierApi forClasses(Iterable<Class<?>> classes);

/**
 * Factory method for multiple class verification with varargs
 * @param first A class for which the equals method should be tested
 * @param second Another class for which the equals method should be tested
 * @param more More classes for which the equals method should be tested
 * @return A fluent API for EqualsVerifier
 */
public MultipleTypeEqualsVerifierApi forClasses(
    Class<?> first,
    Class<?> second,
    Class<?>... more
);

/**
 * Factory method for package scanning (non-recursive)
 * @param packageName A package for which each class's equals should be tested
 * @return A fluent API for EqualsVerifier
 */
public MultipleTypeEqualsVerifierApi forPackage(String packageName);

/**
 * Factory method for package scanning with recursion control
 * @param packageName A package for which each class's equals should be tested
 * @param scanRecursively true to scan all sub-packages
 * @return A fluent API for EqualsVerifier
 */
public MultipleTypeEqualsVerifierApi forPackage(
    String packageName, 
    boolean scanRecursively
);

/**
 * Factory method for package scanning with type filtering
 * @param packageName A package for which each class's equals should be tested
 * @param mustExtend if not null, returns only classes that extend or implement this class
 * @return A fluent API for EqualsVerifier
 */
public MultipleTypeEqualsVerifierApi forPackage(
    String packageName, 
    Class<?> mustExtend
);

// Create shared configuration
ConfiguredEqualsVerifier config = EqualsVerifier.configure()
    .suppress(Warning.STRICT_INHERITANCE, Warning.NONFINAL_FIELDS)
    .withPrefabValues(ExternalDependency.class, redValue, blueValue);

// Apply to single classes
config.forClass(Person.class).verify();
config.forClass(Address.class).verify();

// Apply to multiple classes
config.forClasses(Person.class, Address.class, Phone.class).verify();

// Apply to packages
config.forPackage("com.example.model").verify();
config.forPackage("com.example.entities", true).verify();

// Base configuration for all domain objects
ConfiguredEqualsVerifier baseDomainConfig = EqualsVerifier.configure()
    .suppress(Warning.STRICT_INHERITANCE)
    .withPrefabValues(CommonDependency.class, commonRed, commonBlue);

// Specialized configuration for JPA entities
ConfiguredEqualsVerifier jpaConfig = baseDomainConfig.copy()
    .suppress(Warning.SURROGATE_KEY, Warning.JPA_GETTER);

// Specialized configuration for DTOs
ConfiguredEqualsVerifier dtoConfig = baseDomainConfig.copy()
    .suppress(Warning.NONFINAL_FIELDS);

// Use specialized configurations
jpaConfig.forPackage("com.example.entities").verify();
dtoConfig.forPackage("com.example.dto").verify();

public class EqualsVerifierTestBase {
    protected static ConfiguredEqualsVerifier createConfig() {
        ConfiguredEqualsVerifier.Builder builder = EqualsVerifier.configure()
            .suppress(Warning.STRICT_INHERITANCE);
        
        if (isTestEnvironment()) {
            builder.withPrefabValues(DatabaseConnection.class, mockDb1, mockDb2);
        } else {
            builder.withPrefabValues(DatabaseConnection.class, realDb1, realDb2);
        }
        
        if (isLegacyMode()) {
            builder.suppress(Warning.STRICT_HASHCODE, Warning.NONFINAL_FIELDS);
        }
        
        return builder;
    }
}

// Usage in test classes
ConfiguredEqualsVerifier config = createConfig();
config.forClass(UserEntity.class).verify();

// JUnit 5 extension for shared configuration
@ExtendWith(EqualsVerifierExtension.class)
class PersonTest {
    @EqualsVerifierConfig
    static ConfiguredEqualsVerifier config() {
        return EqualsVerifier.configure()
            .suppress(Warning.STRICT_INHERITANCE)
            .withPrefabValues(Address.class, 
                new Address("123 Main St"), 
                new Address("456 Oak Ave"));
    }
    
    @Test
    void testPersonEquals() {
        config().forClass(Person.class).verify();
    }
}

// Compose configurations for different layers
public static class Configurations {
    public static final ConfiguredEqualsVerifier ENTITY_CONFIG = 
        EqualsVerifier.configure()
            .suppress(Warning.SURROGATE_KEY, Warning.JPA_GETTER);
    
    public static final ConfiguredEqualsVerifier DTO_CONFIG = 
        EqualsVerifier.configure()
            .suppress(Warning.NONFINAL_FIELDS);
    
    public static final ConfiguredEqualsVerifier VALUE_OBJECT_CONFIG = 
        EqualsVerifier.simple();
    
    public static ConfiguredEqualsVerifier withCommonPrefabs(
            ConfiguredEqualsVerifier base) {
        return base.copy()
            .withPrefabValues(UUID.class, UUID.randomUUID(), UUID.randomUUID())
            .withGenericPrefabValues(Optional.class, Optional::of);
    }
}

// Usage
Configurations.withCommonPrefabs(Configurations.ENTITY_CONFIG)
    .forPackage("com.example.entities")
    .verify();