// Remove the child
        entry.removeChild(childName);
        assertFalse(entry.hasChild(childName));
        assertTrue(entry.hasChanges());

        // Remove non-existent child - should not change state
        entry.removeChild("nonexistent.txt");
        assertTrue(entry.hasChanges()); // Still has changes from previous removal
    }

    @Test
    public void testGetChildren() {
        // Add multiple children

        assertEquals(456, Config.getInt(testProperties, "nonexistent.int", 456));
        assertEquals(789, Config.getInt(testProperties, "test.invalid.int", 789));
    }

    @Test
    @DisplayName("Should get integer property")
    void testGetInt() {
        assertEquals(123, Config.getInt(testProperties, "test.int"));
        assertEquals(-1, Config.getInt(testProperties, "nonexistent.int"));

        assertEquals("pdf", fileTypeHelper.get("application/pdf"));
        assertEquals("text", fileTypeHelper.get("text/plain"));

        // Test non-existent mimetype returns default value
        assertEquals("others", fileTypeHelper.get("non/existent"));
    }

    public void test_get_withNullMimetype() {
        assertEquals("others", fileTypeHelper.get(null));
    }

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

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

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

    public void test_get_nullProperty() {
        // Test getting non-existent property
        try {
            fessConfig.get("non.existent.property");
            fail("Should throw exception for non-existent property");
        } catch (ConfigPropertyNotFoundException e) {
            // Expected exception
            assertTrue(e.getMessage().contains("non.existent.property"));
        }
    }

        // Test operations on empty service
        assertEquals(0, mockService.getRegistrationCount());
        assertFalse(mockService.hasRegistration("non-existent"));
        assertFalse(mockService.unregisterWitness("non-existent"));
        assertFalse(mockService.processHeartbeat("non-existent", 1));

        // Test registration with null/empty values
        String regId1 = mockService.registerWitness(null, "192.168.1.100", 1);

        assertFalse(processHelper.isProcessRunning("nonexistent"));
    }

    public void test_getRunningSessionIdSet_empty() {
        Set<String> sessionIds = processHelper.getRunningSessionIdSet();
        assertNotNull(sessionIds);
        assertTrue(sessionIds.isEmpty());
    }

    public void test_destroyProcess_nonExistent() {
        int result = processHelper.destroyProcess("nonexistent");
        assertEquals(-1, result);
    }

			expectedRespStatus: http.StatusBadRequest,
		},
		// Test case - 8.
		// non-existent bucket is used.
		// writing BucketPolicy should fail.
		// should result in 404 StatusNotFound
		{
			bucketName:         "non-existent-bucket",
			bucketPolicyReader: bytes.NewReader(fmt.Appendf(nil, bucketPolicyTemplate, "non-existent-bucket", "non-existent-bucket")),

            // Expected
        }
    }

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

        // Should not throw exception
        lenientService.updatePreauthHash("non-existent", "test".getBytes());

        // With enforcement enabled, should throw exception
        assertThrows(CIFSException.class, () -> {
            preauthService.updatePreauthHash("non-existent", "test".getBytes());
        });
    }

    @Test
    @DisplayName("Test context invalidation")