@Override
    public boolean isErrorEnabled() {
        return logger.isErrorEnabled();
    }

    @Override
    public void error(final String message) {
        logger.error(message);
    }

    @Override
    public void error(final String message, final Throwable t) {
        logger.error(message, t);
    }

    @Override
    public boolean isWarnEnabled() {
        return logger.isWarnEnabled();
    }

    public void testWarn() throws Exception {
        logger.warn("warn");
    }

    /**
     * @throws Exception
     */
    @Test
    public void testError() throws Exception {
        logger.error("error");
    }

    /**
     * @throws Exception
     */
    @Test
    public void testFatal() throws Exception {
        logger.fatal("fatal");
    }

    /**
     * @throws Exception
     */

        }
    }

    /**
     * Simply parse the given xml string.
     *
     * @param xml the input xml string
     * @return the parsed object
     * @throws XmlReaderException if an error occurs during the parsing
     * @see #toXmlString(Object)
     */
    public static Model fromXml(@Nonnull String xml) throws XmlReaderException {
        return new DefaultModelXmlFactory().fromXmlString(xml);
    }

            throw new ToolchainsBuilderException("Error building toolchains", problems);
        }

        return new DefaultToolchainsBuilderResult(effective, problems);
    }

    private boolean hasErrors(List<BuilderProblem> problems) {
        if (problems != null) {
            for (BuilderProblem problem : problems) {
                if (BuilderProblem.Severity.ERROR.compareTo(problem.getSeverity()) >= 0) {

        stemmerOverrideFile.stemmerOverrideItemList = itemList;
    }

    public void test_selectList() {
        final PagingList<StemmerOverrideItem> itemList1 = stemmerOverrideFile.selectList(0, 20); // error occurs
        assertEquals(3, itemList1.size());
        assertEquals(3, itemList1.getAllRecordCount());
        assertEquals(1, itemList1.getCurrentPageNumber());
        assertEquals(20, itemList1.getPageSize());

    }

    public static void printThreadDumpAsWarn() {
        processThreadDump(logger::warn);
    }

    public static void printThreadDumpAsError() {
        processThreadDump(logger::error);
    }

    public static void writeThreadDump(final String file) {
        try (final Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), Constants.CHARSET_UTF_8))) {

 * artifactId, and version for the plugin; at times, the goal name for which
 * execution failed; a message detailing the problem; the ClassRealm used to
 * look up the plugin; and the Plexus exception that caused this error.
 *
 *
 */
public class PluginContainerException extends PluginManagerException {

    private ClassRealm pluginRealm;

    public PluginContainerException(

            reverseName = true;
            name = name.substring(1);
        }

        if (name == null || name.isEmpty()) {
            problems.add(
                    BuilderProblem.Severity.ERROR,
                    ModelProblem.Version.BASE,
                    "The property name is required to activate the profile " + profile.getId(),
                    property.getLocation(""));
            return false;
        }

                }
                return null;
            });
            resultBuf.append(count).append(" docs").append("\n");
        } catch (final Exception e) {
            logger.error("Could not update labels.", e);
            resultBuf.append(e.getMessage()).append("\n");
        }

        return resultBuf.toString();
    }

    public UpdateLabelJob query(final QueryBuilder queryBuilder) {

         * the way 2.x works. When we're in strict mode, the removal of duplicates just saves other merging steps from
         * aftereffects and bogus error messages.
         */
        List<Dependency> dependencies = model.getDependencies();
        Map<String, Dependency> normalized = new LinkedHashMap<>(dependencies.size() * 2);