if (!matcher.matches()) {
                return s;
            }
            final int v = Integer.parseInt(matcher.group(1));
            if ("-".equals(matcher.group(2))) {
                if (version >= v) {
                    return matcher.group(3);
                }
            } else if (v == version) {
                return matcher.group(3);
            }

        for (Map<String, String> item : dicts) {
            assertTrue(item.containsKey("id"));
            assertTrue(item.containsKey("type"));
            if (getDictType().equals(item.get("type"))) {
                dictId = item.get("id");
                return;
            }
        }

        fail();
    }

    @Override
    protected String getJsonPath() {

            for (int i = 0; i < components.length; i++) {
                String component = components[i].replaceAll("[<>:\"|?*\\\\]", "_");
                if (".".equals(component) || "..".equals(component)) {
                    continue;
                }
                if (component.length() > MAX_PATH_COMPONENT_LENGTH) {

        final List<Map<String, Object>> resList = new ArrayList<>();
        for (Map<String, Object> elem : logList) {
            if (elem.containsKey("job_name") && elem.get("job_name").equals(namePrefix + "Scheduler")) {
                resList.add(elem);
            }
        }
        return resList;
    }

    protected static List<Map<String, Object>> readLogItems(final String apiName) {

        String result2 = aggregateLogJob.execute();
        assertNotNull(result2);
        assertTrue(result2.contains("Error 2"));

        // Results should be independent
        assertFalse(result1.equals(result2));
    }

    @Test
    public void test_execute_withEmptyStringException() {
        // Setup mock SearchLogHelper that throws exception with empty message

        val allBuildTypes = rootProject.subProjects.flatMap { it.buildTypes }
        allBuildTypes.forEach {
            val credentialLeakCondition = it.failureConditions.items.find { it.type.equals("BuildFailureOnMessage") } as BuildFailureOnText
            assertTrue(credentialLeakCondition.enabled)
            assertTrue(credentialLeakCondition.stopBuildOnFailure!!)
        }
    }

                final String[] ids = { "", "", "" };
                if (Constants.WEB_CRAWLER_TYPE.equals(type)) {
                    ids[0] = "\"" + id + "\"";
                } else if (Constants.FILE_CRAWLER_TYPE.equals(type)) {
                    ids[1] = "\"" + id + "\"";
                } else if (Constants.DATA_CRAWLER_TYPE.equals(type)) {
                    ids[2] = "\"" + id + "\"";
                }

        // Verify document content
        for (int i = 0; i < 5; i++) {
            final String expectedTitle = NAME_PREFIX + i;
            boolean found = docs.stream().anyMatch(doc -> expectedTitle.equals(doc.get("title")));
            assertTrue(found, "Document with title " + expectedTitle + " should exist");
        }

        logger.info("[END] testBulkCreate");
    }

    /**

            final float boost, final String field, final String[] texts) {
        final String text = String.join(" ", texts);

        if (Constants.DEFAULT_FIELD.equals(field)) {
            context.addFieldLog(field, text);
            stream(texts).of(stream -> stream.forEach(t -> context.addHighlightedQuery(t)));

     *
     * @return true if LLM chat is configured and available, false otherwise
     */
    public boolean available() {
        final String llmType = getLlmType();
        if (Constants.NONE.equals(llmType)) {
            if (logger.isTraceEnabled()) {
                logger.trace("[LLM] LLM not available. llmType=none");
            }
            return false;
        }
        if (!isRagChatEnabled()) {