public void test_update() {
        loadTestData();

        StopwordsItem item = stopwordsFile.get(1).get();
        item.setNewInput("updated");
        stopwordsFile.update(item);

        // Verify the item was updated
        OptionalEntity<StopwordsItem> result = stopwordsFile.get(1);
        assertTrue(result.isPresent());
        assertEquals("updated", result.get().getInput());
    }

        assertEquals(2, tokens.size());
        assertEquals("test", tokens.get(0).getTerm());
        assertEquals("text", tokens.get(1).getTerm());
        // Check that readings are added
        assertEquals("TEST", ((TestAnalyzeToken) tokens.get(0)).getReading());
        assertEquals("TEXT", ((TestAnalyzeToken) tokens.get(1)).getReading());
    }

    @Test
    public void testAnalyzeAndReadingWithEmptyText() {

        // Get an existing item
        ProtwordsItem item = protwordsFile.get(1).get();
        item.setNewInput("updatedWord");

        // Update the item
        protwordsFile.update(item);

        // Verify the update
        protwordsFile.reload(null);
        ProtwordsItem updatedItem = protwordsFile.get(1).get();
        assertEquals("updatedWord", updatedItem.getInput());
    }

        assertEquals(3, executionOrder.size());
        assertEquals(Integer.valueOf(3), executionOrder.get(0));
        assertEquals(Integer.valueOf(2), executionOrder.get(1));
        assertEquals(Integer.valueOf(1), executionOrder.get(2));
    }

    // Test addScoreBooster with same priorities
    public void test_addScoreBooster_samePriority() {

        assertTrue(queryContext.hasSorts());
        List<SortBuilder<?>> sorts = queryContext.sortBuilders();
        assertEquals(2, sorts.size());
        assertEquals(sort1, sorts.get(0));
        assertEquals(sort2, sorts.get(1));
    }

    // Test addSorts with no sorts
    public void test_addSorts_empty() {
        queryContext = new QueryContext("test", false);
        queryContext.addSorts();

        assertEquals(1, notifications.get(0).getAction());
        assertEquals("file1", notifications.get(0).getFileName());

        assertEquals(2, notifications.get(1).getAction());
        assertEquals("file2", notifications.get(1).getFileName());

        assertEquals(3, notifications.get(2).getAction());
        assertEquals("file3", notifications.get(2).getFileName());
    }

        List<ResolverType> order = config.getResolveOrder();
        assertEquals(3, order.size());
        assertEquals(ResolverType.RESOLVER_LMHOSTS, order.get(0));
        assertEquals(ResolverType.RESOLVER_DNS, order.get(1));
        assertEquals(ResolverType.RESOLVER_BCAST, order.get(2));
    }

    @Test
    @DisplayName("Test initResolverOrder with WINS server")

        List<Rule> rules = ruleManager.getRules();
        assertEquals(3, rules.size());
        assertEquals("rule1", rules.get(0).getRuleId());
        assertEquals("rule2", rules.get(1).getRuleId());
        assertEquals("rule3", rules.get(2).getRuleId());
    }

    /**
     * Test adding rule at index 0
     */
    public void test_addRule_atIndexZero() {

        chain.update(user2);
        chain.update(user3);

        assertEquals(3, chain.updateCalls.size());
        assertEquals(user1, chain.updateCalls.get(0));
        assertEquals(user2, chain.updateCalls.get(1));
        assertEquals(user3, chain.updateCalls.get(2));
    }

    // Test update with exception handling
    public void test_update_withException() {

        assertFalse(newIPv4.isIPv6());
        assertEquals(WitnessNotification.WitnessIPAddress.IPV4, newIPv4.getFlags());

        // Check IPv6 address
        WitnessNotification.WitnessIPAddress newIPv6 = newAddresses.get(1);
        assertEquals(ipv6, newIPv6.getAddress());
        assertFalse(newIPv6.isIPv4());
        assertTrue(newIPv6.isIPv6());
        assertEquals(WitnessNotification.WitnessIPAddress.IPV6, newIPv6.getFlags());
    }