final Set<ElementType> actualTargets = new HashSet<>(Arrays.asList(target.value()));

        assertEquals("Target elements should match", expectedTargets, actualTargets);
    }

    // Test annotation is documented
    @Test
    public void test_documented() {
        final Documented documented = UriType.class.getAnnotation(Documented.class);

                "11-malformed:-invalid" // Should not match pattern
        };

        String[] result = JvmUtil.filterJvmOptions(args);
        assertEquals(4, result.length); // All should pass through since invalid patterns don't match
        assertEquals("-Dprop=value:with:colons", result[0]);

        }

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

        return Constants.TRUE;
    }

            final java.util.regex.Matcher m = p.matcher(stripCodeFences(json));
            if (m.find()) {
                final String arrayContent = m.group(1);
                return Arrays.stream(arrayContent.split(","))
                        .map(String::trim)
                        .filter(s -> s.matches("\\d+"))
                        .map(Integer::parseInt)

        }
        final Matcher matcher = regexPattern.matcher(input);
        if (matcher.find()) {
            if (pathMapperFunc == null) {
                final String replacement = StringUtil.isNotBlank(getReplacement()) ? getReplacement() : StringUtil.EMPTY;
                pathMapperFunc = pathMappingHelper.createPathMatcher(matcher, replacement);
            }
            try {

                exitCode.set(1);
                latch.countDown();
            });

            try {
                latch.await();
            } catch (final InterruptedException ignore) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Interrupted.", ignore);
                }
                exitCode.set(1);
            }
        }

        }

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

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

        return Constants.TRUE;

    }

                    if (updater != null) {
                        updater.write(line);
                    }
                    continue;
                }

                final Matcher m = parsePattern.matcher(replacedLine);

                if (!m.find()) {
                    logger.warn("Failed to parse stemmer override: line={}, path={}", line, path);
                    if (updater != null) {

 * from files that match the pattern "stopwords.*\\.txt".
 */
public class StopwordsCreator extends DictionaryCreator {
    private static final Logger logger = LogManager.getLogger(StopwordsCreator.class);

    /**
     * Constructs a new creator for stopwords dictionaries.
     * It sets the file pattern to match files starting with "stopwords"
     * and ending with ".txt".
     */

        return Arrays.stream(values).map(s -> {
            final Matcher matcher = VERSION_PREFIX_PATTERN.matcher(s);
            if (!matcher.matches()) {
                return s;
            }
            final int v = Integer.parseInt(matcher.group(1));
            if ("-".equals(matcher.group(2))) {
                if (version >= v) {
                    return matcher.group(3);
                }
            } else if (v == version) {