// Clear the filter
        urlFilter.clear();

        // After clear, all URLs should match (no filters applied)
        assertTrue(urlFilter.match("https://example.com/page"));
        assertTrue(urlFilter.match("https://other.com/page"));
        assertTrue(urlFilter.match("https://any.com/image.jpg"));
    }

    /**
     * Test clear method without initialization
     */

            addDocumentToQueue();
        }

        return queue.poll();
    }

    @Override
    public void close() {
        isFinished.set(true);
        queue.clear();
    }

    /**
     * Sets the scroll size.
     * @param scrollSize The scroll size.
     */
    public void setScrollSize(final int scrollSize) {
        this.scrollSize = scrollSize;
    }

                return token;
            }
        }
    }

    void consultDictionary() throws IOException {
        if (synonymMap == null) {
            return;
        }
        synonyms.clear();
        final char[] key = block.toString().toCharArray();
        for (int start = 0; start < block.length();) {
            final BytesRef matchOutput = getLongestMatchOutput(key, start);

        }

        public void addCondition(String key, String value) {
            conditions.put(key, value);
        }

        public void clearConditions() {
            conditions.clear();
        }
    }

    /**
     * Test response processor implementation
     */
    public static class TestResponseProcessor implements ResponseProcessor, Serializable {

    /**
     * Clears a scroll context.
     *
     * @param scrollId The scroll ID to clear.
     */
    public void clearScroll(final String scrollId) {
        if (scrollId != null) {
            prepareClearScroll().addScrollId(scrollId)
                    .execute(ActionListener.wrap(res -> {}, e -> logger.warn("Failed to clear " + scrollId, e)));
        }
    }

    /**
     * Listener for connection events.

        assertEquals(listener2, factory.getOnDestroyListener());
        factory.destroyObject(pooledObject);
        assertEquals(2, events.size());
        assertEquals("listener2", events.get(1));

        // Clear listener
        factory.setOnDestroyListener(null);
        assertNull(factory.getOnDestroyListener());
        factory.destroyObject(pooledObject);
        assertEquals(2, events.size()); // No new events
    }

                logger.warn("Failed to restore " + urlQueue, e);
            }
        }));
    }

    /**
     * Clears the cache.
     */
    public void clearCache() {
        sessionCache.clear();
    }

    /**
     * Updates the session ID for all URL queue entries.
     *
     * @param oldSessionId The old session ID.
     * @param newSessionId The new session ID.
     */
    @Override

     */
    public void cleanup(final String sessionId) {
        // TODO transaction?
        urlQueueService.delete(sessionId);
        dataService.delete(sessionId);
        urlFilter.clear();
    }

    /**
     * Closes the crawler, releasing resources.
     * This method is called automatically when the crawler is used in a try-with-resources statement.
     */
    @Override

                        numberOfSuggestDocs += res.getNumberOfSuggestDocs();
                        numberOfInputDocs += res.getNumberOfInputDocs();
                        queryLogs.clear();

                        Thread.sleep(requestInterval);
                    }
                }
                deferred.resolve(

        }

        public List<String> getNameHistory() {
            return new ArrayList<>(nameHistory);
        }

        public void clearHistory() {
            nameHistory.clear();
        }
    }

    private TestTransformer testTransformer;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        testTransformer = new TestTransformer();