TestFessTransformer transformer = new TestFessTransformer();
        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

        Map<String, Object> parentMap = new HashMap<>();
        DocMap docMap = new DocMap(parentMap);

        assertNull(docMap.put("newKey", "newValue"));
        assertEquals("newValue", docMap.get("newKey"));

        assertEquals("newValue", docMap.put("newKey", "updatedValue"));
        assertEquals("updatedValue", docMap.get("newKey"));

        assertNull(docMap.get("nonexistent"));
    }

    @Test

        assertFalse(valve.isShowServerInfo());
    }

    @Test
    public void test_defaultSettings() {
        final SuppressErrorReportValve newValve = new SuppressErrorReportValve();
        assertFalse(newValve.isShowReport());
        assertFalse(newValve.isShowServerInfo());
    }

    @Test
    public void test_setShowReport() {
        valve.setShowReport(true);
        assertTrue(valve.isShowReport());

            String value1 = fessConfig.get(testKey);
            assertEquals(initialValue, value1);

            // Change system property
            String newValue = "changed";
            System.setProperty(Constants.FESS_CONFIG_PREFIX + testKey, newValue);

            // Get value again - in real FessConfigImpl it would be cached,
            // but our test implementation always checks system properties

            @Override
            public Object evaluate(String template, Map<String, Object> paramMap) {
                // Try to add new param
                paramMap.put("newKey", "newValue");
                return paramMap.size();
            }
        });

        // Execute first time
        Object result1 = scriptExecutor.execute("modifyEngine", "script1");

        // Test overwriting existing keys
        paramMap = new HashMap<>();
        paramMap.put("key1", "oldValue");
        configParam = "key1=newValue";
        ParameterUtil.loadConfigParams(paramMap, configParam);
        assertEquals(1, paramMap.size());
        assertEquals("newValue", paramMap.get("key1"));
    }

    @Test
    public void test_createConfigParameterMap() {
        String configParameters;

    public void test_overwriteValues() {
        dataStoreParams.put("key1", "originalValue");
        assertEquals("originalValue", dataStoreParams.get("key1"));

        dataStoreParams.put("key1", "newValue");
        assertEquals("newValue", dataStoreParams.get("key1"));

        dataStoreParams.put("key1", null);
        assertNull(dataStoreParams.get("key1"));
    }

    // Test multiple operations in sequence
    @Test

        ProtwordsItem item = new ProtwordsItem(1, "oldValue");
        item.setNewInput("newValue");

        ProtwordsFile.ProtwordsUpdater updater = protwordsFile.new ProtwordsUpdater(item);

        // Write the same item (should update)
        ProtwordsItem result = updater.write(item);

        assertNotNull(result);
        assertEquals("newValue", result.getInput());
        assertEquals(1, result.getId());

        assertEquals("value3", crawlingInfoHelper.infoMap.get("key3"));

        // Test overwriting existing key
        crawlingInfoHelper.putToInfoMap("key1", "new_value1");
        assertEquals("new_value1", crawlingInfoHelper.infoMap.get("key1"));
    }

    @Test
    public void test_store_create() {
        final String sessionId = "test-session-123";

        // Mock CrawlingInfoService