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);

        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

        String expected = "[testParam, [value1, value2]]";
        assertEquals(expected, param.toString());
    }

    @Test
    public void test_toString_withNullName() {
        // Test toString with null name
        String[] values = { "value1" };
        RequestParameter param = new RequestParameter(null, values);

        String expected = "[null, [value1]]";

        // 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() {

    private static final String RESULT3 = COMMENT + LINE_SEPARATOR + COMMENT + LINE_SEPARATOR + KEY1A + " = " + VALUE1
            + "\\" + LINE_SEPARATOR + VALUE1 + LINE_SEPARATOR;

    @Test
    public void testSaveComment3() throws Exception {
        properties.put(KEY1, List.of(new String[] {COMMENT, COMMENT}), List.of(new String[] {VALUE1, VALUE1}));
        StringWriter sw = new StringWriter();
        properties.save(sw);

        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);

        SuggestSettingsBuilder builder2 = new SuggestSettingsBuilder();

        builder1.addInitialSettings("key", "value1");
        builder2.addInitialSettings("key", "value2");

        assertEquals("value1", builder1.initialSettings.get("key"));
        assertEquals("value2", builder2.initialSettings.get("key"));
    }

    @Test
    public void testBuildMultipleInstances() {

        System.setProperty("custom.prop.one", "value1");
        System.setProperty("custom.prop.two", "value2");
        System.setProperty("other.property", "value3");

        // Test with regex pattern
        execJob.testAddFessCustomSystemProperties(cmdList, "custom\\.prop\\..*");

        assertEquals(2, cmdList.size());
        assertTrue(cmdList.contains("-Dcustom.prop.one=value1"));

	switch value := input.(type) {
	case string:
		return json.Unmarshal([]byte(value), l)
	case []byte:
		return json.Unmarshal(value, l)
	default:
		return errors.New("not supported")
	}
}

type Role struct {
	Name string `gorm:"size:256"`
}

func (role *Role) Scan(value interface{}) error {
	if b, ok := value.([]uint8); ok {
		role.Name = string(b)
	} else {
		role.Name = value.(string)
	}

        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);