assertNull(sentIndex.get());

        sentIndex.set(null);
        sentDocList.clear();
        docList.add(new HashMap<>(Map.of(//
                "_id", "001", //
                "config_id", "W01", //
                "url", "http://test.com/001"//
        )));
        docList.add(new HashMap<>(Map.of(//
                "_id", "002", //
                "thumbnail", "http://test.com/002", //

        final Map<String, Object> params = new HashMap<>();
        params.put("test", "value");
        assertNull(groovyEngine.evaluate(null, params));
    }

    /**
     * Test that evaluate returns null for empty string template
     */
    @Test
    public void test_evaluate_emptyTemplate() {
        final Map<String, Object> params = new HashMap<>();
        params.put("test", "value");

    Map<String, String> hashmap = new HashMap<>();
    hashmap.put("foo", "bar");
    hashmap.put(null, "baz");

    StandardImplForwardingMap<String, String> forwardingMap =
        new StandardImplForwardingMap<>(new HashMap<>());
    forwardingMap.put("foo", "bar");
    forwardingMap.put(null, "baz");

    assertThat(forwardingMap.toString()).isEqualTo(hashmap.toString());
  }

        map.put("data1", 1);
        assertEquals(100.0f, docBoostMatcher.getValue(map));
    }

    @Test
    public void test_getValue_numericStringReturn() {
        final DocBoostMatcher docBoostMatcher = new DocBoostMatcher();
        docBoostMatcher.setBoostExpression("'3.14'");

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

import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.codelibs.fess.unit.UnitFessTestCase;
import org.junit.jupiter.api.Test;

public class DocumentUtilTest extends UnitFessTestCase {

    @Test
    public void test_string() {
        Map<String, Object> doc = new HashMap<>();

        String expected = "1";
        doc.put("key1", expected);

            @Override
            public String getIndexAdminRequiredFields() {
                return "aaa,bbb";
            }
        };

        HashMap<String, Object> source = new HashMap<>();
        assertFalse(fessConfig.validateIndexRequiredFields(source));
        source.put("aaa", null);
        assertFalse(fessConfig.validateIndexRequiredFields(source));

        Map<String, Object> nestedParams = new HashMap<>();
        Map<String, Object> innerMap = new HashMap<>();
        innerMap.put("innerKey", "innerValue");
        nestedParams.put("nested", innerMap);

        assertNotNull(queryRescorer.evaluate(nestedParams));

        // Test without nested parameters
        Map<String, Object> flatParams = new HashMap<>();
        flatParams.put("flat", "value");

    }

    @Override
    protected Map<String, Object> createTestParam(int id) {
        // Not used for this test
        return new HashMap<>();
    }

    @Override
    protected Map<String, Object> getUpdateMap() {
        // Not used for this test
        return new HashMap<>();
    }

    @Override
    @AfterEach
    protected void tearDown() {
        // Custom teardown in tearDownAll
    }

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

        languageHelper.updateDocument(doc);

        // Should not add any language fields
        assertNull(doc.get("lang"));
        assertEquals(0, doc.size());
    }

    @Test
    public void test_updateDocument_skipExistingLangFields() {
        Map<String, Object> doc = new HashMap<>();
        doc.put("lang", "ja");

        Map<String, Object> dataMap1 = new HashMap<>();
        dataMap1.put("url", "http://example.com/test1");
        indexUpdateCallback.store(paramMap, dataMap1);
        assertEquals(1, indexingHelper.sendDocumentsCalled);

        // Add second document - should trigger indexing again
        Map<String, Object> dataMap2 = new HashMap<>();
        dataMap2.put("url", "http://example.com/test2");