dataService.delete("id1");

        assertNull(dataService.getAccessResult("id1", "http://www.id1.com/"));
        assertNotNull(dataService.getAccessResult("id2", "http://www.id2.com/"));

        dataService.store(accessResult1);
        assertNotNull(dataService.getAccessResult("id1", "http://www.id1.com/"));

        dataService.deleteAll();

import org.codelibs.fess.crawler.util.CrawlerWebServer;
import org.dbflute.utflute.core.PlainTestCase;

public class CrawlerTest extends PlainTestCase {

    public Crawler crawler;

    public DataService dataService;

    public UrlQueueService urlQueueService;

    public FileTransformer fileTransformer;

    private StandardCrawlerContainer container;

    @Override
    protected void setUp() throws Exception {

    public void test_dataService_setAndGet() {
        // Initially should be null
        assertNull(CrawlingParameterUtil.getDataService());

        // Create a mock DataService
        DataService<AccessResult<?>> service = new DataService<AccessResult<?>>() {
            @Override
            public void store(AccessResult<?> accessResult) {
            }

            @Override

     * Otherwise, it sets the provided DataService to the current thread's local storage.
     *
     * @param dataService the DataService instance to be set for the current thread, or null to remove it
     */
    public static void setDataService(final DataService<AccessResult<?>> dataService) {
        if (dataService == null) {
            DATA_SERVICE_THREAD_LOCAL.remove();

     * if too many empty results are encountered or if a system shutdown is requested.
     */
    @Override
    public void run() {
        if (dataService == null) {
            throw new FessSystemException("DataService is null. IndexUpdater cannot proceed without a DataService instance.");
        }

        if (logger.isDebugEnabled()) {
            logger.debug("Starting indexUpdater.");
        }

context.setMaxDepth(3);           // Max depth (-1 = unlimited)
context.setNumOfThread(10);       // Concurrent threads
```

### Accessing Results

```java
DataService ds = container.getComponent("dataService");

// Count
int count = ds.getCount(sessionId);

// Get by URL
AccessResult result = ds.getAccessResult(sessionId, url);

// Iterate all
ds.iterate(sessionId, accessResult -> {

    private CrawlerThread crawlerThread;
    private CrawlerContext crawlerContext;
    private UrlQueueService<UrlQueue<?>> urlQueueService;
    private DataService dataService;
    private CrawlerContainer crawlerContainer;
    private LogHelper logHelper;
    private CrawlerClientFactory clientFactory;
    private UrlFilter urlFilter;
    private RuleManager ruleManager;

    @Override
    @SuppressWarnings("unchecked")

    private static final Logger logger = LogManager.getLogger(OpenSearchUrlQueueService.class);

    /**
     * Data service for checking access results.
     */
    @Resource
    protected OpenSearchDataService dataService;

    /**
     * Cache for session queues.
     */
    protected Map<String, QueueHolder> sessionCache = new ConcurrentHashMap<>();

    /**
     * The number of URLs to fetch when polling.
     */

import org.opensearch.search.SearchHits;

import jakarta.annotation.PostConstruct;

/**
 * OpenSearchDataService is an implementation of {@link DataService} for OpenSearch.
 */
public class OpenSearchDataService extends AbstractCrawlerService implements DataService<OpenSearchAccessResult> {

    /**
     * Fields to fetch for access result list without data.
     */

     */
    @Resource
    protected UrlQueueService<UrlQueue<?>> urlQueueService;

    /**
     * Service for managing access result data.
     */
    @Resource
    protected DataService<AccessResult<?>> dataService;

    /**
     * Filter for URLs to control which URLs are crawled.
     */
    @Resource
    protected UrlFilter urlFilter;

    /**
     * Manager for crawling rules and configurations.