// Should not match non-included path
        assertFalse(pattern.match("/other/path"));
    }

    public void test_labelTypePattern_match_onlyIncluded() {
        LabelTypePattern pattern = new LabelTypePattern("test", "/test.*", null);

        // Should match included path
        assertTrue(pattern.match("/test/path"));

        // Should not match non-included path

// flags:
//   filter:
//     newerThan: "7d" # match objects newer than this value (e.g. 7d10h31s)
//     olderThan: "7d" # match objects older than this value (e.g. 7d10h31s)
//     createdAfter: "date" # match objects created after "date"
//     createdBefore: "date" # match objects created before "date"
//     tags:
//       - key: "name"
//         value: "pick*" # match objects with tag 'name', with all values starting with 'pick'

        responseData.setUrl("http://example.com");

        assertTrue(rule.match(responseData));
        assertTrue(rule.match(responseData));
        assertTrue(rule.match(responseData));
        assertEquals(3, rule.getMatchCallCount());
    }

    /**
     * Test Rule with always false match
     */
    public void test_ruleNeverMatch() {

        final CustomSize annotation = field.getAnnotation(CustomSize.class);

        assertNotNull("Annotation should be present on field", annotation);
        assertEquals("minKey should match", "test.min", annotation.minKey());
        assertEquals("maxKey should match", "test.max", annotation.maxKey());
        assertEquals("message should be default", "{jakarta.validation.constraints.Size.message}", annotation.message());
    }

        // Without any patterns, all URLs should match
        assertTrue(urlFilter.match("https://example.com/"));
        assertTrue(urlFilter.match("https://test.com/page"));
        assertTrue(urlFilter.match("ftp://files.com/document.pdf"));
        assertTrue(urlFilter.match("file:///home/user/file.txt"));
    }

    /**
     * Test match with complex URL patterns
     */

                        .status(ApiResult.Status.OK)
                        .result());
    }

    /**
     * Retrieves a specific key match setting by ID.
     *
     * @param id the ID of the key match setting to retrieve
     * @return JSON response containing the key match setting
     */
    // GET /api/admin/keymatch/setting/{id}
    @Execute
    public JsonResponse<ApiResult> get$setting(final String id) {

    //                                                                           =========
    /** Helper for key match operations. */
    @Resource
    private KeyMatchHelper keyMatchHelper;

    /** Service for key match operations. */
    @Resource
    private KeyMatchService keyMatchService;

    /** Pager for key match list pagination. */
    @Resource
    private KeyMatchPager keyMatchPager;

        List<RelatedContent> testData = new ArrayList<>();
        testData.add(createRelatedContent("exact", "Exact Match", ""));
        testData.add(createRelatedContent("regex:test.*", "Regex Match: __QUERY__", ""));
        mockBhv.setTestData(testData);

        relatedContentHelper.load();

        // Test exact match
        String[] results = relatedContentHelper.getRelatedContents("exact");
        assertEquals(1, results.length);

     * Returns whether all regular expressions must match for this rule to match.
     * @return true if all patterns must match, false if only one needs to match
     */
    public boolean isAllRequired() {
        return allRequired;
    }

    /**
     * Sets whether all regular expressions must match for this rule to match.
     * @param allRequired true if all patterns must match, false if only one needs to match
     */

        if (!includeList.isEmpty()) {
            boolean match = false;
            for (final Pattern pattern : includeList) {
                final Matcher matcher = pattern.matcher(url);
                if (matcher.matches()) {
                    match = true;
                }
            }
            if (!match) {
                return false;
            }
        }