* @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);
        }
        return null;
    }

    /**
     * Strips comments from a line (everything after '#' character).

            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                String filename = file.getFileName().toString();
                if (mavenArtifactJar.matcher(filename).matches()) {
                    Process p = Runtime.getRuntime().exec(new String[] {
                        Paths.get(System.getProperty("java.home"), "bin/java").toString(),
                        "-jar",

     * Retrieves related content for a given search query.
     * First checks for exact term matches, then evaluates regex patterns.
     * For regex matches, the query placeholder is replaced with the actual query.
     *
     * @param query the search query to find related content for
     * @return array of related content strings, or empty array if no matches found
     */
    public String[] getRelatedContents(final String query) {

        final Matcher matcher = Pattern.compile(tokenPattern).matcher(content);
        if (matcher.find()) {
            if (logger.isDebugEnabled()) {
                logger.debug("Matched: {}", matcher.group());
            }
            if (matcher.groupCount() > 0) {
                return matcher.group(1);
            }
        }
        return null;
    }

   * used in FilenameFilter.)
   */
  @Override
  public boolean accept(File dir, String fileName) {
    return pattern.matcher(fileName).matches();
  }

        scriptType = ComponentUtil.getFessConfig().getCrawlerDefaultScript();
    }

    /**
     * Determines if the given document data matches the configured match expression.
     *
     * @param map the document data as a map of field names to values
     * @return true if the document matches the expression, false otherwise
     */
    public boolean match(final Map<String, Object> map) {

     * excluding the general "*" pattern which matches all bots.
     *
     * @param userAgent the user agent string to match against directives,
     *                 can be null (treated as empty string)
     * @return the most specific matching directive, or null if no directive matches
     */
    public Directive getMatchedDirective(final String userAgent) {

      "CallEnd",
    )
  }

  private fun assertBytesReadWritten(
    listener: RecordingEventListener,
    requestHeaderLength: Matcher<Long?>?,
    requestBodyBytes: Matcher<Long?>?,
    responseHeaderLength: Matcher<Long?>?,
    responseBodyBytes: Matcher<Long?>?,
  ) {
    if (requestHeaderLength != null) {
      val responseHeadersEnd = listener.removeUpToEvent<RequestHeadersEnd>()

            if (artifact.isSnapshot()) {
                Matcher matcher = Artifact.VERSION_FILE_PATTERN.matcher(artifact.getVersion());
                if (matcher.matches()) {
                    Snapshot snapshot = new Snapshot();
                    snapshot.setTimestamp(matcher.group(2));
                    try {
                        snapshot.setBuildNumber(Integer.parseInt(matcher.group(3)));

    Pattern pattern = Pattern.compile("Multiple entries with same key: four=(.*) and four=(.*)");
    assertThat(expected).hasMessageThat().matches(pattern);
    Matcher matcher = pattern.matcher(expected.getMessage());
    assertThat(matcher.matches()).isTrue();
    assertThat(matcher.group(1)).isNotEqualTo(matcher.group(2));
  }

  public void testOf() {
    assertMapEquals(ImmutableMap.of("one", 1), "one", 1);