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

    <url-pattern>/*</url-pattern>
    <dispatcher>REQUEST</dispatcher>
  </filter-mapping>

  <filter-mapping>
    <filter-name>webApiFilter</filter-name>
    <url-pattern>/*</url-pattern>
    <dispatcher>REQUEST</dispatcher>
  </filter-mapping>

  <filter-mapping>
    <filter-name>lastaShowbaseFilter</filter-name>
    <url-pattern>/*</url-pattern>
    <dispatcher>REQUEST</dispatcher>

        // Pattern with single backslash (14 chars): should match
        String singleBackslash = "image/svg" + "\\" + "+xml";
        assertEquals("Single backslash pattern should be 14 chars", 14, singleBackslash.length());
        assertTrue(svgMimetype.matches(singleBackslash));

        // Pattern with double backslash (15 chars): should NOT match
        String doubleBackslash = "image/svg" + "\\\\" + "+xml";

        le: float | None = None,
        min_length: int | None = None,
        max_length: int | None = None,
        pattern: str | None = None,
        regex: Annotated[
            str | None,
            deprecated(
                "Deprecated in FastAPI 0.100.0 and Pydantic v2, use `pattern` instead."
            ),
        ] = None,
        discriminator: str | None = None,
        strict: bool | None = _Unset,

        Pattern pattern = Pattern.compile(FS_FILE_RULE_PATTERN);
        assertTrue(pattern.matcher("text/html").matches());
    }

    @Test
    public void test_fsFileRulePattern_lhaTypes() {
        Pattern pattern = Pattern.compile(FS_FILE_RULE_PATTERN);
        assertTrue(pattern.matcher("application/lha").matches());
        assertTrue(pattern.matcher("application/x-lha").matches());

    init {
      require(
        (pattern.startsWith("*.") && pattern.indexOf("*", 1) == -1) ||
          (pattern.startsWith("**.") && pattern.indexOf("*", 2) == -1) ||
          pattern.indexOf("*") == -1,
      ) {
        "Unexpected pattern: $pattern"
      }

      this.pattern =
        pattern.toCanonicalHost() ?: throw IllegalArgumentException("Invalid pattern: $pattern")

      when {

            """
        ),
    ] = None,
    pattern: Annotated[
        str | None,
        Doc(
            """
            RegEx pattern for strings.
            """
        ),
    ] = None,
    regex: Annotated[
        str | None,
        Doc(
            """
            RegEx pattern for strings.
            """
        ),
        deprecated(

        LabelTypePattern pattern = new LabelTypePattern("test", "/test.*", "/exclude.*");

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

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

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

    @Test

            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;
            }
        }

                .getTotalHits()
                .value() > 0);

        // Verify pattern can be retrieved
        final List<Pattern> patterns = urlFilterService.getIncludeUrlPatternList(sessionId);
        assertEquals(1, patterns.size());
        assertTrue(patterns.get(0).matcher("http://example.com/page1").matches());
        assertFalse(patterns.get(0).matcher("http://other.com/page1").matches());