| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache license, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the license for the specific language governing permissions and |
| * limitations under the license. |
| */ |
| package org.apache.logging.log4j; |
| |
| import static org.hamcrest.CoreMatchers.containsString; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertThat; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| |
| import org.apache.logging.log4j.junit.StatusLoggerRule; |
| import org.apache.logging.log4j.message.Message; |
| import org.apache.logging.log4j.message.ObjectMessage; |
| import org.apache.logging.log4j.message.ParameterizedMessage; |
| import org.apache.logging.log4j.message.ParameterizedMessageFactory; |
| import org.apache.logging.log4j.message.SimpleMessage; |
| import org.apache.logging.log4j.spi.AbstractLogger; |
| import org.apache.logging.log4j.status.StatusData; |
| import org.apache.logging.log4j.status.StatusLogger; |
| import org.apache.logging.log4j.util.MessageSupplier; |
| import org.apache.logging.log4j.util.Supplier; |
| import org.junit.Rule; |
| import org.junit.Test; |
| |
| import java.util.List; |
| |
| /** |
| * |
| */ |
| public class AbstractLoggerTest { |
| |
| private static final StringBuilder CHAR_SEQ = new StringBuilder("CharSeq"); |
| |
| // TODO add proper tests for ReusableMessage |
| |
| @SuppressWarnings("ThrowableInstanceNeverThrown") |
| private static Throwable t = new UnsupportedOperationException("Test"); |
| |
| private static Class<AbstractLogger> obj = AbstractLogger.class; |
| private static String pattern = "{}, {}"; |
| private static String p1 = "Long Beach"; |
| |
| private static String p2 = "California"; |
| private static Message charSeq = new SimpleMessage(CHAR_SEQ); |
| private static Message simple = new SimpleMessage("Hello"); |
| private static Message object = new ObjectMessage(obj); |
| |
| private static Message param = new ParameterizedMessage(pattern, p1, p2); |
| |
| private static final Marker MARKER = MarkerManager.getMarker("TEST"); |
| private static final String MARKER_NAME = "TEST"; |
| |
| @Rule |
| public StatusLoggerRule status = new StatusLoggerRule(Level.WARN); |
| |
| private static final LogEvent[] EVENTS = new LogEvent[] { |
| new LogEvent(null, simple, null), |
| new LogEvent(MARKER_NAME, simple, null), |
| new LogEvent(null, simple, t), |
| new LogEvent(MARKER_NAME, simple, t), |
| |
| new LogEvent(null, object, null), |
| new LogEvent(MARKER_NAME, object, null), |
| new LogEvent(null, object, t), |
| new LogEvent(MARKER_NAME, object, t), |
| |
| new LogEvent(null, param, null), |
| new LogEvent(MARKER_NAME, param, null), |
| |
| new LogEvent(null, simple, null), |
| new LogEvent(null, simple, t), |
| new LogEvent(MARKER_NAME, simple, null), |
| new LogEvent(MARKER_NAME, simple, t), |
| new LogEvent(MARKER_NAME, simple, null), |
| |
| new LogEvent(null, charSeq, null), |
| new LogEvent(null, charSeq, t), |
| new LogEvent(MARKER_NAME, charSeq, null), |
| new LogEvent(MARKER_NAME, charSeq, t), |
| }; |
| |
| |
| @Test |
| public void testDebug() { |
| final CountingLogger logger = new CountingLogger(); |
| logger.setCurrentLevel(Level.DEBUG); |
| |
| logger.setCurrentEvent(EVENTS[0]); |
| logger.debug("Hello"); |
| logger.debug((Marker) null, "Hello"); |
| logger.setCurrentEvent(EVENTS[1]); |
| logger.debug(MARKER, "Hello"); |
| logger.setCurrentEvent(EVENTS[2]); |
| logger.debug("Hello", t); |
| logger.debug((Marker) null, "Hello", t); |
| logger.setCurrentEvent(EVENTS[3]); |
| logger.debug(MARKER, "Hello", t); |
| logger.setCurrentEvent(EVENTS[4]); |
| logger.debug(obj); |
| logger.setCurrentEvent(EVENTS[5]); |
| logger.debug(MARKER, obj); |
| logger.setCurrentEvent(EVENTS[6]); |
| logger.debug(obj, t); |
| logger.debug((Marker) null, obj, t); |
| logger.setCurrentEvent(EVENTS[7]); |
| logger.debug(MARKER, obj, t); |
| logger.setCurrentEvent(EVENTS[8]); |
| logger.debug(pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[9]); |
| logger.debug(MARKER, pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[10]); |
| logger.debug(simple); |
| logger.debug((Marker) null, simple); |
| logger.debug((Marker) null, simple, null); |
| logger.setCurrentEvent(EVENTS[11]); |
| logger.debug(simple, t); |
| logger.debug((Marker) null, simple, t); |
| logger.setCurrentEvent(EVENTS[12]); |
| logger.debug(MARKER, simple, null); |
| logger.setCurrentEvent(EVENTS[13]); |
| logger.debug(MARKER, simple, t); |
| logger.setCurrentEvent(EVENTS[14]); |
| logger.debug(MARKER, simple); |
| |
| logger.setCurrentEvent(EVENTS[15]); |
| logger.debug(CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[16]); |
| logger.debug(CHAR_SEQ, t); |
| logger.setCurrentEvent(EVENTS[17]); |
| logger.debug(MARKER, CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[18]); |
| logger.debug(MARKER, CHAR_SEQ, t); |
| |
| assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount()); |
| assertEquals("log(Object) invocations", 5, logger.getObjectCount()); |
| } |
| |
| @Test |
| public void testError() { |
| final CountingLogger logger = new CountingLogger(); |
| logger.setCurrentLevel(Level.ERROR); |
| |
| logger.setCurrentEvent(EVENTS[0]); |
| logger.error("Hello"); |
| logger.error((Marker) null, "Hello"); |
| logger.setCurrentEvent(EVENTS[1]); |
| logger.error(MARKER, "Hello"); |
| logger.setCurrentEvent(EVENTS[2]); |
| logger.error("Hello", t); |
| logger.error((Marker) null, "Hello", t); |
| logger.setCurrentEvent(EVENTS[3]); |
| logger.error(MARKER, "Hello", t); |
| logger.setCurrentEvent(EVENTS[4]); |
| logger.error(obj); |
| logger.setCurrentEvent(EVENTS[5]); |
| logger.error(MARKER, obj); |
| logger.setCurrentEvent(EVENTS[6]); |
| logger.error(obj, t); |
| logger.error((Marker) null, obj, t); |
| logger.setCurrentEvent(EVENTS[7]); |
| logger.error(MARKER, obj, t); |
| logger.setCurrentEvent(EVENTS[8]); |
| logger.error(pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[9]); |
| logger.error(MARKER, pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[10]); |
| logger.error(simple); |
| logger.error((Marker) null, simple); |
| logger.error((Marker) null, simple, null); |
| logger.setCurrentEvent(EVENTS[11]); |
| logger.error(simple, t); |
| logger.error((Marker) null, simple, t); |
| logger.setCurrentEvent(EVENTS[12]); |
| logger.error(MARKER, simple, null); |
| logger.setCurrentEvent(EVENTS[13]); |
| logger.error(MARKER, simple, t); |
| logger.setCurrentEvent(EVENTS[14]); |
| logger.error(MARKER, simple); |
| |
| logger.setCurrentEvent(EVENTS[15]); |
| logger.error(CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[16]); |
| logger.error(CHAR_SEQ, t); |
| logger.setCurrentEvent(EVENTS[17]); |
| logger.error(MARKER, CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[18]); |
| logger.error(MARKER, CHAR_SEQ, t); |
| |
| assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount()); |
| assertEquals("log(Object) invocations", 5, logger.getObjectCount()); |
| } |
| |
| @Test |
| public void testFatal() { |
| final CountingLogger logger = new CountingLogger(); |
| logger.setCurrentLevel(Level.FATAL); |
| |
| logger.setCurrentEvent(EVENTS[0]); |
| logger.fatal("Hello"); |
| logger.fatal((Marker) null, "Hello"); |
| logger.setCurrentEvent(EVENTS[1]); |
| logger.fatal(MARKER, "Hello"); |
| logger.setCurrentEvent(EVENTS[2]); |
| logger.fatal("Hello", t); |
| logger.fatal((Marker) null, "Hello", t); |
| logger.setCurrentEvent(EVENTS[3]); |
| logger.fatal(MARKER, "Hello", t); |
| logger.setCurrentEvent(EVENTS[4]); |
| logger.fatal(obj); |
| logger.setCurrentEvent(EVENTS[5]); |
| logger.fatal(MARKER, obj); |
| logger.setCurrentEvent(EVENTS[6]); |
| logger.fatal(obj, t); |
| logger.fatal((Marker) null, obj, t); |
| logger.setCurrentEvent(EVENTS[7]); |
| logger.fatal(MARKER, obj, t); |
| logger.setCurrentEvent(EVENTS[8]); |
| logger.fatal(pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[9]); |
| logger.fatal(MARKER, pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[10]); |
| logger.fatal(simple); |
| logger.fatal((Marker) null, simple); |
| logger.fatal((Marker) null, simple, null); |
| logger.setCurrentEvent(EVENTS[11]); |
| logger.fatal(simple, t); |
| logger.fatal((Marker) null, simple, t); |
| logger.setCurrentEvent(EVENTS[12]); |
| logger.fatal(MARKER, simple, null); |
| logger.setCurrentEvent(EVENTS[13]); |
| logger.fatal(MARKER, simple, t); |
| logger.setCurrentEvent(EVENTS[14]); |
| logger.fatal(MARKER, simple); |
| |
| logger.setCurrentEvent(EVENTS[15]); |
| logger.fatal(CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[16]); |
| logger.fatal(CHAR_SEQ, t); |
| logger.setCurrentEvent(EVENTS[17]); |
| logger.fatal(MARKER, CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[18]); |
| logger.fatal(MARKER, CHAR_SEQ, t); |
| |
| assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount()); |
| assertEquals("log(Object) invocations", 5, logger.getObjectCount()); |
| } |
| |
| @Test |
| public void testInfo() { |
| final CountingLogger logger = new CountingLogger(); |
| logger.setCurrentLevel(Level.INFO); |
| |
| logger.setCurrentEvent(EVENTS[0]); |
| logger.info("Hello"); |
| logger.info((Marker) null, "Hello"); |
| logger.setCurrentEvent(EVENTS[1]); |
| logger.info(MARKER, "Hello"); |
| logger.setCurrentEvent(EVENTS[2]); |
| logger.info("Hello", t); |
| logger.info((Marker) null, "Hello", t); |
| logger.setCurrentEvent(EVENTS[3]); |
| logger.info(MARKER, "Hello", t); |
| logger.setCurrentEvent(EVENTS[4]); |
| logger.info(obj); |
| logger.setCurrentEvent(EVENTS[5]); |
| logger.info(MARKER, obj); |
| logger.setCurrentEvent(EVENTS[6]); |
| logger.info(obj, t); |
| logger.info((Marker) null, obj, t); |
| logger.setCurrentEvent(EVENTS[7]); |
| logger.info(MARKER, obj, t); |
| logger.setCurrentEvent(EVENTS[8]); |
| logger.info(pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[9]); |
| logger.info(MARKER, pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[10]); |
| logger.info(simple); |
| logger.info((Marker) null, simple); |
| logger.info((Marker) null, simple, null); |
| logger.setCurrentEvent(EVENTS[11]); |
| logger.info(simple, t); |
| logger.info((Marker) null, simple, t); |
| logger.setCurrentEvent(EVENTS[12]); |
| logger.info(MARKER, simple, null); |
| logger.setCurrentEvent(EVENTS[13]); |
| logger.info(MARKER, simple, t); |
| logger.setCurrentEvent(EVENTS[14]); |
| logger.info(MARKER, simple); |
| |
| logger.setCurrentEvent(EVENTS[15]); |
| logger.info(CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[16]); |
| logger.info(CHAR_SEQ, t); |
| logger.setCurrentEvent(EVENTS[17]); |
| logger.info(MARKER, CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[18]); |
| logger.info(MARKER, CHAR_SEQ, t); |
| |
| assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount()); |
| assertEquals("log(Object) invocations", 5, logger.getObjectCount()); |
| } |
| |
| @Test |
| public void testLogDebug() { |
| final CountingLogger logger = new CountingLogger(); |
| logger.setCurrentLevel(Level.DEBUG); |
| |
| logger.setCurrentEvent(EVENTS[0]); |
| logger.log(Level.DEBUG, "Hello"); |
| logger.log(Level.DEBUG, (Marker) null, "Hello"); |
| logger.setCurrentEvent(EVENTS[1]); |
| logger.log(Level.DEBUG, MARKER, "Hello"); |
| logger.setCurrentEvent(EVENTS[2]); |
| logger.log(Level.DEBUG, "Hello", t); |
| logger.log(Level.DEBUG, (Marker) null, "Hello", t); |
| logger.setCurrentEvent(EVENTS[3]); |
| logger.log(Level.DEBUG, MARKER, "Hello", t); |
| logger.setCurrentEvent(EVENTS[4]); |
| logger.log(Level.DEBUG, obj); |
| logger.setCurrentEvent(EVENTS[5]); |
| logger.log(Level.DEBUG, MARKER, obj); |
| logger.setCurrentEvent(EVENTS[6]); |
| logger.log(Level.DEBUG, obj, t); |
| logger.log(Level.DEBUG, (Marker) null, obj, t); |
| logger.setCurrentEvent(EVENTS[7]); |
| logger.log(Level.DEBUG, MARKER, obj, t); |
| logger.setCurrentEvent(EVENTS[8]); |
| logger.log(Level.DEBUG, pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[9]); |
| logger.log(Level.DEBUG, MARKER, pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[10]); |
| logger.log(Level.DEBUG, simple); |
| logger.log(Level.DEBUG, (Marker) null, simple); |
| logger.log(Level.DEBUG, (Marker) null, simple, null); |
| logger.setCurrentEvent(EVENTS[11]); |
| logger.log(Level.DEBUG, simple, t); |
| logger.log(Level.DEBUG, (Marker) null, simple, t); |
| logger.setCurrentEvent(EVENTS[12]); |
| logger.log(Level.DEBUG, MARKER, simple, null); |
| logger.setCurrentEvent(EVENTS[13]); |
| logger.log(Level.DEBUG, MARKER, simple, t); |
| logger.setCurrentEvent(EVENTS[14]); |
| logger.log(Level.DEBUG, MARKER, simple); |
| |
| logger.setCurrentEvent(EVENTS[15]); |
| logger.log(Level.DEBUG, CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[16]); |
| logger.log(Level.DEBUG, CHAR_SEQ, t); |
| logger.setCurrentEvent(EVENTS[17]); |
| logger.log(Level.DEBUG, MARKER, CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[18]); |
| logger.log(Level.DEBUG, MARKER, CHAR_SEQ, t); |
| |
| assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount()); |
| assertEquals("log(Object) invocations", 5, logger.getObjectCount()); |
| } |
| |
| @Test |
| public void testLogError() { |
| final CountingLogger logger = new CountingLogger(); |
| logger.setCurrentLevel(Level.ERROR); |
| |
| logger.setCurrentEvent(EVENTS[0]); |
| logger.log(Level.ERROR, "Hello"); |
| logger.log(Level.ERROR, (Marker) null, "Hello"); |
| logger.setCurrentEvent(EVENTS[1]); |
| logger.log(Level.ERROR, MARKER, "Hello"); |
| logger.setCurrentEvent(EVENTS[2]); |
| logger.log(Level.ERROR, "Hello", t); |
| logger.log(Level.ERROR, (Marker) null, "Hello", t); |
| logger.setCurrentEvent(EVENTS[3]); |
| logger.log(Level.ERROR, MARKER, "Hello", t); |
| logger.setCurrentEvent(EVENTS[4]); |
| logger.log(Level.ERROR, obj); |
| logger.setCurrentEvent(EVENTS[5]); |
| logger.log(Level.ERROR, MARKER, obj); |
| logger.setCurrentEvent(EVENTS[6]); |
| logger.log(Level.ERROR, obj, t); |
| logger.log(Level.ERROR, (Marker) null, obj, t); |
| logger.setCurrentEvent(EVENTS[7]); |
| logger.log(Level.ERROR, MARKER, obj, t); |
| logger.setCurrentEvent(EVENTS[8]); |
| logger.log(Level.ERROR, pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[9]); |
| logger.log(Level.ERROR, MARKER, pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[10]); |
| logger.log(Level.ERROR, simple); |
| logger.log(Level.ERROR, (Marker) null, simple); |
| logger.log(Level.ERROR, (Marker) null, simple, null); |
| logger.setCurrentEvent(EVENTS[11]); |
| logger.log(Level.ERROR, simple, t); |
| logger.log(Level.ERROR, (Marker) null, simple, t); |
| logger.setCurrentEvent(EVENTS[12]); |
| logger.log(Level.ERROR, MARKER, simple, null); |
| logger.setCurrentEvent(EVENTS[13]); |
| logger.log(Level.ERROR, MARKER, simple, t); |
| logger.setCurrentEvent(EVENTS[14]); |
| logger.log(Level.ERROR, MARKER, simple); |
| |
| logger.setCurrentEvent(EVENTS[15]); |
| logger.log(Level.ERROR, CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[16]); |
| logger.log(Level.ERROR, CHAR_SEQ, t); |
| logger.setCurrentEvent(EVENTS[17]); |
| logger.log(Level.ERROR, MARKER, CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[18]); |
| logger.log(Level.ERROR, MARKER, CHAR_SEQ, t); |
| |
| assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount()); |
| assertEquals("log(Object) invocations", 5, logger.getObjectCount()); |
| } |
| |
| @Test |
| public void testLogFatal() { |
| final CountingLogger logger = new CountingLogger(); |
| logger.setCurrentLevel(Level.FATAL); |
| |
| logger.setCurrentEvent(EVENTS[0]); |
| logger.log(Level.FATAL, "Hello"); |
| logger.log(Level.FATAL, (Marker) null, "Hello"); |
| logger.setCurrentEvent(EVENTS[1]); |
| logger.log(Level.FATAL, MARKER, "Hello"); |
| logger.setCurrentEvent(EVENTS[2]); |
| logger.log(Level.FATAL, "Hello", t); |
| logger.log(Level.FATAL, (Marker) null, "Hello", t); |
| logger.setCurrentEvent(EVENTS[3]); |
| logger.log(Level.FATAL, MARKER, "Hello", t); |
| logger.setCurrentEvent(EVENTS[4]); |
| logger.log(Level.FATAL, obj); |
| logger.setCurrentEvent(EVENTS[5]); |
| logger.log(Level.FATAL, MARKER, obj); |
| logger.setCurrentEvent(EVENTS[6]); |
| logger.log(Level.FATAL, obj, t); |
| logger.log(Level.FATAL, (Marker) null, obj, t); |
| logger.setCurrentEvent(EVENTS[7]); |
| logger.log(Level.FATAL, MARKER, obj, t); |
| logger.setCurrentEvent(EVENTS[8]); |
| logger.log(Level.FATAL, pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[9]); |
| logger.log(Level.FATAL, MARKER, pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[10]); |
| logger.log(Level.FATAL, simple); |
| logger.log(Level.FATAL, (Marker) null, simple); |
| logger.log(Level.FATAL, (Marker) null, simple, null); |
| logger.setCurrentEvent(EVENTS[11]); |
| logger.log(Level.FATAL, simple, t); |
| logger.log(Level.FATAL, (Marker) null, simple, t); |
| logger.setCurrentEvent(EVENTS[12]); |
| logger.log(Level.FATAL, MARKER, simple, null); |
| logger.setCurrentEvent(EVENTS[13]); |
| logger.log(Level.FATAL, MARKER, simple, t); |
| logger.setCurrentEvent(EVENTS[14]); |
| logger.log(Level.FATAL, MARKER, simple); |
| |
| logger.setCurrentEvent(EVENTS[15]); |
| logger.log(Level.FATAL, CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[16]); |
| logger.log(Level.FATAL, CHAR_SEQ, t); |
| logger.setCurrentEvent(EVENTS[17]); |
| logger.log(Level.FATAL, MARKER, CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[18]); |
| logger.log(Level.FATAL, MARKER, CHAR_SEQ, t); |
| |
| assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount()); |
| assertEquals("log(Object) invocations", 5, logger.getObjectCount()); |
| } |
| |
| @Test |
| public void testLogInfo() { |
| final CountingLogger logger = new CountingLogger(); |
| logger.setCurrentLevel(Level.INFO); |
| |
| logger.setCurrentEvent(EVENTS[0]); |
| logger.log(Level.INFO, "Hello"); |
| logger.log(Level.INFO, (Marker) null, "Hello"); |
| logger.setCurrentEvent(EVENTS[1]); |
| logger.log(Level.INFO, MARKER, "Hello"); |
| logger.setCurrentEvent(EVENTS[2]); |
| logger.log(Level.INFO, "Hello", t); |
| logger.log(Level.INFO, (Marker) null, "Hello", t); |
| logger.setCurrentEvent(EVENTS[3]); |
| logger.log(Level.INFO, MARKER, "Hello", t); |
| logger.setCurrentEvent(EVENTS[4]); |
| logger.log(Level.INFO, obj); |
| logger.setCurrentEvent(EVENTS[5]); |
| logger.log(Level.INFO, MARKER, obj); |
| logger.setCurrentEvent(EVENTS[6]); |
| logger.log(Level.INFO, obj, t); |
| logger.log(Level.INFO, (Marker) null, obj, t); |
| logger.setCurrentEvent(EVENTS[7]); |
| logger.log(Level.INFO, MARKER, obj, t); |
| logger.setCurrentEvent(EVENTS[8]); |
| logger.log(Level.INFO, pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[9]); |
| logger.log(Level.INFO, MARKER, pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[10]); |
| logger.log(Level.INFO, simple); |
| logger.log(Level.INFO, (Marker) null, simple); |
| logger.log(Level.INFO, (Marker) null, simple, null); |
| logger.setCurrentEvent(EVENTS[11]); |
| logger.log(Level.INFO, simple, t); |
| logger.log(Level.INFO, (Marker) null, simple, t); |
| logger.setCurrentEvent(EVENTS[12]); |
| logger.log(Level.INFO, MARKER, simple, null); |
| logger.setCurrentEvent(EVENTS[13]); |
| logger.log(Level.INFO, MARKER, simple, t); |
| logger.setCurrentEvent(EVENTS[14]); |
| logger.log(Level.INFO, MARKER, simple); |
| |
| logger.setCurrentEvent(EVENTS[15]); |
| logger.log(Level.INFO, CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[16]); |
| logger.log(Level.INFO, CHAR_SEQ, t); |
| logger.setCurrentEvent(EVENTS[17]); |
| logger.log(Level.INFO, MARKER, CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[18]); |
| logger.log(Level.INFO, MARKER, CHAR_SEQ, t); |
| |
| assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount()); |
| assertEquals("log(Object) invocations", 5, logger.getObjectCount()); |
| } |
| |
| @Test |
| public void testLogTrace() { |
| final CountingLogger logger = new CountingLogger(); |
| logger.setCurrentLevel(Level.TRACE); |
| |
| logger.setCurrentEvent(EVENTS[0]); |
| logger.log(Level.TRACE, "Hello"); |
| logger.log(Level.TRACE, (Marker) null, "Hello"); |
| logger.setCurrentEvent(EVENTS[1]); |
| logger.log(Level.TRACE, MARKER, "Hello"); |
| logger.setCurrentEvent(EVENTS[2]); |
| logger.log(Level.TRACE, "Hello", t); |
| logger.log(Level.TRACE, (Marker) null, "Hello", t); |
| logger.setCurrentEvent(EVENTS[3]); |
| logger.log(Level.TRACE, MARKER, "Hello", t); |
| logger.setCurrentEvent(EVENTS[4]); |
| logger.log(Level.TRACE, obj); |
| logger.setCurrentEvent(EVENTS[5]); |
| logger.log(Level.TRACE, MARKER, obj); |
| logger.setCurrentEvent(EVENTS[6]); |
| logger.log(Level.TRACE, obj, t); |
| logger.log(Level.TRACE, (Marker) null, obj, t); |
| logger.setCurrentEvent(EVENTS[7]); |
| logger.log(Level.TRACE, MARKER, obj, t); |
| logger.setCurrentEvent(EVENTS[8]); |
| logger.log(Level.TRACE, pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[9]); |
| logger.log(Level.TRACE, MARKER, pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[10]); |
| logger.log(Level.TRACE, simple); |
| logger.log(Level.TRACE, (Marker) null, simple); |
| logger.log(Level.TRACE, (Marker) null, simple, null); |
| logger.setCurrentEvent(EVENTS[11]); |
| logger.log(Level.TRACE, simple, t); |
| logger.log(Level.TRACE, (Marker) null, simple, t); |
| logger.setCurrentEvent(EVENTS[12]); |
| logger.log(Level.TRACE, MARKER, simple, null); |
| logger.setCurrentEvent(EVENTS[13]); |
| logger.log(Level.TRACE, MARKER, simple, t); |
| logger.setCurrentEvent(EVENTS[14]); |
| logger.log(Level.TRACE, MARKER, simple); |
| |
| logger.setCurrentEvent(EVENTS[15]); |
| logger.log(Level.TRACE, CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[16]); |
| logger.log(Level.TRACE, CHAR_SEQ, t); |
| logger.setCurrentEvent(EVENTS[17]); |
| logger.log(Level.TRACE, MARKER, CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[18]); |
| logger.log(Level.TRACE, MARKER, CHAR_SEQ, t); |
| |
| assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount()); |
| assertEquals("log(Object) invocations", 5, logger.getObjectCount()); |
| } |
| |
| @Test |
| public void testLogWarn() { |
| final CountingLogger logger = new CountingLogger(); |
| logger.setCurrentLevel(Level.WARN); |
| |
| logger.setCurrentEvent(EVENTS[0]); |
| logger.log(Level.WARN, "Hello"); |
| logger.log(Level.WARN, (Marker) null, "Hello"); |
| logger.setCurrentEvent(EVENTS[1]); |
| logger.log(Level.WARN, MARKER, "Hello"); |
| logger.setCurrentEvent(EVENTS[2]); |
| logger.log(Level.WARN, "Hello", t); |
| logger.log(Level.WARN, (Marker) null, "Hello", t); |
| logger.setCurrentEvent(EVENTS[3]); |
| logger.log(Level.WARN, MARKER, "Hello", t); |
| logger.setCurrentEvent(EVENTS[4]); |
| logger.log(Level.WARN, obj); |
| logger.setCurrentEvent(EVENTS[5]); |
| logger.log(Level.WARN, MARKER, obj); |
| logger.setCurrentEvent(EVENTS[6]); |
| logger.log(Level.WARN, obj, t); |
| logger.log(Level.WARN, (Marker) null, obj, t); |
| logger.setCurrentEvent(EVENTS[7]); |
| logger.log(Level.WARN, MARKER, obj, t); |
| logger.setCurrentEvent(EVENTS[8]); |
| logger.log(Level.WARN, pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[9]); |
| logger.log(Level.WARN, MARKER, pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[10]); |
| logger.log(Level.WARN, simple); |
| logger.log(Level.WARN, (Marker) null, simple); |
| logger.log(Level.WARN, (Marker) null, simple, null); |
| logger.setCurrentEvent(EVENTS[11]); |
| logger.log(Level.WARN, simple, t); |
| logger.log(Level.WARN, (Marker) null, simple, t); |
| logger.setCurrentEvent(EVENTS[12]); |
| logger.log(Level.WARN, MARKER, simple, null); |
| logger.setCurrentEvent(EVENTS[13]); |
| logger.log(Level.WARN, MARKER, simple, t); |
| logger.setCurrentEvent(EVENTS[14]); |
| logger.log(Level.WARN, MARKER, simple); |
| |
| logger.setCurrentEvent(EVENTS[15]); |
| logger.log(Level.WARN, CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[16]); |
| logger.log(Level.WARN, CHAR_SEQ, t); |
| logger.setCurrentEvent(EVENTS[17]); |
| logger.log(Level.WARN, MARKER, CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[18]); |
| logger.log(Level.WARN, MARKER, CHAR_SEQ, t); |
| |
| assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount()); |
| assertEquals("log(Object) invocations", 5, logger.getObjectCount()); |
| } |
| |
| @Test |
| public void testTrace() { |
| final CountingLogger logger = new CountingLogger(); |
| logger.setCurrentLevel(Level.TRACE); |
| |
| logger.setCurrentEvent(EVENTS[0]); |
| logger.trace("Hello"); |
| logger.trace((Marker) null, "Hello"); |
| logger.setCurrentEvent(EVENTS[1]); |
| logger.trace(MARKER, "Hello"); |
| logger.setCurrentEvent(EVENTS[2]); |
| logger.trace("Hello", t); |
| logger.trace((Marker) null, "Hello", t); |
| logger.setCurrentEvent(EVENTS[3]); |
| logger.trace(MARKER, "Hello", t); |
| logger.setCurrentEvent(EVENTS[4]); |
| logger.trace(obj); |
| logger.setCurrentEvent(EVENTS[5]); |
| logger.trace(MARKER, obj); |
| logger.setCurrentEvent(EVENTS[6]); |
| logger.trace(obj, t); |
| logger.trace((Marker) null, obj, t); |
| logger.setCurrentEvent(EVENTS[7]); |
| logger.trace(MARKER, obj, t); |
| logger.setCurrentEvent(EVENTS[8]); |
| logger.trace(pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[9]); |
| logger.trace(MARKER, pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[10]); |
| logger.trace(simple); |
| logger.trace((Marker) null, simple); |
| logger.trace((Marker) null, simple, null); |
| logger.setCurrentEvent(EVENTS[11]); |
| logger.trace(simple, t); |
| logger.trace((Marker) null, simple, t); |
| logger.setCurrentEvent(EVENTS[12]); |
| logger.trace(MARKER, simple, null); |
| logger.setCurrentEvent(EVENTS[13]); |
| logger.trace(MARKER, simple, t); |
| logger.setCurrentEvent(EVENTS[14]); |
| logger.trace(MARKER, simple); |
| |
| logger.setCurrentEvent(EVENTS[15]); |
| logger.trace(CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[16]); |
| logger.trace(CHAR_SEQ, t); |
| logger.setCurrentEvent(EVENTS[17]); |
| logger.trace(MARKER, CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[18]); |
| logger.trace(MARKER, CHAR_SEQ, t); |
| |
| assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount()); |
| assertEquals("log(Object) invocations", 5, logger.getObjectCount()); |
| } |
| |
| @Test |
| public void testWarn() { |
| final CountingLogger logger = new CountingLogger(); |
| logger.setCurrentLevel(Level.WARN); |
| |
| logger.setCurrentEvent(EVENTS[0]); |
| logger.warn("Hello"); |
| logger.warn((Marker) null, "Hello"); |
| logger.setCurrentEvent(EVENTS[1]); |
| logger.warn(MARKER, "Hello"); |
| logger.setCurrentEvent(EVENTS[2]); |
| logger.warn("Hello", t); |
| logger.warn((Marker) null, "Hello", t); |
| logger.setCurrentEvent(EVENTS[3]); |
| logger.warn(MARKER, "Hello", t); |
| logger.setCurrentEvent(EVENTS[4]); |
| logger.warn(obj); |
| logger.setCurrentEvent(EVENTS[5]); |
| logger.warn(MARKER, obj); |
| logger.setCurrentEvent(EVENTS[6]); |
| logger.warn(obj, t); |
| logger.warn((Marker) null, obj, t); |
| logger.setCurrentEvent(EVENTS[7]); |
| logger.warn(MARKER, obj, t); |
| logger.setCurrentEvent(EVENTS[8]); |
| logger.warn(pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[9]); |
| logger.warn(MARKER, pattern, p1, p2); |
| logger.setCurrentEvent(EVENTS[10]); |
| logger.warn(simple); |
| logger.warn((Marker) null, simple); |
| logger.warn((Marker) null, simple, null); |
| logger.setCurrentEvent(EVENTS[11]); |
| logger.warn(simple, t); |
| logger.warn((Marker) null, simple, t); |
| logger.setCurrentEvent(EVENTS[12]); |
| logger.warn(MARKER, simple, null); |
| logger.setCurrentEvent(EVENTS[13]); |
| logger.warn(MARKER, simple, t); |
| logger.setCurrentEvent(EVENTS[14]); |
| logger.warn(MARKER, simple); |
| |
| logger.setCurrentEvent(EVENTS[15]); |
| logger.warn(CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[16]); |
| logger.warn(CHAR_SEQ, t); |
| logger.setCurrentEvent(EVENTS[17]); |
| logger.warn(MARKER, CHAR_SEQ); |
| logger.setCurrentEvent(EVENTS[18]); |
| logger.warn(MARKER, CHAR_SEQ, t); |
| |
| assertEquals("log(CharSeq) invocations", 4, logger.getCharSeqCount()); |
| assertEquals("log(Object) invocations", 5, logger.getObjectCount()); |
| } |
| |
| @Test |
| public void testMessageWithThrowable() { |
| final ThrowableExpectingLogger logger = new ThrowableExpectingLogger(true); |
| final ThrowableMessage message = new ThrowableMessage(t); |
| |
| logger.debug(message); |
| logger.error(message); |
| logger.fatal(message); |
| logger.info(message); |
| logger.trace(message); |
| logger.warn(message); |
| logger.log(Level.INFO, message); |
| |
| logger.debug(MARKER, message); |
| logger.error(MARKER, message); |
| logger.fatal(MARKER, message); |
| logger.info(MARKER, message); |
| logger.trace(MARKER, message); |
| logger.warn(MARKER, message); |
| logger.log(Level.INFO, MARKER, message); |
| } |
| |
| @Test |
| public void testMessageWithoutThrowable() { |
| final ThrowableExpectingLogger logger = new ThrowableExpectingLogger(false); |
| final ThrowableMessage message = new ThrowableMessage(null); |
| |
| logger.debug(message); |
| logger.error(message); |
| logger.fatal(message); |
| logger.info(message); |
| logger.trace(message); |
| logger.warn(message); |
| logger.log(Level.INFO, message); |
| |
| logger.debug(MARKER, message); |
| logger.error(MARKER, message); |
| logger.fatal(MARKER, message); |
| logger.info(MARKER, message); |
| logger.trace(MARKER, message); |
| logger.warn(MARKER, message); |
| logger.log(Level.INFO, MARKER, message); |
| } |
| |
| @Test |
| public void testMessageSupplierWithThrowable() { |
| final ThrowableExpectingLogger logger = new ThrowableExpectingLogger(true); |
| final ThrowableMessage message = new ThrowableMessage(t); |
| final MessageSupplier supplier = new MessageSupplier() { |
| @Override |
| public Message get() { |
| return message; |
| } |
| }; |
| |
| logger.debug(supplier); |
| logger.error(supplier); |
| logger.fatal(supplier); |
| logger.info(supplier); |
| logger.trace(supplier); |
| logger.warn(supplier); |
| logger.log(Level.INFO, supplier); |
| |
| logger.debug(MARKER, supplier); |
| logger.error(MARKER, supplier); |
| logger.fatal(MARKER, supplier); |
| logger.info(MARKER, supplier); |
| logger.trace(MARKER, supplier); |
| logger.warn(MARKER, supplier); |
| logger.log(Level.INFO, MARKER, supplier); |
| } |
| |
| @Test |
| public void testMessageSupplierWithoutThrowable() { |
| final ThrowableExpectingLogger logger = new ThrowableExpectingLogger(false); |
| final ThrowableMessage message = new ThrowableMessage(null); |
| final MessageSupplier supplier = new MessageSupplier() { |
| @Override |
| public Message get() { |
| return message; |
| } |
| }; |
| |
| logger.debug(supplier); |
| logger.error(supplier); |
| logger.fatal(supplier); |
| logger.info(supplier); |
| logger.trace(supplier); |
| logger.warn(supplier); |
| logger.log(Level.INFO, supplier); |
| |
| logger.debug(MARKER, supplier); |
| logger.error(MARKER, supplier); |
| logger.fatal(MARKER, supplier); |
| logger.info(MARKER, supplier); |
| logger.trace(MARKER, supplier); |
| logger.warn(MARKER, supplier); |
| logger.log(Level.INFO, MARKER, supplier); |
| } |
| |
| @Test |
| public void testSupplierWithThrowable() { |
| final ThrowableExpectingLogger logger = new ThrowableExpectingLogger(true); |
| final ThrowableMessage message = new ThrowableMessage(t); |
| final Supplier<Message> supplier = new Supplier<Message>() { |
| @Override |
| public Message get() { |
| return message; |
| } |
| }; |
| |
| logger.debug(supplier); |
| logger.error(supplier); |
| logger.fatal(supplier); |
| logger.info(supplier); |
| logger.trace(supplier); |
| logger.warn(supplier); |
| logger.log(Level.INFO, supplier); |
| |
| logger.debug(MARKER, supplier); |
| logger.error(MARKER, supplier); |
| logger.fatal(MARKER, supplier); |
| logger.info(MARKER, supplier); |
| logger.trace(MARKER, supplier); |
| logger.warn(MARKER, supplier); |
| logger.log(Level.INFO, MARKER, supplier); |
| } |
| |
| @Test |
| public void testSupplierWithoutThrowable() { |
| final ThrowableExpectingLogger logger = new ThrowableExpectingLogger(false); |
| final ThrowableMessage message = new ThrowableMessage(null); |
| final Supplier<Message> supplier = new Supplier<Message>() { |
| @Override |
| public Message get() { |
| return message; |
| } |
| }; |
| |
| logger.debug(supplier); |
| logger.error(supplier); |
| logger.fatal(supplier); |
| logger.info(supplier); |
| logger.trace(supplier); |
| logger.warn(supplier); |
| logger.log(Level.INFO, supplier); |
| |
| logger.debug(MARKER, supplier); |
| logger.error(MARKER, supplier); |
| logger.fatal(MARKER, supplier); |
| logger.info(MARKER, supplier); |
| logger.trace(MARKER, supplier); |
| logger.warn(MARKER, supplier); |
| logger.log(Level.INFO, MARKER, supplier); |
| } |
| |
| @Test |
| public void testMessageThrows() { |
| final ThrowableExpectingLogger logger = new ThrowableExpectingLogger(false); |
| logger.error(new TestMessage(new TestMessage.FormattedMessageSupplier() { |
| @Override |
| public String getFormattedMessage() { |
| throw new IllegalStateException("Oops!"); |
| } |
| }, "Message Format")); |
| List<StatusData> statusDatalist = StatusLogger.getLogger().getStatusData(); |
| StatusData mostRecent = statusDatalist.get(statusDatalist.size() - 1); |
| assertEquals(Level.WARN, mostRecent.getLevel()); |
| assertThat(mostRecent.getFormattedStatus(), containsString( |
| "org.apache.logging.log4j.spi.AbstractLogger caught " + |
| "java.lang.IllegalStateException logging TestMessage: Message Format")); |
| } |
| |
| @Test |
| public void testMessageThrowsAndNullFormat() { |
| final ThrowableExpectingLogger logger = new ThrowableExpectingLogger(false); |
| logger.error(new TestMessage(new TestMessage.FormattedMessageSupplier() { |
| @Override |
| public String getFormattedMessage() { |
| throw new IllegalStateException("Oops!"); |
| } |
| }, null /* format */)); |
| List<StatusData> statusDatalist = StatusLogger.getLogger().getStatusData(); |
| StatusData mostRecent = statusDatalist.get(statusDatalist.size() - 1); |
| assertEquals(Level.WARN, mostRecent.getLevel()); |
| assertThat(mostRecent.getFormattedStatus(), containsString( |
| "org.apache.logging.log4j.spi.AbstractLogger caught " + |
| "java.lang.IllegalStateException logging TestMessage: ")); |
| } |
| |
| private static final class TestMessage implements Message { |
| private final FormattedMessageSupplier formattedMessageSupplier; |
| private final String format; |
| TestMessage(FormattedMessageSupplier formattedMessageSupplier, String format) { |
| this.formattedMessageSupplier = formattedMessageSupplier; |
| this.format = format; |
| } |
| |
| @Override |
| public String getFormattedMessage() { |
| return formattedMessageSupplier.getFormattedMessage(); |
| } |
| |
| @Override |
| public String getFormat() { |
| return format; |
| } |
| |
| @Override |
| public Object[] getParameters() { |
| return new Object[0]; |
| } |
| |
| @Override |
| public Throwable getThrowable() { |
| return null; |
| } |
| |
| interface FormattedMessageSupplier { |
| String getFormattedMessage(); |
| } |
| } |
| |
| private static class CountingLogger extends AbstractLogger { |
| private static final long serialVersionUID = -3171452617952475480L; |
| |
| private Level currentLevel; |
| private LogEvent currentEvent; |
| private int charSeqCount; |
| private int objectCount; |
| |
| CountingLogger() { |
| super("CountingLogger", ParameterizedMessageFactory.INSTANCE); |
| } |
| |
| void setCurrentLevel(final Level currentLevel) { |
| this.currentLevel = currentLevel; |
| } |
| |
| void setCurrentEvent(final LogEvent currentEvent) { |
| this.currentEvent = currentEvent; |
| } |
| |
| int getCharSeqCount() { |
| return charSeqCount; |
| } |
| |
| int getObjectCount() { |
| return objectCount; |
| } |
| |
| @Override |
| public Level getLevel() { |
| return currentLevel; |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final Message data, final Throwable t) { |
| assertTrue("Incorrect Level. Expected " + currentLevel + ", actual " + level, level.equals(currentLevel)); |
| if (marker == null) { |
| if (currentEvent.markerName != null) { |
| fail("Incorrect marker. Expected " + currentEvent.markerName + ", actual is null"); |
| } |
| } else { |
| if (currentEvent.markerName == null) { |
| fail("Incorrect marker. Expected null. Actual is " + marker.getName()); |
| } else { |
| assertTrue("Incorrect marker. Expected " + currentEvent.markerName + ", actual " + |
| marker.getName(), currentEvent.markerName.equals(marker.getName())); |
| } |
| } |
| if (data == null) { |
| if (currentEvent.data != null) { |
| fail("Incorrect message. Expected " + currentEvent.data + ", actual is null"); |
| } |
| } else { |
| if (currentEvent.data == null) { |
| fail("Incorrect message. Expected null. Actual is " + data.getFormattedMessage()); |
| } else { |
| assertTrue("Incorrect message type. Expected " + currentEvent.data + ", actual " + data, |
| data.getClass().isAssignableFrom(currentEvent.data.getClass())); |
| assertTrue("Incorrect message. Expected " + currentEvent.data.getFormattedMessage() + ", actual " + |
| data.getFormattedMessage(), |
| currentEvent.data.getFormattedMessage().equals(data.getFormattedMessage())); |
| } |
| } |
| if (t == null) { |
| if (currentEvent.t != null) { |
| fail("Incorrect Throwable. Expected " + currentEvent.t + ", actual is null"); |
| } |
| } else { |
| if (currentEvent.t == null) { |
| fail("Incorrect Throwable. Expected null. Actual is " + t); |
| } else { |
| assertTrue("Incorrect Throwable. Expected " + currentEvent.t + ", actual " + t, |
| currentEvent.t.equals(t)); |
| } |
| } |
| return true; |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final CharSequence data, final Throwable t) { |
| charSeqCount++; |
| return isEnabled(level, marker, (Message) new SimpleMessage(data), t); |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final Object data, final Throwable t) { |
| objectCount++; |
| return isEnabled(level, marker, new ObjectMessage(data), t); |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String data) { |
| return isEnabled(level, marker, (Message) new SimpleMessage(data), null); |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String data, final Object... p1) { |
| return isEnabled(level, marker, new ParameterizedMessage(data, p1), null); |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0) { |
| return isEnabled(level, marker, new ParameterizedMessage(message, p0), null); |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0, |
| final Object p1) { |
| return isEnabled(level, marker, new ParameterizedMessage(message, p0, p1), null); |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0, |
| final Object p1, final Object p2) { |
| return isEnabled(level, marker, new ParameterizedMessage(message, p0, p1, p2), null); |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0, |
| final Object p1, final Object p2, final Object p3) { |
| return isEnabled(level, marker, new ParameterizedMessage(message, p0, p1, p2, p3), null); |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0, |
| final Object p1, final Object p2, final Object p3, |
| final Object p4) { |
| return isEnabled(level, marker, new ParameterizedMessage(message, p0, p1, p2, p3, p4), null); |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0, |
| final Object p1, final Object p2, final Object p3, |
| final Object p4, final Object p5) { |
| return isEnabled(level, marker, new ParameterizedMessage(message, p0, p1, p2, p3, p4, p5), null); |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0, |
| final Object p1, final Object p2, final Object p3, |
| final Object p4, final Object p5, final Object p6) { |
| return isEnabled(level, marker, new ParameterizedMessage(message, p0, p1, p2, p3, p4, p5, p6), null); |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0, |
| final Object p1, final Object p2, final Object p3, |
| final Object p4, final Object p5, final Object p6, |
| final Object p7) { |
| return isEnabled(level, marker, new ParameterizedMessage(message, p0, p1, p2, p3, p4, p5, p6, p7), null); |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0, |
| final Object p1, final Object p2, final Object p3, |
| final Object p4, final Object p5, final Object p6, |
| final Object p7, final Object p8) { |
| return isEnabled(level, marker, new ParameterizedMessage(message, p0, p1, p2, p3, p4, p5, p6, p7, p8), null); |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0, |
| final Object p1, final Object p2, final Object p3, |
| final Object p4, final Object p5, final Object p6, |
| final Object p7, final Object p8, final Object p9) { |
| return isEnabled(level, marker, new ParameterizedMessage(message, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9), |
| null); |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String data, final Throwable t) { |
| return isEnabled(level, marker, (Message) new SimpleMessage(data), t); |
| } |
| |
| @Override |
| public void logMessage(final String fqcn, final Level level, final Marker marker, final Message data, final Throwable t) { |
| assertTrue("Incorrect Level. Expected " + currentLevel + ", actual " + level, level.equals(currentLevel)); |
| if (marker == null) { |
| if (currentEvent.markerName != null) { |
| fail("Incorrect marker. Expected " + currentEvent.markerName + ", actual is null"); |
| } |
| } else { |
| if (currentEvent.markerName == null) { |
| fail("Incorrect marker. Expected null. Actual is " + marker.getName()); |
| } else { |
| assertTrue("Incorrect marker. Expected " + currentEvent.markerName + ", actual " + |
| marker.getName(), currentEvent.markerName.equals(marker.getName())); |
| } |
| } |
| if (data == null) { |
| if (currentEvent.data != null) { |
| fail("Incorrect message. Expected " + currentEvent.data + ", actual is null"); |
| } |
| } else { |
| if (currentEvent.data == null) { |
| fail("Incorrect message. Expected null. Actual is " + data.getFormattedMessage()); |
| } else { |
| assertTrue("Incorrect message type. Expected " + currentEvent.data + ", actual " + data, |
| data.getClass().isAssignableFrom(currentEvent.data.getClass())); |
| assertTrue("Incorrect message. Expected " + currentEvent.data.getFormattedMessage() + ", actual " + |
| data.getFormattedMessage(), |
| currentEvent.data.getFormattedMessage().equals(data.getFormattedMessage())); |
| } |
| } |
| if (t == null) { |
| if (currentEvent.t != null) { |
| fail("Incorrect Throwable. Expected " + currentEvent.t + ", actual is null"); |
| } |
| } else { |
| if (currentEvent.t == null) { |
| fail("Incorrect Throwable. Expected null. Actual is " + t); |
| } else { |
| assertTrue("Incorrect Throwable. Expected " + currentEvent.t + ", actual " + t, |
| currentEvent.t.equals(t)); |
| } |
| } |
| } |
| } |
| |
| private static class LogEvent { |
| String markerName; |
| Message data; |
| Throwable t; |
| |
| public LogEvent(final String markerName, final Message data, final Throwable t) { |
| this.markerName = markerName; |
| this.data = data; |
| this.t = t; |
| } |
| } |
| |
| private static class ThrowableExpectingLogger extends AbstractLogger { |
| private static final long serialVersionUID = -7218195998038685039L; |
| private final boolean expectingThrowables; |
| |
| ThrowableExpectingLogger(final boolean expectingThrowables) { |
| super("ThrowableExpectingLogger", ParameterizedMessageFactory.INSTANCE); |
| this.expectingThrowables = expectingThrowables; |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final Message message, final Throwable t) { |
| return true; |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final CharSequence message, final Throwable t) { |
| return true; |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final Object message, final Throwable t) { |
| return true; |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Throwable t) { |
| return true; |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message) { |
| return true; |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object... params) { |
| return true; |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0) { |
| return true; |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0, final Object p1) { |
| return true; |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0, final Object p1, final Object p2) { |
| return true; |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0, final Object p1, final Object p2, final Object p3) { |
| return true; |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0, final Object p1, final Object p2, final Object p3, final Object p4) { |
| return true; |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0, final Object p1, final Object p2, final Object p3, final Object p4, final Object p5) { |
| return true; |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0, final Object p1, final Object p2, final Object p3, final Object p4, final Object p5, final Object p6) { |
| return true; |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0, final Object p1, final Object p2, final Object p3, final Object p4, final Object p5, final Object p6, final Object p7) { |
| return true; |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0, final Object p1, final Object p2, final Object p3, final Object p4, final Object p5, final Object p6, final Object p7, final Object p8) { |
| return true; |
| } |
| |
| @Override |
| public boolean isEnabled(final Level level, final Marker marker, final String message, final Object p0, final Object p1, final Object p2, final Object p3, final Object p4, final Object p5, final Object p6, final Object p7, final Object p8, final Object p9) { |
| return true; |
| } |
| |
| @Override |
| public void logMessage(final String fqcn, final Level level, final Marker marker, final Message message, final Throwable t) { |
| if(expectingThrowables) { |
| assertNotNull("Expected a Throwable but received null!", t); |
| } else { |
| assertNull("Expected null but received a Throwable! "+t, t); |
| } |
| if (message != null) { |
| message.getFormattedMessage(); |
| } |
| } |
| |
| @Override |
| public Level getLevel() { |
| return Level.INFO; |
| } |
| } |
| |
| private static class ThrowableMessage implements Message { |
| /** |
| * |
| */ |
| private static final long serialVersionUID = 1L; |
| private final Throwable throwable; |
| |
| public ThrowableMessage(final Throwable throwable) { |
| this.throwable = throwable; |
| } |
| |
| @Override |
| public String getFormattedMessage() { |
| return null; |
| } |
| |
| @Override |
| public String getFormat() { |
| return null; |
| } |
| |
| @Override |
| public Object[] getParameters() { |
| return new Object[0]; |
| } |
| |
| @Override |
| public Throwable getThrowable() { |
| return throwable; |
| } |
| } |
| } |
