bean.setSpecialCron("invalid");

        // Validate default group
        Set<ConstraintViolation<GroupTestBean>> violations = validator.validate(bean, Default.class);
        assertEquals(1, violations.size());
        assertTrue(violations.iterator().next().getPropertyPath().toString().contains("defaultCron"));

        // Validate special group
        violations = validator.validate(bean, SpecialGroup.class);

            return 4000;
        }
    }

    /**
     * Parses and validates field filter parameters from the request.
     * Only configured label values are accepted to prevent query injection.
     *
     * @param request the HTTP request
     * @return a map of field names to their validated filter values
     */
    protected Map<String, String[]> parseFieldFilters(final HttpServletRequest request) {

    //                                                                        ============

    /**
     * Validates group attributes using LDAP manager.
     *
     * @param attributes the attributes to validate
     * @param throwError the error handler
     */

     * Reloads the document index by closing and reopening it.
     *
     * @param form the action form (validated but not used for configuration)
     * @return HTML response redirecting to the maintenance page
     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse reloadDocIndex(final ActionForm form) {
        validate(form, messages -> {}, this::asIndexHtml);
        verifyToken(this::asIndexHtml);

import jakarta.validation.ConstraintDefinitionException;
import jakarta.validation.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;

/**
 * Validator implementation for URI type constraints.
 * This validator checks URI strings against specified protocol types.
 */
public class UriTypeValidator implements ConstraintValidator<UriType, String> {

    /**

        form.password = null;
        form.confirmPassword = null;
    }

    /**
     * Validates LDAP user attribute types using the configured LDAP manager.
     *
     * @param attributes the map of attributes to validate
     * @param throwError callback to report any validation errors
     */

    //                                                                           =========
    /**
     * Validates document fields according to index field requirements.
     *
     * @param doc the document to validate
     * @param throwError consumer to handle validation errors
     */

            throw new SsoLoginException("unexpected set of artifacts received");
        }
    }

    /**
     * Validates the OAuth2 state parameter.
     * @param session The HTTP session containing stored state data.
     * @param state The state parameter to validate.
     * @return The validated state data.
     */
    protected StateData validateState(final HttpSession session, final String state) {

        this.systemCpuCheckInterval = systemCpuCheckInterval;
    }

    /**
     * Validates a password against configured password policy requirements.
     *
     * @param password The password to validate.
     * @return An empty string if the password is valid, or an error key for the validation failure.
     */

     */
    protected void write(final String path, final byte[] data) {
        validateFilePath(path);
        LdiFileUtil.write(path, data);
    }

    /**
     * Validates the file path.
     *
     * @param path the file path to validate
     */
    protected void validateFilePath(final String path) {
        if (StringUtil.isBlank(path)) {
            throw new IllegalArgumentException("File path cannot be blank.");