return requestBody;
    }

    @Override
    protected Map<String, Object> getUpdateMap() {
        final Map<String, Object> updateMap = new HashMap<>();
        updateMap.put("value", "new_value");
        return updateMap;
    }

    @Test
    void crudTest() {
        testCreate();
        testRead();
        testUpdate();
        testDelete();
    }

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

        return parent.remove(toCamelCase(key), value);
    }

    @Override
    public boolean replace(final K key, final V oldValue, final V newValue) {
        if (parent.replace(key, oldValue, newValue)) {
            return true;
        }
        return parent.replace(key, oldValue, newValue);
    }

    @Override
    public V replace(final K key, final V value) {
        // use original key

        if (!escape) {
            return value;
        }

        String newValue = value;
        for (final String element : Constants.RESERVED) {
            final String replacement = element.replaceAll("(.)", "\\\\$1");
            newValue = newValue.replace(element, replacement);
        }
        return newValue;
    }

    /**
     * Builds the complete query string from the configured parameters.

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

                var newValue = this.startDate.format(this.locale.format);
                if (!this.singleDatePicker) {
                    newValue += this.locale.separator + this.endDate.format(this.locale.format);
                }
                if (newValue !== this.element.val()) {
                    this.element.val(newValue).trigger('change');
                }
            }

        return requestBody;
    }

    @Override
    protected Map<String, Object> getUpdateMap() {
        final Map<String, Object> updateMap = new HashMap<>();
        updateMap.put("value", "newValue");
        return updateMap;
    }

    @Test
    void crudTest() {
        testCreate();
        testRead();
        testUpdate();
        testDelete();
    }