}
        for (final Map.Entry<String, String> entry : conditionMap.entrySet()) {
            if (docMap.get(entry.getKey()) instanceof final String value && value.matches(entry.getValue())) {
                if (logger.isDebugEnabled()) {
                    logger.debug("[{}] match {}:{}", entry.getKey(), name, value);
                }
                return true;
            }
        }
        return false;
    }

                        successCount.incrementAndGet();
                    }
                } catch (Exception e) {
                    errorCount.incrementAndGet();
                } finally {
                    latch.countDown();
                }
            }).start();
        }

        latch.await();

        assertEquals("All threads should succeed", threadCount, successCount.get());

        // Execute and expect IOException
        try {
            webApiFilter.doFilter(request, response, chain);
            fail("Expected IOException");
        } catch (IOException e) {
            assertEquals("Test IOException", e.getMessage());
        } catch (ServletException e) {
            fail("Unexpected ServletException: " + e.getMessage());
        }
    }

        this.maxIndexerErrorCount = maxIndexerErrorCount;
    }

    /**
     * Adds a document boost matcher rule for enhancing document relevance scores.
     *
     * @param rule the document boost matcher rule to add
     */
    public void addDocBoostMatcher(final DocBoostMatcher rule) {
        docBoostMatcherList.add(rule);
    }

    /**

            for (int i = 0; i < events.size(); i += BATCH_SIZE) {
                final List<LogNotificationEvent> batch = events.subList(i, Math.min(i + BATCH_SIZE, events.size()));
                final BulkRequestBuilder bulkRequest = client.prepareBulk();
                for (final LogNotificationEvent event : batch) {
                    final Map<String, Object> source = new HashMap<>();
                    source.put("hostname", hostname);

    //                                                                        ============
    /**
     * Verify that the CRUD mode matches the expected mode.
     * Throws validation error if modes don't match.
     *
     * @param crudMode The current CRUD mode
     * @param expectedMode The expected CRUD mode
     * @param dictId The dictionary ID for error context
     */

        return searchEngineClient.delete(fessConfig.getIndexDocumentUpdateIndex(), id);
    }

    /**
     * Deletes all documents that match the specified URL.
     *
     * @param searchEngineClient the search engine client to use for deletion
     * @param url the URL to match for document deletion
     * @return the number of documents that were deleted
     */

        final String value = clientConfigMap.get(CRAWLER_CLIENTS);
        final CrawlerClient client = getClientRuleList(value).stream().map(e -> {
            if (e.getSecond().matcher(url).matches()) {
                return e.getFirst();
            }
            return null;
        })
                .filter(StringUtil::isNotBlank)
                .findFirst()//

            fail("Should throw FessSystemException");
        } catch (FessSystemException e) {
            assertEquals("Invalid time format: 12. Expected format: HH:MM", e.getMessage());
        }

        try {
            IntervalControlHelper.parseTime("12:30:45");
            fail("Should throw FessSystemException");
        } catch (FessSystemException e) {

<%@page pageEncoding="UTF-8" contentType="text/html; charset=UTF-8"%>
<%-- query did not match any document --%>
<div id="result" class="row">
	<div class="col-md-8">
		<div class="text-center py-4">
			<p class="mb-3"><i class="fa fa-search fa-3x text-muted" aria-hidden="true"></i></p>
			<p class="mb-2"><la:message key="labels.did_not_match" arg0="${displayQuery}" /></p>
			<p class="text-muted"><la:message key="labels.did_not_match_suggestion" /></p>