}

    /**
     * Converts a GSA URL pattern into a regular expression pattern suitable for Fess.
     * Handles various GSA pattern formats including regexp, contains, and URL-based patterns.
     *
     * @param s the input GSA pattern string
     * @return a regular expression pattern string, or empty string for comments/invalid patterns
     */
    protected String getFilterPath(final String s) {

        final Set<String> valueSet = new HashSet<>();
        for (final LabelTypePattern pattern : labelTypePatternList) {
            if (pattern.match(path)) {
                valueSet.add(pattern.getValue());
            }
        }
        return valueSet;
    }

    /**
     * Builds a list of label type patterns.
     *
     * @param labelTypeList The list of label types.
     */

    /**
     * Cache for client rules mapping client names to their corresponding URL patterns.
     * This cache improves performance by avoiding repeated parsing of client configuration rules.
     * The key is the rule string, and the value is a pair containing the client name and compiled pattern.
     */
    protected ConcurrentHashMap<String, Pair<String, Pattern>> clientRuleCache = new ConcurrentHashMap<>();

    /**

        System.setProperty("java.version", "11.0.1");

        // Test version patterns with different separators
        String[] args = new String[] { "11:-Dprop=value:with:colons", "8-:-Xbootclasspath/a:/path/to/jar", "malformed11:-invalid", // Should not match pattern
                "11-malformed:-invalid" // Should not match pattern
        };

        String[] result = JvmUtil.filterJvmOptions(args);

   - Convert URL patterns to Fess regex patterns
   - Set up LabelType (access control labels) if defined

**Step 3: Verify Imported Configurations**

After import, verify:
- **Crawler > Web**: Check web crawling configurations
- **Crawler > File**: Check file crawling configurations (SMB, FTP)
- **System > General**: Verify URL patterns and filters

**GSA Configuration Mapping**

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

        // Should not match excluded path
        assertFalse(pattern.match("/exclude/path"));
    }

    @Test
    public void test_labelTypePattern_match_noPatterns() {
        LabelTypePattern pattern = new LabelTypePattern("test", null, null);

        // Should match everything when no patterns
        assertTrue(pattern.match("/any/path"));

                final Pattern pattern = Pattern.compile(value);
                paramMap.put(URL_EXCLUDE_PATTERN, pattern);
                if (logger.isDebugEnabled()) {
                    logger.debug("Using exclude pattern: {}", pattern);
                }
            }
            if (paramMap.get(URL_EXCLUDE_PATTERN) instanceof final Pattern pattern) {
                if (pattern.matcher(url).matches()) {

    /** Pattern for detecting reserved characters in Lucene range field queries. */
    public static final Pattern LUCENE_RANGE_FIELD_RESERVED_PATTERN = Pattern.compile("([!\\(\\){}\\[\\]\"~\\\\:\\p{Zs}]|(&&)|(\\|\\|))");

    // ============================================================
    // Query and Search Constants

 * @param historyDays days number of days to store build history .
 * @param artifactsDays number of days to store artifacts. In the stored history, artifacts older than this number will be cleaned up.
 * @param artifactsPatterns patterns for artifacts clean-up. If not specified, all artifacts will be removed.
 */
fun Project.cleanupRule(
    historyDays: Int,
    artifactsDays: Int,
    artifactsPatterns: String? = null,
) {
    features {

            return Constants.TRUE;
        }

        for (final Pattern pattern : includedDocUrlPatterns) {
            if (pattern.matcher(input).matches()) {
                return Constants.TRUE;
            }
        }

        for (final Pattern pattern : excludedDocUrlPatterns) {
            if (pattern.matcher(input).matches()) {
                return Constants.FALSE;
            }
        }