log in PatternLayout (%F:%L)%c.%M
Motivation: When Log4j2Logger is used with PatternLayout (%F:%L)%c.%M, the log message incorrect shows: (Log4J2Logger.java:73)io.netty.util.internal.PlatformDependent0.debug .... Modification: Extend AbstractLogger Result: Fixes [#7186].
This commit is contained in:
杨浩
Norman Maurer
parent
8c8779669e
commit
14189140a0
@ -15,166 +15,102 @@
|
|||||||
*/
|
*/
|
||||||
package io.netty.util.internal.logging;
|
package io.netty.util.internal.logging;
|
||||||
|
|
||||||
import org.apache.logging.log4j.Logger;
|
|
||||||
|
|
||||||
final class Log4J2Logger extends AbstractInternalLogger {
|
import org.apache.logging.log4j.Level;
|
||||||
|
import org.apache.logging.log4j.Logger;
|
||||||
|
import org.apache.logging.log4j.spi.ExtendedLogger;
|
||||||
|
import org.apache.logging.log4j.spi.ExtendedLoggerWrapper;
|
||||||
|
|
||||||
|
class Log4J2Logger extends ExtendedLoggerWrapper implements InternalLogger {
|
||||||
|
|
||||||
private static final long serialVersionUID = 5485418394879791397L;
|
private static final long serialVersionUID = 5485418394879791397L;
|
||||||
|
|
||||||
private final transient Logger logger;
|
/** {@linkplain AbstractInternalLogger#EXCEPTION_MESSAGE} */
|
||||||
|
private static final String EXCEPTION_MESSAGE = "Unexpected exception:";
|
||||||
|
|
||||||
Log4J2Logger(Logger logger) {
|
Log4J2Logger(Logger logger) {
|
||||||
super(logger.getName());
|
super((ExtendedLogger) logger, logger.getName(), logger.getMessageFactory());
|
||||||
this.logger = logger;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
@Override
|
||||||
public boolean isTraceEnabled() {
|
public String name() {
|
||||||
return logger.isTraceEnabled();
|
return getName();
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
@Override
|
||||||
public void trace(String msg) {
|
public void trace(Throwable t) {
|
||||||
logger.trace(msg);
|
log(Level.TRACE, EXCEPTION_MESSAGE, t);
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
@Override
|
||||||
public void trace(String format, Object arg) {
|
public void debug(Throwable t) {
|
||||||
logger.trace(format, arg);
|
log(Level.DEBUG, EXCEPTION_MESSAGE, t);
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
@Override
|
||||||
public void trace(String format, Object argA, Object argB) {
|
public void info(Throwable t) {
|
||||||
logger.trace(format, argA, argB);
|
log(Level.INFO, EXCEPTION_MESSAGE, t);
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
@Override
|
||||||
public void trace(String format, Object... arguments) {
|
public void warn(Throwable t) {
|
||||||
logger.trace(format, arguments);
|
log(Level.WARN, EXCEPTION_MESSAGE, t);
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
@Override
|
||||||
public void trace(String msg, Throwable t) {
|
public void error(Throwable t) {
|
||||||
logger.trace(msg, t);
|
log(Level.ERROR, EXCEPTION_MESSAGE, t);
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
@Override
|
||||||
public boolean isDebugEnabled() {
|
public boolean isEnabled(InternalLogLevel level) {
|
||||||
return logger.isDebugEnabled();
|
return isEnabled(toLevel(level));
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
@Override
|
||||||
public void debug(String msg) {
|
public void log(InternalLogLevel level, String msg) {
|
||||||
logger.debug(msg);
|
log(toLevel(level), msg);
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
@Override
|
||||||
public void debug(String format, Object arg) {
|
public void log(InternalLogLevel level, String format, Object arg) {
|
||||||
logger.debug(format, arg);
|
log(toLevel(level), format, arg);
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
@Override
|
||||||
public void debug(String format, Object argA, Object argB) {
|
public void log(InternalLogLevel level, String format, Object argA, Object argB) {
|
||||||
logger.debug(format, argA, argB);
|
log(toLevel(level), format, argA, argB);
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
@Override
|
||||||
public void debug(String format, Object... arguments) {
|
public void log(InternalLogLevel level, String format, Object... arguments) {
|
||||||
logger.debug(format, arguments);
|
log(toLevel(level), format, arguments);
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
@Override
|
||||||
public void debug(String msg, Throwable t) {
|
public void log(InternalLogLevel level, String msg, Throwable t) {
|
||||||
logger.debug(msg, t);
|
log(toLevel(level), msg, t);
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
@Override
|
||||||
public boolean isInfoEnabled() {
|
public void log(InternalLogLevel level, Throwable t) {
|
||||||
return logger.isInfoEnabled();
|
log(toLevel(level), EXCEPTION_MESSAGE, t);
|
||||||
}
|
}
|
||||||
|
|
||||||
@Override
|
protected Level toLevel(InternalLogLevel level) {
|
||||||
public void info(String msg) {
|
switch (level) {
|
||||||
logger.info(msg);
|
case INFO:
|
||||||
}
|
return Level.INFO;
|
||||||
|
case DEBUG:
|
||||||
@Override
|
return Level.DEBUG;
|
||||||
public void info(String format, Object arg) {
|
case WARN:
|
||||||
logger.info(format, arg);
|
return Level.WARN;
|
||||||
}
|
case ERROR:
|
||||||
|
return Level.ERROR;
|
||||||
@Override
|
case TRACE:
|
||||||
public void info(String format, Object argA, Object argB) {
|
return Level.TRACE;
|
||||||
logger.info(format, argA, argB);
|
default:
|
||||||
}
|
throw new Error();
|
||||||
|
}
|
||||||
@Override
|
|
||||||
public void info(String format, Object... arguments) {
|
|
||||||
logger.info(format, arguments);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void info(String msg, Throwable t) {
|
|
||||||
logger.info(msg, t);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public boolean isWarnEnabled() {
|
|
||||||
return logger.isWarnEnabled();
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void warn(String msg) {
|
|
||||||
logger.warn(msg);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void warn(String format, Object arg) {
|
|
||||||
logger.warn(format, arg);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void warn(String format, Object... arguments) {
|
|
||||||
logger.warn(format, arguments);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void warn(String format, Object argA, Object argB) {
|
|
||||||
logger.warn(format, argA, argB);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void warn(String msg, Throwable t) {
|
|
||||||
logger.warn(msg, t);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public boolean isErrorEnabled() {
|
|
||||||
return logger.isErrorEnabled();
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void error(String msg) {
|
|
||||||
logger.error(msg);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void error(String format, Object arg) {
|
|
||||||
logger.error(format, arg);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void error(String format, Object argA, Object argB) {
|
|
||||||
logger.error(format, argA, argB);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void error(String format, Object... arguments) {
|
|
||||||
logger.error(format, arguments);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Override
|
|
||||||
public void error(String msg, Throwable t) {
|
|
||||||
logger.error(msg, t);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@ -0,0 +1,150 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2017 The Netty Project
|
||||||
|
*
|
||||||
|
* The Netty Project 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 io.netty.util.internal.logging;
|
||||||
|
|
||||||
|
import static org.junit.Assert.assertEquals;
|
||||||
|
import static org.junit.Assert.assertFalse;
|
||||||
|
import static org.junit.Assert.assertTrue;
|
||||||
|
|
||||||
|
import java.lang.reflect.Method;
|
||||||
|
import java.util.HashMap;
|
||||||
|
import java.util.Map;
|
||||||
|
|
||||||
|
import org.junit.Test;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* We only need to test methods defined by {@link InternaLogger}.
|
||||||
|
*/
|
||||||
|
public abstract class AbstractInternalLoggerTest<T> {
|
||||||
|
protected String loggerName = "foo";
|
||||||
|
protected T mockLog;
|
||||||
|
protected InternalLogger logger;
|
||||||
|
protected final Map<String, Object> result = new HashMap<String, Object>();
|
||||||
|
|
||||||
|
@SuppressWarnings("unchecked")
|
||||||
|
protected <V> V getResult(String key) {
|
||||||
|
return (V) result.get(key);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
public void testName() {
|
||||||
|
assertEquals(loggerName, logger.name());
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
public void testAllLevel() throws Exception {
|
||||||
|
testLevel(InternalLogLevel.TRACE);
|
||||||
|
testLevel(InternalLogLevel.DEBUG);
|
||||||
|
testLevel(InternalLogLevel.INFO);
|
||||||
|
testLevel(InternalLogLevel.WARN);
|
||||||
|
testLevel(InternalLogLevel.ERROR);
|
||||||
|
}
|
||||||
|
|
||||||
|
protected void testLevel(InternalLogLevel level) throws Exception {
|
||||||
|
result.clear();
|
||||||
|
|
||||||
|
String format1 = "a={}", format2 = "a={}, b= {}", format3 = "a={}, b= {}, c= {}";
|
||||||
|
String msg = "a test message from Junit";
|
||||||
|
Exception ex = new Exception("a test Exception from Junit");
|
||||||
|
|
||||||
|
Class<InternalLogger> clazz = InternalLogger.class;
|
||||||
|
String levelName = level.name(), logMethod = levelName.toLowerCase();
|
||||||
|
Method isXXEnabled = clazz
|
||||||
|
.getMethod("is" + levelName.charAt(0) + levelName.substring(1).toLowerCase() + "Enabled");
|
||||||
|
|
||||||
|
// when level log is disabled
|
||||||
|
setLevelEnable(level, false);
|
||||||
|
assertFalse((Boolean) isXXEnabled.invoke(logger));
|
||||||
|
|
||||||
|
// test xx(msg)
|
||||||
|
clazz.getMethod(logMethod, String.class).invoke(logger, msg);
|
||||||
|
assertTrue(result.isEmpty());
|
||||||
|
|
||||||
|
// test xx(format, arg)
|
||||||
|
clazz.getMethod(logMethod, String.class, Object.class).invoke(logger, format1, msg);
|
||||||
|
assertTrue(result.isEmpty());
|
||||||
|
|
||||||
|
// test xx(format, argA, argB)
|
||||||
|
clazz.getMethod(logMethod, String.class, Object.class, Object.class).invoke(logger, format2, msg, msg);
|
||||||
|
assertTrue(result.isEmpty());
|
||||||
|
|
||||||
|
// test xx(format, ...arguments)
|
||||||
|
clazz.getMethod(logMethod, String.class, Object[].class).invoke(logger, format3,
|
||||||
|
new Object[] { msg, msg, msg });
|
||||||
|
assertTrue(result.isEmpty());
|
||||||
|
|
||||||
|
// test xx(format, ...arguments), the last argument is Throwable
|
||||||
|
clazz.getMethod(logMethod, String.class, Object[].class).invoke(logger, format3,
|
||||||
|
new Object[] { msg, msg, msg, ex });
|
||||||
|
assertTrue(result.isEmpty());
|
||||||
|
|
||||||
|
// test xx(msg, Throwable)
|
||||||
|
clazz.getMethod(logMethod, String.class, Throwable.class).invoke(logger, msg, ex);
|
||||||
|
assertTrue(result.isEmpty());
|
||||||
|
|
||||||
|
// test xx(Throwable)
|
||||||
|
clazz.getMethod(logMethod, Throwable.class).invoke(logger, ex);
|
||||||
|
assertTrue(result.isEmpty());
|
||||||
|
|
||||||
|
// when level log is enabled
|
||||||
|
setLevelEnable(level, true);
|
||||||
|
assertTrue((Boolean) isXXEnabled.invoke(logger));
|
||||||
|
|
||||||
|
// test xx(msg)
|
||||||
|
result.clear();
|
||||||
|
clazz.getMethod(logMethod, String.class).invoke(logger, msg);
|
||||||
|
assertResult(level, null, null, msg);
|
||||||
|
|
||||||
|
// test xx(format, arg)
|
||||||
|
result.clear();
|
||||||
|
clazz.getMethod(logMethod, String.class, Object.class).invoke(logger, format1, msg);
|
||||||
|
assertResult(level, format1, null, msg);
|
||||||
|
|
||||||
|
// test xx(format, argA, argB)
|
||||||
|
result.clear();
|
||||||
|
clazz.getMethod(logMethod, String.class, Object.class, Object.class).invoke(logger, format2, msg, msg);
|
||||||
|
assertResult(level, format2, null, msg, msg);
|
||||||
|
|
||||||
|
// test xx(format, ...arguments)
|
||||||
|
result.clear();
|
||||||
|
clazz.getMethod(logMethod, String.class, Object[].class).invoke(logger, format3,
|
||||||
|
new Object[] { msg, msg, msg });
|
||||||
|
assertResult(level, format3, null, msg, msg, msg);
|
||||||
|
|
||||||
|
// test xx(format, ...arguments), the last argument is Throwable
|
||||||
|
result.clear();
|
||||||
|
clazz.getMethod(logMethod, String.class, Object[].class).invoke(logger, format3,
|
||||||
|
new Object[] { msg, msg, msg, ex });
|
||||||
|
assertResult(level, format3, ex, msg, msg, msg, ex);
|
||||||
|
|
||||||
|
// test xx(msg, Throwable)
|
||||||
|
result.clear();
|
||||||
|
clazz.getMethod(logMethod, String.class, Throwable.class).invoke(logger, msg, ex);
|
||||||
|
assertResult(level, null, ex, msg);
|
||||||
|
|
||||||
|
// test xx(Throwable)
|
||||||
|
result.clear();
|
||||||
|
clazz.getMethod(logMethod, Throwable.class).invoke(logger, ex);
|
||||||
|
assertResult(level, null, ex);
|
||||||
|
}
|
||||||
|
|
||||||
|
/** a just default code, you can override to fix {@linkplain #mockLog} */
|
||||||
|
protected void assertResult(InternalLogLevel level, String format, Throwable t, Object... args) {
|
||||||
|
assertFalse(result.isEmpty());
|
||||||
|
}
|
||||||
|
|
||||||
|
protected abstract void setLevelEnable(InternalLogLevel level, boolean enable) throws Exception;
|
||||||
|
}
|
||||||
@ -15,211 +15,87 @@
|
|||||||
*/
|
*/
|
||||||
package io.netty.util.internal.logging;
|
package io.netty.util.internal.logging;
|
||||||
|
|
||||||
import org.junit.Test;
|
import static org.junit.Assert.assertEquals;
|
||||||
|
|
||||||
|
import java.lang.reflect.Field;
|
||||||
|
import java.lang.reflect.Method;
|
||||||
|
import java.util.Arrays;
|
||||||
|
|
||||||
|
import org.apache.logging.log4j.Level;
|
||||||
|
import org.apache.logging.log4j.LogManager;
|
||||||
import org.apache.logging.log4j.Logger;
|
import org.apache.logging.log4j.Logger;
|
||||||
|
import org.apache.logging.log4j.Marker;
|
||||||
|
import org.apache.logging.log4j.message.Message;
|
||||||
|
import org.apache.logging.log4j.spi.ExtendedLoggerWrapper;
|
||||||
|
import org.hamcrest.CoreMatchers;
|
||||||
|
import org.junit.Assume;
|
||||||
|
import org.junit.Test;
|
||||||
|
|
||||||
import static org.junit.Assert.assertTrue;
|
import io.netty.util.internal.ReflectionUtil;
|
||||||
import static org.mockito.Mockito.*;
|
|
||||||
|
|
||||||
public class Log4J2LoggerTest {
|
/**
|
||||||
private static final Exception e = new Exception();
|
* {@linkplain Log4J2Logger} extends {@linkplain ExtendedLoggerWrapper} implements {@linkplain InternalLogger}.<br>
|
||||||
|
* {@linkplain ExtendedLoggerWrapper} is Log4j2 wrapper class to support wrapped loggers,
|
||||||
|
* so There is no need to test it's method.<br>
|
||||||
|
* We only need to test the netty's {@linkplain InternalLogger} interface method.<br>
|
||||||
|
* It's meaning that we only need to test the Override method in the {@linkplain Log4J2Logger}.
|
||||||
|
*/
|
||||||
|
public class Log4J2LoggerTest extends AbstractInternalLoggerTest<Logger> {
|
||||||
|
|
||||||
@Test
|
{
|
||||||
public void testIsTraceEnabled() {
|
mockLog = LogManager.getLogger(loggerName);
|
||||||
Logger mock = mock(Logger.class);
|
logger = new Log4J2Logger(mockLog) {
|
||||||
|
private static final long serialVersionUID = 1L;
|
||||||
|
|
||||||
when(mock.getName()).thenReturn("foo");
|
@Override
|
||||||
when(mock.isTraceEnabled()).thenReturn(true);
|
public void logMessage(String fqcn, Level level, Marker marker, Message message, Throwable t) {
|
||||||
InternalLogger logger = new Log4J2Logger(mock);
|
result.put("level", level.name());
|
||||||
assertTrue(logger.isTraceEnabled());
|
result.put("t", t);
|
||||||
|
super.logMessage(fqcn, level, marker, message, t);
|
||||||
verify(mock).getName();
|
};
|
||||||
verify(mock).isTraceEnabled();
|
};
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
public void testIsDebugEnabled() {
|
public void testEXCEPTION_MESSAGE() {
|
||||||
Logger mock = mock(Logger.class);
|
assertEquals(getFieldValue(AbstractInternalLogger.class, "EXCEPTION_MESSAGE"),
|
||||||
|
getFieldValue(Log4J2Logger.class, "EXCEPTION_MESSAGE"));
|
||||||
when(mock.getName()).thenReturn("foo");
|
|
||||||
when(mock.isDebugEnabled()).thenReturn(true);
|
|
||||||
|
|
||||||
InternalLogger logger = new Log4J2Logger(mock);
|
|
||||||
assertTrue(logger.isDebugEnabled());
|
|
||||||
|
|
||||||
verify(mock).getName();
|
|
||||||
verify(mock).isDebugEnabled();
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@SuppressWarnings("unchecked")
|
||||||
public void testIsInfoEnabled() {
|
private static <T> T getFieldValue(Class<?> clazz, String fieldName) {
|
||||||
Logger mock = mock(Logger.class);
|
try {
|
||||||
|
Field field = clazz.getDeclaredField(fieldName);
|
||||||
when(mock.getName()).thenReturn("foo");
|
if (!field.isAccessible()) {
|
||||||
when(mock.isInfoEnabled()).thenReturn(true);
|
Assume.assumeThat(ReflectionUtil.trySetAccessible(field), CoreMatchers.nullValue());
|
||||||
|
}
|
||||||
InternalLogger logger = new Log4J2Logger(mock);
|
return (T) field.get(AbstractInternalLogger.class);
|
||||||
assertTrue(logger.isInfoEnabled());
|
} catch (ReflectiveOperationException e) {
|
||||||
|
throw new IllegalStateException(e);
|
||||||
verify(mock).getName();
|
}
|
||||||
verify(mock).isInfoEnabled();
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Override
|
||||||
public void testIsWarnEnabled() {
|
protected void setLevelEnable(InternalLogLevel level, boolean enable) throws Exception {
|
||||||
Logger mock = mock(Logger.class);
|
Level targetLevel = Level.valueOf(level.name());
|
||||||
|
if (!enable) {
|
||||||
|
Level[] levels = Level.values();
|
||||||
|
Arrays.sort(levels);
|
||||||
|
int pos = Arrays.binarySearch(levels, targetLevel);
|
||||||
|
targetLevel = levels[pos - 1];
|
||||||
|
}
|
||||||
|
|
||||||
when(mock.getName()).thenReturn("foo");
|
Method method = mockLog.getClass().getDeclaredMethod("setLevel", Level.class);
|
||||||
when(mock.isWarnEnabled()).thenReturn(true);
|
if (!method.isAccessible()) {
|
||||||
|
Assume.assumeThat(ReflectionUtil.trySetAccessible(method), CoreMatchers.nullValue());
|
||||||
InternalLogger logger = new Log4J2Logger(mock);
|
}
|
||||||
assertTrue(logger.isWarnEnabled());
|
method.invoke(mockLog, targetLevel);
|
||||||
|
|
||||||
verify(mock).getName();
|
|
||||||
verify(mock).isWarnEnabled();
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Override
|
||||||
public void testIsErrorEnabled() {
|
protected void assertResult(InternalLogLevel level, String format, Throwable t, Object... args) {
|
||||||
Logger mock = mock(Logger.class);
|
super.assertResult(level, format, t, args);
|
||||||
|
assertEquals(t, result.get("t"));
|
||||||
when(mock.getName()).thenReturn("foo");
|
assertEquals(level.name(), result.get("level"));
|
||||||
when(mock.isErrorEnabled()).thenReturn(true);
|
|
||||||
|
|
||||||
InternalLogger logger = new Log4J2Logger(mock);
|
|
||||||
assertTrue(logger.isErrorEnabled());
|
|
||||||
|
|
||||||
verify(mock).getName();
|
|
||||||
verify(mock).isErrorEnabled();
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
public void testTrace() {
|
|
||||||
Logger mock = mock(Logger.class);
|
|
||||||
|
|
||||||
when(mock.getName()).thenReturn("foo");
|
|
||||||
|
|
||||||
InternalLogger logger = new Log4J2Logger(mock);
|
|
||||||
logger.trace("a");
|
|
||||||
|
|
||||||
verify(mock).getName();
|
|
||||||
verify(mock).trace("a");
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
public void testTraceWithException() {
|
|
||||||
Logger mock = mock(Logger.class);
|
|
||||||
|
|
||||||
when(mock.getName()).thenReturn("foo");
|
|
||||||
|
|
||||||
InternalLogger logger = new Log4J2Logger(mock);
|
|
||||||
logger.trace("a", e);
|
|
||||||
|
|
||||||
verify(mock).getName();
|
|
||||||
verify(mock).trace("a", e);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
public void testDebug() {
|
|
||||||
Logger mock = mock(Logger.class);
|
|
||||||
|
|
||||||
when(mock.getName()).thenReturn("foo");
|
|
||||||
|
|
||||||
InternalLogger logger = new Log4J2Logger(mock);
|
|
||||||
logger.debug("a");
|
|
||||||
|
|
||||||
verify(mock).getName();
|
|
||||||
verify(mock).debug("a");
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
public void testDebugWithException() {
|
|
||||||
Logger mock = mock(Logger.class);
|
|
||||||
|
|
||||||
when(mock.getName()).thenReturn("foo");
|
|
||||||
|
|
||||||
InternalLogger logger = new Log4J2Logger(mock);
|
|
||||||
logger.debug("a", e);
|
|
||||||
|
|
||||||
verify(mock).getName();
|
|
||||||
verify(mock).debug("a", e);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
public void testInfo() {
|
|
||||||
Logger mock = mock(Logger.class);
|
|
||||||
|
|
||||||
when(mock.getName()).thenReturn("foo");
|
|
||||||
|
|
||||||
InternalLogger logger = new Log4J2Logger(mock);
|
|
||||||
logger.info("a");
|
|
||||||
|
|
||||||
verify(mock).getName();
|
|
||||||
verify(mock).info("a");
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
public void testInfoWithException() {
|
|
||||||
Logger mock = mock(Logger.class);
|
|
||||||
|
|
||||||
when(mock.getName()).thenReturn("foo");
|
|
||||||
|
|
||||||
InternalLogger logger = new Log4J2Logger(mock);
|
|
||||||
logger.info("a", e);
|
|
||||||
|
|
||||||
verify(mock).getName();
|
|
||||||
verify(mock).info("a", e);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
public void testWarn() {
|
|
||||||
Logger mock = mock(Logger.class);
|
|
||||||
|
|
||||||
when(mock.getName()).thenReturn("foo");
|
|
||||||
|
|
||||||
InternalLogger logger = new Log4J2Logger(mock);
|
|
||||||
logger.warn("a");
|
|
||||||
|
|
||||||
verify(mock).getName();
|
|
||||||
verify(mock).warn("a");
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
public void testWarnWithException() {
|
|
||||||
Logger mock = mock(Logger.class);
|
|
||||||
|
|
||||||
when(mock.getName()).thenReturn("foo");
|
|
||||||
|
|
||||||
InternalLogger logger = new Log4J2Logger(mock);
|
|
||||||
logger.warn("a", e);
|
|
||||||
|
|
||||||
verify(mock).getName();
|
|
||||||
verify(mock).warn("a", e);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
public void testError() {
|
|
||||||
Logger mock = mock(Logger.class);
|
|
||||||
|
|
||||||
when(mock.getName()).thenReturn("foo");
|
|
||||||
|
|
||||||
InternalLogger logger = new Log4J2Logger(mock);
|
|
||||||
logger.error("a");
|
|
||||||
|
|
||||||
verify(mock).getName();
|
|
||||||
verify(mock).error("a");
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
public void testErrorWithException() {
|
|
||||||
Logger mock = mock(Logger.class);
|
|
||||||
|
|
||||||
when(mock.getName()).thenReturn("foo");
|
|
||||||
|
|
||||||
InternalLogger logger = new Log4J2Logger(mock);
|
|
||||||
logger.error("a", e);
|
|
||||||
|
|
||||||
verify(mock).getName();
|
|
||||||
verify(mock).error("a", e);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
Loading…
Reference in New Issue
Block a user