// Verify escaped pattern matches
            assertTrue("Escaped pattern should match: " + mimeType, Pattern.compile(escapedPattern).matcher(mimeType).matches());

            // Verify unescaped pattern does NOT match
            assertFalse("Unescaped pattern should NOT match: " + mimeType, Pattern.compile(mimeType).matcher(mimeType).matches());
        }
    }

    @Test

    }

    /**
     * Gets the current match expression.
     *
     * @return the match expression string
     */
    public String getMatchExpression() {
        return matchExpression;
    }

    /**
     * Sets the match expression used to determine if documents should be boosted.
     *
     * @param expression the match expression string
     */

             String invalidLink = matcher.group();
             errorsForFile.add(new Error(lineNumber, line, "Markdown-style links are not supported: " + invalidLink));
        }
    }

    private void gatherDeadLinksInLine(File sourceFile, String line, int lineNumber, List<Error> errorsForFile) {
        Matcher matcher = linkPattern.matcher(line);
        while (matcher.find()) {

        assertTrue("text/html".matches("text/html"));
        assertTrue("application/pdf".matches("application/pdf"));
        assertTrue("image/jpeg".matches("image/jpeg"));
        assertTrue("image/png".matches("image/png"));
        assertTrue("image/gif".matches("image/gif"));
        assertTrue("image/tiff".matches("image/tiff"));
    }

    @Test
    public void test_addConditionWithSvgMimetype() {

        map.put("data1", 20);
        assertTrue(docBoostMatcher.match(map));

        map.put("data1", 5);
        assertFalse(docBoostMatcher.match(map));

        map.remove("data1");
        assertFalse(docBoostMatcher.match(map));

        map.put("data2", 5);
        assertFalse(docBoostMatcher.match(map));
    }

    @Test
    public void test_string() {

                // Check field name follows convention
                assertTrue("Field name should match pattern: " + field.getName(), labelPattern.matcher(field.getName()).matches());

                // Check field value follows convention
                field.setAccessible(true);
                String value = (String) field.get(null);

        final String servletPath = request.getServletPath();
        final boolean matches = servletPath.startsWith(CHAT_API_PATH);
        if (logger.isTraceEnabled()) {
            logger.trace("ChatApiManager.matches() checking path. servletPath={}, expectedPrefix={}, matches={}", servletPath,
                    CHAT_API_PATH, matches);
        }
        return matches;
    }

    @Override

     * @return The masked value if the key matches a sensitive pattern, otherwise the original value
     */
    public static String maskSensitiveValue(final String key, final String value) {
        if (key == null || value == null) {
            return value;
        }
        if (getSensitivePattern().matcher(key).matches()) {
            return "********";
        }
        return value;
    }

        assertTrue(tagWithIdAndCss.matches(nodeWithBothIdAndClass));

        // Node with correct id but different class should still match (id takes precedence)
        MockNode nodeWithCorrectIdWrongClass = new MockNode("div");
        nodeWithCorrectIdWrongClass.addAttribute("id", "main");
        nodeWithCorrectIdWrongClass.addAttribute("class", "other");
        assertTrue(tagWithIdAndCss.matches(nodeWithCorrectIdWrongClass));

        }
        for (final WebApiManager webApiManager : webApiManagers) {
            if (webApiManager.matches(request)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("WebApiManager matched. servletPath={}, manager={}", servletPath,
                            webApiManager.getClass().getSimpleName());
                }
                return webApiManager;