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

        extension.getClasspath().from(runtimeClasspath);
        extension.getSourceRoots().from(sourcesPath.getIncoming().artifactView(v -> v.lenient(true)).getFiles());
        extension.getDocumentedSource().from(sourcesPath.getIncoming().artifactView(v -> v.lenient(true)).getFiles().getAsFileTree().matching(f -> {
            f.include(PublicApi.INSTANCE.getIncludes());
            // Filter out any non-public APIs

        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    @Override
    public String[] getRoleNames() {
        return stream(getRoles()).get(stream -> stream.map(this::decode).toArray(n -> new String[n]));
    }

    @Override
    public String[] getGroupNames() {

     *
     * @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) {

    //                                                                            ========
    public String[] getPermissions() {
        return user.getPermissions();
    }

    public String[] getRoles() {
        return user.getRoleNames();
    }

    public String[] getGroups() {
        return user.getGroupNames();
    }

    public boolean isEditable() {
        return user.isEditable();
    }