return length;
        }

        /**
         * Checks if the given path matches this pattern.
         * @param path the path to check
         * @return true if the path matches, false otherwise
         */
        public boolean matches(final String path) {
            return regexPattern.matcher(path).find();
        }

        /**
         * Gets the original pattern string.

        }

        /**
         * Matches the given path.
         *
         * @param path The path to match.
         * @return True if the path matches, otherwise false.
         */
        public boolean match(final String path) {
            if (includedPaths == null) {
                if (excludedPaths != null && excludedPaths.matcher(path).matches()) {
                    if (logger.isDebugEnabled()) {

        // Get rule after removal
        matched = ruleManager.getRule(responseData);
        assertNull(matched); // No matching rule now

        // Add rule4 which matches
        ruleManager.addRule(rule4);
        matched = ruleManager.getRule(responseData);
        assertEquals("rule4", matched.getRuleId());
    }

    /**
     * Test rule replacement scenario
     */

      var month = -1
      var year = -1
      val matcher = TIME_PATTERN.matcher(s)

      while (pos < limit) {
        val end = dateCharacterOffset(s, pos + 1, limit, true)
        matcher.region(pos, end)

        when {
          hour == -1 && matcher.usePattern(TIME_PATTERN).matches() -> {
            hour = matcher.group(1).toInt()
            minute = matcher.group(2).toInt()

     * @param pattern the pattern to match against
     * @param line the line to extract the value from
     * @return the extracted value, or null if no match
     */
    protected String getValue(final Pattern pattern, final String line) {
        final Matcher m = pattern.matcher(line);
        if (m.matches() && m.groupCount() > 0) {
            return m.group(1);
        }

        // Should match the more specific directive
        Directive matched = robotsTxt.getMatchedDirective("GoogleBot");
        assertNotNull(matched);
        assertEquals("GoogleBot", matched.getUserAgent());
    }

    public void test_getMatchedDirectiveWithPartialMatch() {
        // Test getMatchedDirective with partial pattern match
        RobotsTxt robotsTxt = new RobotsTxt();

        int lineNum = 0;
        for (final String line : values) {
            final Matcher matcher = pattern.matcher(line);
            if (matcher.matches()) {
                if (lineNum == 0) {
                    lineNum = Integer.parseInt(matcher.group(1));
                    list.clear();
                }
                list.add(matcher.group(2));
            } else {
                list.add(line);
            }

        // Verify patterns work correctly
        assertTrue(includePatterns.get(0).matcher("http://example.com/page").matches());
        assertTrue(excludePatterns.get(0).matcher("http://example.com/admin/users").matches());
        assertFalse(excludePatterns.get(0).matcher("http://example.com/page").matches());

        urlFilterService.delete(sessionId);
    }

            final Pattern pattern = Pattern.compile(regex);
            System.getProperties()
                    .keySet()
                    .stream()
                    .filter(k -> k != null && pattern.matcher(k.toString()).matches())
                    .forEach(k -> addSystemProperty(cmdList, k.toString(), null, null));
        }
    }

    /**
     * Deletes the specified temporary directory.

            throw new IllegalArgumentException("Path exceeds maximum length: " + path.length());
        }
        if (PATH_TRAVERSAL.matcher(path).find()) {
            throw new IllegalArgumentException("Path contains directory traversal sequences: " + path);
        }
        if (INVALID_PATH_CHARS.matcher(path).find()) {
            throw new IllegalArgumentException("Path contains invalid characters: " + path);
        }
    }