testRule.crawlerContainer = container;
    }

    /**
     * Test getRuleId and setRuleId
     */
    public void test_ruleId_getterSetter() {
        // Initial state
        assertNull(testRule.getRuleId());

        // Set rule ID
        testRule.setRuleId("testRule1");
        assertEquals("testRule1", testRule.getRuleId());

        // Change rule ID
        testRule.setRuleId("changedRule");

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

    /**
     * Test adding duplicate rules
     */
    public void test_addRule_duplicates() {

        AccessResultImpl<Long> result = new AccessResultImpl<>();
        assertNotNull(result);
        assertNull(result.getId());
        assertNull(result.getSessionId());
        assertNull(result.getRuleId());
        assertNull(result.getUrl());
        assertNull(result.getParentUrl());
        assertEquals(Constants.OK_STATUS, result.getStatus());
        assertNull(result.getHttpStatusCode());

        assertNotNull(rule);
        assertEquals("fileRule", rule.getRuleId());
        CloseableUtil.closeQuietly(responseData);
    }

    public void test_checkRule() {
        final Rule rule = ruleManager.getRule(new ResponseData());
        assertNotNull(rule);
        assertEquals("fileRule", rule.getRuleId());

        final RegexRule rule2 = new RegexRule();
        rule2.setAllRequired(true);

        assertSame(sharedProcessor, rule3.getResponseProcessor());

        // Different rule IDs
        assertEquals("rule1", rule1.getRuleId());
        assertEquals("rule2", rule2.getRuleId());
        assertEquals("rule3", rule3.getRuleId());

        // Different match results
        ResponseData responseData = new ResponseData();
        assertTrue(rule1.match(responseData));

     */
    boolean match(ResponseData responseData);

    /**
     * Retrieves the unique identifier for the rule.
     *
     * @return the rule's unique identifier as a String.
     */
    String getRuleId();

    /**
     * Retrieves the response processor associated with this rule.
     *
     * @return the response processor
     */
    ResponseProcessor getResponseProcessor();

        // Test rule ID getter/setter
        ResponseData data = new ResponseData();

        String ruleId = "rule123";
        data.setRuleId(ruleId);
        assertEquals(ruleId, data.getRuleId());
    }

    public void test_sessionIdGetterSetter() {
        // Test session ID getter/setter
        ResponseData data = new ResponseData();

        String sessionId = "session456";

        this.sessionId = sessionId;
    }

    /*
     * (non-Javadoc)
     *
     * @see org.codelibs.fess.crawler.entity.AccessResult#getRuleId()
     */
    @Override
    public String getRuleId() {
        return ruleId;
    }

    /*
     * (non-Javadoc)
     *
     * @see org.codelibs.fess.crawler.entity.AccessResult#setRuleId(java.lang.String)
     */

        final Rule rule = mock(Rule.class);
        final ResponseProcessor responseProcessor = mock(ResponseProcessor.class);

        when(ruleManager.getRule(responseData)).thenReturn(rule);
        when(rule.getRuleId()).thenReturn("test-rule");
        when(rule.getResponseProcessor()).thenReturn(responseProcessor);

        // Use reflection to access protected method
        final java.lang.reflect.Method method =

    public void register(final int index) {
        final RuleManager ruleManager = crawlerContainer.getComponent("ruleManager");
        ruleManager.addRule(index, this);
    }

    @Override
    public String getRuleId() {
        return ruleId;
    }

    /**
     * Sets the rule ID for this rule.
     *
     * @param ruleId the rule ID to set
     */
    public void setRuleId(final String ruleId) {