}
        };

        callback.store(new DataStoreParams(), new HashMap<>());
        assertEquals(1L, callback.getDocumentSize());
    }

    @Test
    public void test_commit_behavior() {
        // Test commit behavior with state tracking
        final AtomicInteger commitCount = new AtomicInteger(0);
        final AtomicLong documentsBeforeCommit = new AtomicLong(0);

        List<LogNotificationEvent> events = new ArrayList<>();
        events.add(new LogNotificationEvent(base, "ERROR", "org.test.A", "first", null));
        events.add(new LogNotificationEvent(base + 1000, "WARN", "org.test.B", "second", null));
        events.add(new LogNotificationEvent(base + 2000, "ERROR", "org.test.C", "third", null));

        String details = testableJob.testFormatDetails(events);

    @Test
    public void test_matches_basicTag() {
        PrunedTag tag = new PrunedTag("div");

        MockNode divNode = new MockNode("div");
        assertTrue(tag.matches(divNode));

        MockNode spanNode = new MockNode("span");
        assertFalse(tag.matches(spanNode));

        // Case insensitive test
        MockNode divUpperNode = new MockNode("DIV");
        assertTrue(tag.matches(divUpperNode));
    }

        // Test with different types of causes
        DataStoreException withIOException = new DataStoreException("IO Error", new java.io.IOException("File not found"));
        DataStoreException withNPE = new DataStoreException("NPE Error", new NullPointerException("Null value"));
        DataStoreException withCustom = new DataStoreException("Custom Error", new FessSystemException("System error"));

        Exception innerException = new IllegalArgumentException("Invalid argument");
        Error middleError = new AssertionError("Assertion failed", innerException);
        RuntimeException outerException = new RuntimeException("Outer error", middleError);
        ThumbnailGenerationException exception = new ThumbnailGenerationException(message, outerException);

        assertNull(DocumentUtil.getValue(doc, "key2", String.class));
    }

    @Test
    public void test_strings() {
        Map<String, Object> doc = new HashMap<>();
        doc.put("key1", new String[] { "aaa", "bbb" });
        assertArrayEquals(new String[] { "aaa", "bbb" }, DocumentUtil.getValue(doc, "key1", String[].class));

        super.setUp(testInfo);
        suggestHelper = new SuggestHelper();
        setupMockComponents();
    }

    private void setupMockComponents() {
        ComponentUtil.setFessConfig(new MockFessConfig());
        ComponentUtil.register(new MockSearchEngineClient(), "searchEngineClient");
        ComponentUtil.register(new MockSearchLogBhv(), "searchLogBhv");
        ComponentUtil.register(new MockElevateWordBhv(), "elevateWordBhv");

    @Test
    public void test_nestedExceptions() {
        // Test nested exception handling
        Exception innerCause = new IllegalArgumentException("Invalid LDAP parameter");
        RuntimeException middleCause = new RuntimeException("LDAP configuration error", innerCause);
        LdapOperationException exception = new LdapOperationException("LDAP operation failed", middleCause);

                throw new RuntimeException("Crawling error");
            }
        };

        SearchLogService searchLogService = new SearchLogService() {
            @Override
            public void deleteBefore(int days) {
                throw new RuntimeException("Search error");
            }
        };

        JobLogService jobLogService = new JobLogService() {
            @Override

        assertEquals(0L, MemoryUtil.sizeOf(new String[] { null, null }));

        // Mixed content array
        assertEquals(84L, MemoryUtil.sizeOf(new Object[] { "test", 123, null }));

        // Nested arrays
        assertEquals(120L, MemoryUtil.sizeOf(new Object[] { new String[] { "test" }, new String[] { "test" } }));
    }

    @Test
    public void test_sizeOf_collectionVariations() {
        // Empty collection