1   /**
2    * Logback: the generic, reliable, fast and flexible logging framework.
3    * 
4    * Copyright (C) 1999-2006, QOS.ch
5    * 
6    * This library is free software, you can redistribute it and/or modify it under
7    * the terms of the GNU Lesser General Public License as published by the Free
8    * Software Foundation.
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      // listAppender.start();
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      // 1 instead of two, since logger is not additive
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 }