// Test with reflection to access protected method
        List<String> names = testFactory.loadDataStoreNameList();
        assertTrue(names.isEmpty() || names.size() >= 0); // Will be empty due to ResourceUtil static method
    }

    // Test loadDataStoreNameList with malformed XML
    @Test
    public void test_loadDataStoreNameList_malformedXml() throws Exception {

                cb2.fetchFirst(fessConfig.getPageFavoriteLogMaxFetchSizeAsInteger());
            });
            if (!list.isEmpty()) {
                final List<String> newUrlList = new ArrayList<>(list.size());
                for (final FavoriteLog favoriteLog : list) {
                    newUrlList.add(favoriteLog.getUrl());
                }
                return newUrlList;
            }

    }

    @Test
    public void test_crawlingInfoPager_pageSize() {
        final CrawlingInfoPager pager = new CrawlingInfoPager();
        assertEquals(25, pager.getPageSize()); // Default page size
    }

    @Test
    public void test_crawlingInfo_entity() {
        final CrawlingInfo info = new CrawlingInfo();
        assertNull(info.getId());
        assertNull(info.getSessionId());

        Map<String, Object> dataMap = new HashMap<>();

        transformer.putResultDataBody(dataMap, "newKey", "newValue");

        assertEquals("newValue", dataMap.get("newKey"));
        assertEquals(1, dataMap.size());
    }

    /**
     * Test putResultDataBody with null handling
     */
    @Test
    public void test_putResultDataBody_withNullValues() {

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

    /**
     * Cache for storing available artifacts by type.
     * The cache expires after 5 minutes and has a maximum size of 10 entries.
     */
    protected LoadingCache<ArtifactType, Artifact[]> availableArtifacts = CacheBuilder.newBuilder()
            .maximumSize(10)
            .expireAfterWrite(5, TimeUnit.MINUTES)

However, the Java code we have is not fully annotated, which causes several consequences:
* IDE warnings can be misleading
* Redundant null checks may increase binary size, hurt performance, and increase cognitive load for readers
* Missing null checks may cause NullPointerException
* Bridging with Kotlin code is polluted with platform types

 * classes and the classes they depend on. The classes are not relocated, they all
 * remain in their original namespace. This reduces the final Gradle distribution
 * size and makes us more conscious of which parts of a library we really need.
 *
 * WARNING: if you decide to do the minification by hand, make sure that you cover all paths of loading classes:

    /**
     * Initializes the crawler statistics helper.
     * Sets up the statistics logger and creates the cache for storing
     * statistics objects with the configured size and expiration settings.
     */
    @PostConstruct
    public void init() {
        statsLogger = LogManager.getLogger(loggerName);
        statsCache = CacheBuilder.newBuilder()
                .maximumSize(maxCacheSize)

            dataCrawlingThreadStatusList.add(Constants.READY);

        }

        int startedCrawlerNum = 0;
        int activeCrawlerNum = 0;
        while (startedCrawlerNum < dataCrawlingThreadList.size()) {
            // Force to stop crawl
            if (systemHelper.isForceStop()) {
                for (final DataCrawlingThread crawlerThread : dataCrawlingThreadList) {
                    crawlerThread.stopCrawling();

                                waitingThreadNames.size(), threadName);
                    }
                    return false;
                }
                if (logger.isInfoEnabled()) {
                    logger.info("Cpu Load {}% is greater than {}%. {} waiting thread(s).", current, percent, waitingThreadNames.size());
                }
                if (logger.isDebugEnabled()) {