assertEquals(true, docMap.get("key3"));

        assertTrue(docMap.containsKey("key1"));
        assertTrue(docMap.containsValue("value1"));
        assertFalse(docMap.containsKey("nonexistent"));
        assertFalse(docMap.containsValue("nonexistent"));
    }

    @Test
    public void test_put_and_get() {
        Map<String, Object> parentMap = new HashMap<>();
        DocMap docMap = new DocMap(parentMap);

            // Expected
        }
    }

    @Test
    public void test_getBoostedDocumentList_noBoostList() {
        KeyMatch keyMatch = new KeyMatch();
        keyMatch.setId("nonexistent");
        keyMatch.setTerm("nonexistent");
        keyMatch.setVirtualHost("");

        try {
            List<Map<String, Object>> result = keyMatchHelper.getBoostedDocumentList(keyMatch);
            assertNotNull(result);

        // Try to execute with non-existent script type
        try {
            scriptExecutor.execute("nonexistent", "some script");
            fail("Expected ScriptEngineException");
        } catch (ScriptEngineException e) {
            assertTrue(e.getMessage().contains("nonexistent"));
        }
    }

    @Test
    public void test_execute_withNullScriptType() {

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

        assertEquals("default", DocumentUtil.getValue(doc, "nonexistent", String.class, "default"));
        assertEquals(Integer.valueOf(42), DocumentUtil.getValue(doc, "nonexistent", Integer.class, 42));
        assertEquals(Long.valueOf(123L), DocumentUtil.getValue(doc, "nonexistent", Long.class, 123L));

        doc.put("key", "value");

    public void test_sendCommand_jobNotFound() {
        try {
            processHelper.sendCommand("nonexistent", "test command");
            fail("Expected JobNotFoundException");
        } catch (JobNotFoundException e) {
            assertTrue(e.getMessage().contains("Job for nonexistent is not found"));
        }
    }

    @Test
    public void test_startProcess_basicCommand() {
        String sessionId = "test_session";

            assertTrue("Field " + field + " should be found", queryFieldConfig.isSortField(field));
        }

        // Test negative cases
        assertFalse(queryFieldConfig.isSortField("nonexistent"));
        assertFalse(queryFieldConfig.isSortField("title"));
        assertFalse(queryFieldConfig.isSortField(""));
        assertFalse(queryFieldConfig.isSortField(null));
    }

    /**

    @Test
    public void test_getScriptEngine_nonExistentName() {
        try {
            scriptEngineFactory.getScriptEngine("nonexistent");
            fail("Should throw ScriptEngineException for non-existent engine");
        } catch (ScriptEngineException e) {
            assertEquals("nonexistent is not found.", e.getMessage());
        }
    }

    // Test getScriptEngine with empty string
    @Test

    public void test_init_nonExistentDirectory() {
        ThumbnailManager manager = new ThumbnailManager() {
            @Override
            public void init() {
                baseDir = new File(tempDir, "nonexistent/dir");
                if (baseDir.mkdirs()) {
                    logger.info("Created: {}", baseDir.getAbsolutePath());
                }
                if (!baseDir.isDirectory()) {

        assertNull(dataStoreParams.get("key3"));
    }

    // Test get for non-existent key
    @Test
    public void test_getNonExistentKey() {
        assertNull(dataStoreParams.get("nonexistent"));
    }

    // Test getAsString with String value
    @Test
    public void test_getAsStringWithStringValue() {
        dataStoreParams.put("stringKey", "stringValue");

        thread.start();
        thread.join(1000);

        assertTrue(thread.contains("exact line"));
        assertTrue(thread.contains("another line"));
        assertFalse(thread.contains("nonexistent"));
    }

    @Test
    public void test_contains_withTrimming() throws InterruptedException {
        String input = "  trimmed line  \n\tanother\t";