assertEquals("String should match", "test", deserialized.get("string"));
        assertEquals("Integer should match", 42, deserialized.get("integer"));
        assertEquals("Long should match", 123456789L, deserialized.get("long"));
        assertEquals("Double should match", 3.14, deserialized.get("double"));
        assertEquals("Boolean should match", true, deserialized.get("boolean"));

        final List<Artifact> list = new ArrayList<>();
        final String repoContent = getRepositoryContent(url);
        final Matcher matcher = Pattern.compile("href=\"[^\"]*(" + artifactType.getId() + "[a-zA-Z0-9\\-]+)/?\"").matcher(repoContent);
        while (matcher.find()) {
            final String name = matcher.group(1);
            if (isExcludedName(artifactType, name)) {
                continue;
            }

        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]);

            throw new IllegalStateException("Malformed distributionUrl line: " + distributionUrl);
        }
        String url = distributionUrl.substring(idx + 1).trim();

        Matcher m = WRAPPER_VERSION_EXTRACT.matcher(url);
        if (!m.matches()) {
            throw new IllegalStateException("Could not extract wrapper version from distributionUrl: " + url);
        }
        return m.group(1);
    }

        }

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

                    }
                    continue;
                }

                String[] inputs;
                String output;

                final Matcher m = parsePattern.matcher(replacedLine);

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