* @param id the encoded ID to convert
     * @return PathInfo object with separated path and name
     */
    public static PathInfo convertToItem(final String id) {
        final String value = decodeId(id);
        final String[] values = split(value, "/").get(stream -> stream.filter(StringUtil::isNotEmpty).toArray(n -> new String[n]));
        if (values.length == 0) {
            // invalid?

            return;
        }
        for (final String value : values) {
            if (value.indexOf(',') >= 0) {
                action.throwValidationError(messages -> {
                    messages.addErrorsInvalidStrIsIncluded(propertyName, value, ",");
                }, hook);
            }
            if (value.indexOf("=>") >= 0) {
                action.throwValidationError(messages -> {

        assertEquals(2, names.length);
        assertEquals(2, loadCount[0]); // Should increment
    }

    // Test loadDataStoreNameList with valid XML
    @Test
    public void test_loadDataStoreNameList_validXml() throws Exception {
        // Create test JAR with valid XML
        final File jarFile = new File(tempDir, "test-datastore.jar");
        createTestJarWithXml(jarFile,

        // Test setting different max group depths
        authenticator.setMaxGroupDepth(5);
        authenticator.setMaxGroupDepth(20);
        authenticator.setMaxGroupDepth(1);

        // Verify method accepts valid values without exception
        assertTrue(true);
    }

    @Test
    public void test_setGroupCacheExpiry() {
        EntraIdAuthenticator authenticator = new EntraIdAuthenticator();

            assertEquals("Invalid hour value: 24 in time: 24:00. Hour must be between 0 and 23", e.getMessage());
        }

        try {
            IntervalControlHelper.parseTime("12:60");
            fail("Should throw FessSystemException");
        } catch (FessSystemException e) {
            assertEquals("Invalid minute value: 60 in time: 12:60. Minute must be between 0 and 59", e.getMessage());

    @Override
    public boolean isValid(final String value, final ConstraintValidatorContext context) {
        if (StringUtil.isNotBlank(value)) {
            return check(protocols, value);
        }
        return true;
    }

    /**
     * Checks if the given value matches any of the specified protocols.
     *
     * @param protocols the allowed protocols
     * @param value the URI string to validate

        } catch (IOException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    /**
     * Automatically accept changes that are valid property upgrades of a getter or setter.
     *
     * Here we automatically accept the following cases:
     * - A setter `setX` of an upgraded property is removed
     * - A boolean `isX` of an upgraded property is removed

        }
        String value = content;
        int pos = value.indexOf("<!--");
        while (pos >= 0) {
            final int lastPos = value.indexOf("-->", pos);
            if (lastPos < 0) {
                break;
            }
            if (pos == 0) {
                value = " " + value.substring(lastPos + 3);
            } else {

     * @return ActionResponse containing the cached document content or error redirect
     */
    @Execute
    public ActionResponse index(final CacheForm form) {
        validate(form, messages -> {}, () -> asHtml(virtualHost(path_Error_ErrorJsp)));
        if (isLoginRequired()) {
            return redirectToLogin();
        }

        Map<String, Object> doc = null;
        try {

     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse create(final CreateForm form) {
        verifyCrudMode(form.crudMode, CrudMode.CREATE, this::asListHtml);
        validate(form, messages -> {}, this::asEditHtml);
        verifyToken(this::asEditHtml);
        getRole(form).ifPresent(entity -> {
            try {
                roleService.store(entity);