LogEvent result1 = policy.rewrite(event1);
        LogEvent result2 = policy.rewrite(event2);

        assertEquals(Level.WARN, result1.getLevel());
        assertEquals(Level.WARN, result2.getLevel());
    }

    @Test
    public void test_createPolicy_with_spaces_in_logger_names() {
        ErrorToWarnRewritePolicy policy = ErrorToWarnRewritePolicy.createPolicy("  test.logger  ,  another.logger  ,  third.logger  ");

        appender.append(event);

        final List<LogNotificationEvent> events = ComponentUtil.getLogNotificationHelper().drainAll();
        assertEquals(1, events.size());
        assertEquals("ERROR", events.get(0).getLevel());
        assertEquals("org.codelibs.fess.test", events.get(0).getLoggerName());
        assertEquals("test error message", events.get(0).getMessage());
        assertNull(events.get(0).getThrowable());
    }

            return timestamp;
        }

        /**
         * Returns the log level name.
         *
         * @return the log level name
         */
        public String getLevel() {
            return level;
        }

        /**
         * Returns the logger name.
         *
         * @return the logger name
         */
        public String getLoggerName() {

        final SystemHelper systemHelper = ComponentUtil.getSystemHelper();
        final Map<String, List<LogNotificationEvent>> eventsByLevel =
                events.stream().collect(Collectors.groupingBy(LogNotificationEvent::getLevel));

        for (final Map.Entry<String, List<LogNotificationEvent>> entry : eventsByLevel.entrySet()) {
            final String level = entry.getKey();

     *            Exception
     */
    public void log(final LogMessage logMessage, final Throwable throwable) {
        assertArgumentNotNull("logMessage", logMessage);

        final LogLevel level = logMessage.getLevel();
        if (isEnabledFor(level)) {
            final String message = logMessage.getMessage();
            switch (level) {
            case DEBUG:
                log.debug(message, throwable);

            for (final String excluded : EXCLUDED_LOGGERS) {
                if (loggerName.startsWith(excluded)) {
                    return;
                }
            }
        }

        if (!event.getLevel().isMoreSpecificThan(getEffectiveMinLevel())) {
            return;
        }

        try {
            if (!ComponentUtil.getFessConfig().isLogNotificationEnabled()) {
                return;
            }

  public void test() throws Exception {
    assertTrue(handler.getStoredLogRecords().isEmpty());
    ExampleClassUnderTest.foo();
    LogRecord record = handler.getStoredLogRecords().get(0);
    assertEquals(Level.INFO, record.getLevel());
    assertThat(record.getMessage()).isEqualTo("message");
    assertThat(record.getThrown()).isEqualTo(EXCEPTION);
  }

  public void testConcurrentModification() throws Exception {

                    final Map<String, Object> source = new HashMap<>();
                    source.put("hostname", hostname);
                    source.put("level", event.getLevel());
                    source.put("loggerName", event.getLoggerName());
                    source.put("message", event.getMessage());

  public void test() throws Exception {
    assertTrue(handler.getStoredLogRecords().isEmpty());
    ExampleClassUnderTest.foo();
    LogRecord record = handler.getStoredLogRecords().get(0);
    assertEquals(Level.INFO, record.getLevel());
    assertThat(record.getMessage()).isEqualTo("message");
    assertThat(record.getThrown()).isEqualTo(EXCEPTION);
  }

  public void testConcurrentModification() throws Exception {

        Logger rootLogger = Logger.getLogger("");
        rootLogger.setLevel(Level.ALL);
        ConsoleHandler handler = new ConsoleHandler();
        handler.setFormatter(new SimpleFormatter());
        handler.setLevel(Level.ALL);
        rootLogger.addHandler(handler);
    }

    @Override
    public void tearDown(final TestInfo testInfo) throws Exception {