return rules.remove(rule);
        }

        @Override
        public boolean hasRule(Rule rule) {
            return rules.contains(rule);
        }

        public List<Rule> getRules() {
            return new ArrayList<>(rules);
        }

        public void clearRules() {
            rules.clear();
        }
    }

    /**
     * Test ResponseProcessor implementation

        Rule matchedRule = ruleManager.getRule(responseData);

        assertNull(matchedRule);
    }

    /**
     * Test getRule with null ResponseData
     */
    public void test_getRule_nullResponseData() {
        TestRule rule = new TestRule("rule1", true);

        ruleManager.addRule(rule);

        Rule matchedRule = ruleManager.getRule(null);

        assertNull(matchedRule);
    }

        responseData.setResponseBody(new byte[0]);
        final Rule rule = ruleManager.getRule(responseData);
        assertNotNull(rule);
        assertEquals("fileRule", rule.getRuleId());
        CloseableUtil.closeQuietly(responseData);
    }

    public void test_checkRule() {
        final Rule rule = ruleManager.getRule(new ResponseData());
        assertNotNull(rule);

        assertEquals(elevateWord3.getTags().get(0), settings.elevateWord().get()[2].getTags().get(0));
        assertEquals(elevateWord3.getRoles().get(0), settings.elevateWord().get()[2].getRoles().get(0));
    }

    @Test
    public void test_delete() {
        ElevateWord elevateWord1 =

        assertEquals(readings, elevateWord.getReadings());
        assertEquals(fields, elevateWord.getFields());
        assertEquals(tags, elevateWord.getTags());
        assertNotNull(elevateWord.getRoles());
        assertTrue(elevateWord.getRoles().isEmpty());
    }

    @Test
    public void testConstructorWithNullTagsAndRoles() {
        // Test constructor with both null tags and roles
        String word = "test word";

                this.getBoost(), this.getTags().toArray(new String[this.getTags().size()]),
                this.getRoles().toArray(new String[this.getRoles().size()]), null, SuggestItem.Kind.USER);
    }

        assertNotNull(item.getFields());
        assertEquals(0, item.getFields().length);
        assertNotNull(item.getTags());
        assertEquals(0, item.getTags().length);
        assertNotNull(item.getRoles());
        assertEquals(1, item.getRoles().length); // Default role is added
        assertNotNull(item.getLanguages());
        assertEquals(0, item.getLanguages().length);
        assertNotNull(item.getKinds());

     *
     * @see org.codelibs.fess.crawler.rule.RuleManager#getRule(org.codelibs.fess.crawler.entity.ResponseData)
     */
    /**
     * Gets the first rule that matches the given response data.
     * @param responseData the response data to match against
     * @return the first matching rule, or null if no rule matches
     */
    @Override
    public Rule getRule(final ResponseData responseData) {

     *
     * @param responseData the response data for which the rule is to be retrieved
     * @return the rule associated with the given response data
     */
    Rule getRule(ResponseData responseData);

    /**
     * Adds a new rule to the rule manager.
     *
     * @param rule the rule to be added
     */
    void addRule(Rule rule);

    /**

        }
        mergedItem.languages = langList.toArray(new String[langList.size()]);

        final List<String> roleList = new ArrayList<>(item1.getRoles().length + item2.getRoles().length);
        Collections.addAll(roleList, item1.getRoles());
        for (final String role : item2.getRoles()) {
            if (!roleList.contains(role)) {
                roleList.add(role);
            }
        }