1
2
3
4
5
6
7
8
9
10 package ch.qos.logback.classic;
11
12 import static org.junit.Assert.assertEquals;
13 import static org.junit.Assert.assertFalse;
14 import static org.junit.Assert.assertNotNull;
15 import static org.junit.Assert.assertTrue;
16 import static org.junit.Assert.fail;
17
18 import java.util.List;
19
20 import org.junit.Test;
21 import org.slf4j.LoggerFactory;
22
23 import ch.qos.logback.classic.spi.LoggingEvent;
24 import ch.qos.logback.core.read.ListAppender;
25 import ch.qos.logback.core.status.Status;
26
27 public class LoggerTest {
28
29 LoggerContext lc = new LoggerContext();
30 Logger root = lc.getLogger(LoggerContext.ROOT_NAME);
31 Logger loggerTest = lc.getLogger(LoggerTest.class);
32
33 ListAppender<LoggingEvent> listAppender = new ListAppender<LoggingEvent>();
34
35 @Test
36 public void smoke() {
37 ListAppender<LoggingEvent> listAppender = new ListAppender<LoggingEvent>();
38 listAppender.start();
39 root.addAppender(listAppender);
40 Logger logger = lc.getLogger(LoggerTest.class);
41 assertEquals(0, listAppender.list.size());
42 logger.debug("hello");
43 assertEquals(1, listAppender.list.size());
44 }
45
46 @Test
47 public void testNoStart() {
48
49 listAppender.setContext(lc);
50 root.addAppender(listAppender);
51 Logger logger = lc.getLogger(LoggerTest.class);
52 logger.debug("hello");
53
54 List<Status> statusList = lc.getStatusManager().getCopyOfStatusList();
55 Status s0 = statusList.get(0);
56 assertEquals(Status.WARN, s0.getLevel());
57 assertTrue(s0.getMessage().startsWith("Attempted to append to non started"));
58 }
59
60 @Test
61 public void testAdditive() {
62 listAppender.start();
63 root.addAppender(listAppender);
64 loggerTest.addAppender(listAppender);
65 loggerTest.setAdditive(false);
66 loggerTest.debug("hello");
67
68 assertEquals(1, listAppender.list.size());
69 }
70
71 @Test
72 public void testRootLogger() {
73 Logger logger = (Logger) LoggerFactory.getLogger(LoggerContext.ROOT_NAME);
74 LoggerContext lc = logger.getLoggerContext();
75
76 assertNotNull("Returned logger is null", logger);
77 assertEquals("Return logger isn't named root", logger.getName(),
78 LoggerContext.ROOT_NAME);
79 assertTrue("logger instances should be indentical", logger == lc.root);
80 }
81
82 @Test
83 public void testBasicFiltering() throws Exception {
84 listAppender.start();
85 root.addAppender(listAppender);
86 root.setLevel(Level.INFO);
87 loggerTest.debug("x");
88 assertEquals(0, listAppender.list.size());
89 loggerTest.info("x");
90 loggerTest.warn("x");
91 loggerTest.error("x");
92 assertEquals(3, listAppender.list.size());
93 }
94
95 void checkLevelThreshold(Logger logger, Level threshold) {
96
97 if (Level.ERROR_INT >= threshold.levelInt) {
98 assertTrue(logger.isErrorEnabled());
99 assertTrue(logger.isEnabledFor(Level.ERROR));
100 } else {
101 assertFalse(logger.isErrorEnabled());
102 assertFalse(logger.isEnabledFor(Level.ERROR));
103 }
104
105 if (Level.WARN_INT >= threshold.levelInt) {
106 assertTrue(logger.isWarnEnabled());
107 assertTrue(logger.isEnabledFor(Level.WARN));
108 } else {
109 assertFalse(logger.isWarnEnabled());
110 assertFalse(logger.isEnabledFor(Level.WARN));
111 }
112 if (Level.INFO_INT >= threshold.levelInt) {
113 assertTrue(logger.isInfoEnabled());
114 assertTrue(logger.isEnabledFor(Level.INFO));
115 } else {
116 assertFalse(logger.isInfoEnabled());
117 assertFalse(logger.isEnabledFor(Level.INFO));
118 }
119 if (Level.DEBUG_INT >= threshold.levelInt) {
120 assertTrue(logger.isDebugEnabled());
121 assertTrue(logger.isEnabledFor(Level.DEBUG));
122 } else {
123 assertFalse(logger.isDebugEnabled());
124 assertFalse(logger.isEnabledFor(Level.DEBUG));
125 }
126 if (Level.TRACE_INT >= threshold.levelInt) {
127 assertTrue(logger.isTraceEnabled());
128 assertTrue(logger.isEnabledFor(Level.TRACE));
129 } else {
130 assertFalse(logger.isTraceEnabled());
131 assertFalse(logger.isEnabledFor(Level.TRACE));
132 }
133
134 }
135
136 @Test
137 public void testEnabled_All() throws Exception {
138 root.setLevel(Level.ALL);
139 checkLevelThreshold(loggerTest, Level.ALL);
140 }
141
142 @Test
143 public void testEnabled_Debug() throws Exception {
144 root.setLevel(Level.DEBUG);
145 checkLevelThreshold(loggerTest, Level.DEBUG);
146 }
147
148 @Test
149 public void testEnabled_Info() throws Exception {
150 root.setLevel(Level.INFO);
151 checkLevelThreshold(loggerTest, Level.INFO);
152 }
153
154 @Test
155 public void testEnabledX_Warn() throws Exception {
156 root.setLevel(Level.WARN);
157 checkLevelThreshold(loggerTest, Level.WARN);
158 }
159
160 public void testEnabledX_Errror() throws Exception {
161 root.setLevel(Level.ERROR);
162 checkLevelThreshold(loggerTest, Level.ERROR);
163 }
164
165 @Test
166 public void testEnabledX_Off() throws Exception {
167 root.setLevel(Level.OFF);
168 checkLevelThreshold(loggerTest, Level.OFF);
169 }
170
171 @Test
172 public void setRootLevelToNull() {
173 try {
174 root.setLevel(null);
175 fail("The level of the root logger should not be settable to null");
176 } catch (IllegalArgumentException e) {
177 }
178 }
179
180 @Test
181 public void setLevelToNull_A() {
182 loggerTest.setLevel(null);
183 assertEquals(root.getEffectiveLevel(), loggerTest.getEffectiveLevel());
184 }
185
186 @Test
187 public void setLevelToNull_B() {
188 loggerTest.setLevel(Level.DEBUG);
189 loggerTest.setLevel(null);
190 assertEquals(root.getEffectiveLevel(), loggerTest.getEffectiveLevel());
191 }
192
193 @Test
194 public void setLevelToNull_LBCLASSIC_91() {
195 loggerTest.setLevel(Level.DEBUG);
196 ch.qos.logback.classic.Logger child = lc.getLogger(loggerTest.getName() + ".child");
197 loggerTest.setLevel(null);
198 assertEquals(root.getEffectiveLevel(), loggerTest.getEffectiveLevel());
199 assertEquals(root.getEffectiveLevel(), child.getEffectiveLevel());
200 }
201
202 }