* The query is processed through the filter chain before being parsed.
     *
     * @param query the query string to parse
     * @return the parsed Query object
     * @throws QueryParseException if the query cannot be parsed
     */
    public Query parse(final String query) {
        return filterChain.parse(query);
    }

    /**
     * Creates a new Lucene query parser with the current configuration.

        try {
            // parse(String)
            Method parseMethod = KuromojiCSVUtil.class.getMethod("parse", String.class);
            assertTrue("parse should be static", java.lang.reflect.Modifier.isStatic(parseMethod.getModifiers()));
            assertTrue("parse should be public", java.lang.reflect.Modifier.isPublic(parseMethod.getModifiers()));

        parameters = "";
        parameterMap = ParameterUtil.parse(parameters);
        assertEquals(0, parameterMap.size());

        parameters = "domain";
        parameterMap = ParameterUtil.parse(parameters);
        assertEquals(1, parameterMap.size());
        assertEquals("", parameterMap.get("domain"));

        parameters = "domain=";
        parameterMap = ParameterUtil.parse(parameters);
        assertEquals(1, parameterMap.size());

        PrunedTag[] tags = PrunedTag.parse("");
        assertEquals(0, tags.length);

        // Test null
        tags = PrunedTag.parse(null);
        assertEquals(0, tags.length);

        // Test whitespace only
        tags = PrunedTag.parse("   ");
        assertEquals(0, tags.length);

        // Test commas only
        tags = PrunedTag.parse(",,,");
        assertEquals(0, tags.length);

        this.linkConverter = linkConverter;
    }

    public DocComment parse(ClassMetaData classMetaData, GenerationListener listener) {
        listener.start(String.format("class %s", classMetaData));
        try {
            String rawCommentText = classMetaData.getRawCommentText();
            try {
                return parse(rawCommentText, classMetaData, new NoOpCommentSource(), listener);
            } catch (Exception e) {

        String invalidXml = "<?xml version=\"1.0\"?><invalid><test/></invalid>";

        try {
            parser.parse(new InputSource(new StringReader(invalidXml)));
            fail("Should throw GsaConfigException");
        } catch (GsaConfigException e) {
            assertEquals("Failed to parse XML file.", e.getMessage());
        }
    }

    @Test
    public void test_parseWithMalformedXml() {

        if (handlerParameterMap == null) {
            handlerParameterMap = ParameterUtil.parse(getHandlerParameter());
        }
        return handlerParameterMap;
    }

    public Map<String, String> getHandlerScriptMap() {
        if (handlerScriptMap == null) {
            handlerScriptMap = ParameterUtil.parse(getHandlerScript());
        }
        return handlerScriptMap;
    }

    @Override

import org.codelibs.fess.util.ComponentUtil;
import org.dbflute.optional.OptionalEntity;

/**
 * Character mapping file handler for managing character mapping dictionaries.
 * This class provides functionality to load, parse, and manage character mapping
 * rules that define how input characters should be transformed to output characters
 * during text analysis and search processing.
 *
 * Character mapping files contain mapping rules in the format:

                }
                if (values.length > 1) {
                    cb.query().setUpdatedAt_LessEqual(LocalDateTime.parse(values[1], formatter));
                }
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to parse {}", pager.requestedTimeRange, e);
                }

errors.password_no_digit = Hasło musi zawierać co najmniej jedną cyfrę.
errors.password_no_special_char = Hasło musi zawierać co najmniej jeden znak specjalny.
errors.password_is_blacklisted = To hasło jest niedozwolone. Proszę wybrać inne hasło.
errors.invalid_confirm_password = Potwierdzenie hasła nie pasuje.
errors.cannot_delete_doc_because_of_running = Crawler jest uruchomiony. Nie można usunąć dokumentu.