return processResponse(searchResponseOpt);
    }

    /**
     * Processes the OpenSearch response and converts it to a SearchResult.
     *
     * @param searchResponseOpt the optional search response from OpenSearch
     * @return the processed search result
     */
    protected SearchResult processResponse(final OptionalEntity<SearchResponse> searchResponseOpt) {

                    indexUpdateCallback.store(paramMap, dataMap);
                    crawlerStatsHelper.record(keyObj, StatsAction.PROCESSED);
                } else {
                    logger.warn("The response processor is not DefaultResponseProcessor. responseProcessor: {}, Data: {}",
                            responseProcessor, dataMap);
                }

     * @param crawlingInfoId the crawling session ID
     * @param url the URL to process
     * @return a map containing the processed document data
     * @throws CrawlingAccessException if crawling fails or configuration is invalid
     * @throws ChildUrlsException if the URL redirects to another location
     * @throws CrawlerSystemException if data deserialization fails
     */

    protected LinkedList<String> tagQueue;

    /** List to store parsed label types for access control. */
    protected List<LabelType> labelList;

    /** Current label type being processed during parsing. */
    protected LabelType labelType;

    /** Map to store global configuration parameters. */
    protected Map<String, String> globalParams = new HashMap<>();

     */
    public void addHighlightedQuery(final String text) {
        if (highlightedQuerySet != null) {
            highlightedQuerySet.add(text);
        }
    }

    /**
     * Gets the processed query string.
     * @return The query string.
     */
    public String getQueryString() {
        return queryString;
    }

    /**
     * Checks if role-based query filtering is enabled.

            authenticationManager.insert(user);
            fail("Should throw NullPointerException when processing null chain");
        } catch (NullPointerException e) {
            // Expected behavior when null chain is processed
            assertTrue(true);
        }
    }

    // Test chains order preservation
    public void test_chains_orderPreservation() {
        List<TestAuthenticationChain> chains = new ArrayList<>();

         * - The maximum size of alphanumeric and symbol terms can be limited by `maxAlphanumTermSize` and `maxSymbolTermSize` respectively.
         *
         * @return A processed string with terms and spaces, or an empty string if the reader is null or an IOException occurs.
         */
        public String execute() {
            if (reader == null) {
                return StringUtil.EMPTY;

process images, audio, videos, and text. There are several modules specialized
in taking those formats, modifying them, and/or converting them to intermediate
formats that can be processed by TensorFlow.

These modifications and conversions are handled by a variety of libraries that
have different security properties and provide different levels of confidence

        Object result1 = scriptExecutor.execute("testengine", "script1");
        assertEquals("processed: script1", result1);

        Object result2 = scriptExecutor.execute("TESTENGINE", "script2");
        assertEquals("processed: script2", result2);

        Object result3 = scriptExecutor.execute("TestEngine", "script3");
        assertEquals("processed: script3", result3);
    }

    public void test_execute_verifyParamsNotModifiable() {

        assertNotNull(queryBuilder);
        assertTrue(queryBuilder instanceof WildcardQueryBuilder);

        // Query was processed successfully

        // Query was processed successfully
        WildcardQueryBuilder wqb = (WildcardQueryBuilder) queryBuilder;
        assertEquals("title", wqb.fieldName());
    }