final List<Pattern> includeList = getUrlFilterService().getIncludeUrlPatternList(sessionId);
        final List<Pattern> excludeList = getUrlFilterService().getExcludeUrlPatternList(sessionId);

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

        String sessionId = "test-session-024";
        urlFilter.init(sessionId);

        // Test empty pattern
        urlFilter.addInclude("");
        urlFilter.addExclude("");

        // Test single character pattern
        urlFilter.addInclude(".");
        urlFilter.addExclude("*");

        // Test patterns with only special characters
        urlFilter.addInclude("^$");
        urlFilter.addExclude(".*");

      hostname += "."
    }
    if (!pattern.endsWith(".")) {
      pattern += "."
    }
    // Hostname and pattern are now absolute domain names.

    pattern = pattern.asciiToLowercase()
    // Hostname and pattern are now in lower case -- domain names are case-insensitive.

    if ("*" !in pattern) {
      // Not a wildcard pattern -- hostname and pattern must match exactly.
      return hostname == pattern

    /** Map of regex patterns to passwords for static password configuration. */
    protected Map<Pattern, String> passwordMap = new HashMap<>();

    /** Cache for parsed password configurations from extraction parameters. */
    private final Map<String, List<Pair<Pattern, String>>> configPasswordMap = new ConcurrentHashMap<>();

    /**

    }

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

# Based on RFC 9309 specification

# Test wildcard patterns
User-agent: WildcardBot
Disallow: /*.pdf$
Disallow: /admin/*.php
Disallow: /*/private/
Allow: /public/*.html

# Test end-of-path ($) patterns
User-agent: EndPathBot
Disallow: /fish$
Disallow: /temp$
Allow: /fishing

# Test complex patterns
User-agent: ComplexBot
Disallow: /
Allow: /$
Allow: /index.html$
Allow: /public/

     * - Second: List of regex pattern matches (Pattern -> content template)
     */
    protected Map<String, Pair<Map<String, String>, List<Pair<Pattern, String>>>> relatedContentMap = Collections.emptyMap();

    /**
     * Prefix used to identify regex patterns in related content terms.
     * When a term starts with this prefix, it is treated as a regular expression
     * pattern rather than an exact match term.
     */

     * (java.lang.String)
     */
    /**
     * Retrieves a list of URL patterns to be excluded for a given session.
     * @param sessionId The ID of the session.
     * @return A list of compiled regular expression patterns.
     */
    @Override
    public List<Pattern> getExcludeUrlPatternList(final String sessionId) {
        return dataHelper.getExcludeUrlPatternList(sessionId);
    }

        Pattern[] patterns = (Pattern[]) propMap.get(CRAWLER_METADATA_CONTENT_EXCLUDES);
        if (patterns == null) {
            patterns = split(getCrawlerMetadataContentExcludes(), ",")
                    .get(stream -> stream.filter(StringUtil::isNotBlank).map(Pattern::compile).toArray(n -> new Pattern[n]));
            propMap.put(CRAWLER_METADATA_CONTENT_EXCLUDES, patterns);
        }

		t.Run("", func(t *testing.T) {
			argPatterns := make([]ellipses.ArgPattern, len(testCase.args))
			for i, arg := range testCase.args {
				patterns, err := ellipses.FindEllipsesPatterns(arg)
				if err != nil {
					t.Fatalf("Unexpected failure %s", err)
				}
				argPatterns[i] = patterns
			}

			gotIndexes, err := getSetIndexes(testCase.args, testCase.totalSizes, testCase.envOverride, argPatterns)