docMap.put("key1", "value1");
        docMap.put("key2", "value2");
        docMap.put("key3", "value3");

        Collection<Object> values = docMap.values();
        assertEquals(3, values.size());
        assertTrue(values.contains("value1"));
        assertTrue(values.contains("value2"));
        assertTrue(values.contains("value3"));
    }

    @Test

    public void test_multipleOperations() {
        // Add initial values
        dataStoreParams.put("key1", "value1");
        dataStoreParams.put("key2", 123);

        // Add more values using putAll
        Map<String, String> additionalParams = new HashMap<>();
        additionalParams.put("key3", "value3");
        additionalParams.put("key4", "value4");
        dataStoreParams.putAll(additionalParams);

        // Test with normal name and values
        String name = "paramName";
        String[] values = { "value1", "value2", "value3" };
        RequestParameter param = new RequestParameter(name, values);

        assertEquals(name, param.getName());
        assertNotNull(param.getValues());
        assertEquals(3, param.getValues().length);
        assertEquals("value1", param.getValues()[0]);

        // Test getting multiple different properties
        String value1 = fessConfig.get("domain.title");
        String value2 = fessConfig.get("search_engine.type");

        assertEquals("Test Fess", value1);
        assertEquals("opensearch", value2);
        assertFalse(value1.equals(value2));
    }

    // Test empty string property value
    @Test
    public void test_get_emptyStringValue() {

        value = "  key1  =  value1  \n  key2=value2\n";
        paramMap = ParameterUtil.parse(value);
        assertEquals(2, paramMap.size());
        assertEquals("value1", paramMap.get("key1"));
        assertEquals("value2", paramMap.get("key2"));

        // Test with empty lines and mixed whitespace
        value = "key1=value1\n\n\t\nkey2=value2\n \n";
        paramMap = ParameterUtil.parse(value);

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

        // First add a single value
        transformer.putResultDataBody(dataMap, "key1", "value1");
        assertEquals("value1", dataMap.get("key1"));

        // Add an array - should merge with existing value
        String[] newValues = new String[] { "value2", "value3" };
        transformer.putResultDataBody(dataMap, "key1", newValues);

        request.setParameterValues("test", new String[] { "value1", "value2", "value1" });
        String[] result = SearchRequestParams.getParamValueArray(request, "test");
        assertEquals(2, result.length);
        assertEquals("value1", result[0]);
        assertEquals("value2", result[1]);
    }

    @Test
    public void test_getParamValueArray_withNullParam() {

    public void test_enumValues() {
        final StorageType[] types = StorageType.values();
        assertNotNull(types);
        assertEquals(3, types.length);
    }

    public void test_s3Type() {
        assertEquals(StorageType.S3, StorageType.valueOf("S3"));
    }

    public void test_gcsType() {
        assertEquals(StorageType.GCS, StorageType.valueOf("GCS"));
    }

    public void test_s3CompatType() {

        source.put("TestKey", "value1");
        source.put("AnotherTestKey", "value2");

        Map<String, Object> nested = new HashMap<>();
        nested.put("NestedKey", "nestedValue");
        source.put("NestedMap", nested);

        Map<String, Object> result = searchLogHelper.toLowerHyphen(source);

        assertEquals("value1", result.get("test_key"));

    @Test
    public void test_values() {
        ChatIntent[] values = ChatIntent.values();
        assertEquals(4, values.length);

        assertEquals(ChatIntent.SEARCH, values[0]);
        assertEquals(ChatIntent.SUMMARY, values[1]);
        assertEquals(ChatIntent.FAQ, values[2]);
        assertEquals(ChatIntent.UNCLEAR, values[3]);
    }

    @Test
    public void test_getValue() {