001package org.slf4j.event;
002
003import org.junit.After;
004import org.junit.Before;
005import org.junit.Test;
006import org.slf4j.Marker;
007import org.slf4j.helpers.BasicMarkerFactory;
008import org.slf4j.helpers.SubstituteLogger;
009
010import java.util.Queue;
011import java.util.concurrent.LinkedBlockingQueue;
012
013import static org.junit.Assert.*;
014
015public class EventRecodingLoggerTest {
016    private Queue<SubstituteLoggingEvent> queue;
017    private EventRecodingLogger logger;
018    private String message;
019    private Object param1;
020    private Object param2;
021    private Object param3;
022    private Object[] oneParam;
023    private Object[] twoParams;
024    private Object[] threeParams;
025    private Throwable exception;
026    private Marker marker;
027
028    @Before
029    public void setUp() {
030        queue = new LinkedBlockingQueue<>();
031        logger = new EventRecodingLogger(new SubstituteLogger("testLogger", queue, true), queue);
032        message = "Test message with 3 parameters {} {} {} {}";
033        param1 = 1;
034        param2 = 2;
035        param3 = 3;
036        oneParam = new Object[] { param1 };
037        twoParams = new Object[] { param1, param2 };
038        threeParams = new Object[] { param1, param2, param3 };
039        exception = new IllegalStateException("We just need an exception");
040        marker = new BasicMarkerFactory().getMarker("testMarker");
041    }
042
043    @After
044    public void tearDown() {
045        assertTrue(queue.isEmpty());
046    }
047
048    @Test
049    public void singleMessage() {
050        for (Level level : Level.values()) {
051            singleMessageCheck(level);
052        }
053    }
054
055    private void singleMessageCheck(Level level) {
056        switch (level) {
057        case TRACE:
058            logger.trace(message);
059            break;
060        case DEBUG:
061            logger.debug(message);
062            break;
063        case INFO:
064            logger.info(message);
065            break;
066        case WARN:
067            logger.warn(message);
068            break;
069        case ERROR:
070            logger.error(message);
071            break;
072        }
073        verifyMessageWithoutMarker(level, null, null);
074    }
075
076    @Test
077    public void oneParameter() {
078        for (Level level : Level.values()) {
079            oneParameterCheck(level);
080        }
081    }
082
083    private void oneParameterCheck(Level level) {
084        switch (level) {
085        case TRACE:
086            logger.trace(message, param1);
087            break;
088        case DEBUG:
089            logger.debug(message, param1);
090            break;
091        case INFO:
092            logger.info(message, param1);
093            break;
094        case WARN:
095            logger.warn(message, param1);
096            break;
097        case ERROR:
098            logger.error(message, param1);
099            break;
100        }
101        verifyMessageWithoutMarker(level, oneParam, null);
102    }
103
104    @Test
105    public void messageTwoParameters() {
106        for (Level level : Level.values()) {
107            messageTwoParametersCheck(level);
108        }
109    }
110
111    private void messageTwoParametersCheck(Level level) {
112        switch (level) {
113        case TRACE:
114            logger.trace(message, param1, param2);
115            break;
116        case DEBUG:
117            logger.debug(message, param1, param2);
118            break;
119        case INFO:
120            logger.info(message, param1, param2);
121            break;
122        case WARN:
123            logger.warn(message, param1, param2);
124            break;
125        case ERROR:
126            logger.error(message, param1, param2);
127            break;
128        }
129        verifyMessageWithoutMarker(level, twoParams, null);
130    }
131
132    @Test
133    public void traceMessageThreeParameters() {
134        for (Level level : Level.values()) {
135            threeParameterCheck(level);
136        }
137    }
138
139    private void threeParameterCheck(Level level) {
140        switch (level) {
141        case TRACE:
142            logger.trace(message, param1, param2, param3);
143            break;
144        case DEBUG:
145            logger.debug(message, param1, param2, param3);
146            break;
147        case INFO:
148            logger.info(message, param1, param2, param3);
149            break;
150        case WARN:
151            logger.warn(message, param1, param2, param3);
152            break;
153        case ERROR:
154            logger.error(message, param1, param2, param3);
155            break;
156        }
157        verifyMessageWithoutMarker(level, threeParams, null);
158    }
159
160    @Test
161    public void testMessageThrowable() {
162        for (Level level : Level.values()) {
163            throwableCheck(level);
164        }
165    }
166
167    private void throwableCheck(Level level) {
168        switch (level) {
169        case TRACE:
170            logger.trace(message, exception);
171            break;
172        case DEBUG:
173            logger.debug(message, exception);
174            break;
175        case INFO:
176            logger.info(message, exception);
177            break;
178        case WARN:
179            logger.warn(message, exception);
180            break;
181        case ERROR:
182            logger.error(message, exception);
183            break;
184        }
185        verifyMessageWithoutMarker(level, null, exception);
186    }
187
188    @Test
189    public void traceMessageOneParameterThrowable() {
190        for (Level level : Level.values()) {
191            oneParamThrowableCheck(level);
192        }
193    }
194
195    private void oneParamThrowableCheck(Level level) {
196        switch (level) {
197        case TRACE:
198            logger.trace(message, param1, exception);
199            break;
200        case DEBUG:
201            logger.debug(message, param1, exception);
202            break;
203        case INFO:
204            logger.info(message, param1, exception);
205            break;
206        case WARN:
207            logger.warn(message, param1, exception);
208            break;
209        case ERROR:
210            logger.error(message, param1, exception);
211            break;
212        }
213        verifyMessageWithoutMarker(level, oneParam, exception);
214    }
215
216    @Test
217    public void traceMessageTwoParametersThrowable() {
218        for (Level level : Level.values()) {
219            twoParamThrowableCheck(level);
220        }
221    }
222
223    private void twoParamThrowableCheck(Level level) {
224        switch (level) {
225        case TRACE:
226            logger.trace(message, param1, param2, exception);
227            break;
228        case DEBUG:
229            logger.debug(message, param1, param2, exception);
230            break;
231        case INFO:
232            logger.info(message, param1, param2, exception);
233            break;
234        case WARN:
235            logger.warn(message, param1, param2, exception);
236            break;
237        case ERROR:
238            logger.error(message, param1, param2, exception);
239            break;
240        }
241        verifyMessageWithoutMarker(level, twoParams, exception);
242    }
243
244    @Test
245    public void testMessageThreeParametersThrowable() {
246        for (Level level : Level.values()) {
247            messageWith3ArgsPlusException(level);
248        }
249    }
250
251    private void messageWith3ArgsPlusException(Level level) {
252        switch (level) {
253        case TRACE:
254            logger.trace(message, param1, param2, param3, exception);
255            break;
256        case DEBUG:
257            logger.debug(message, param1, param2, param3, exception);
258            break;
259        case INFO:
260            logger.info(message, param1, param2, param3, exception);
261            break;
262        case WARN:
263            logger.warn(message, param1, param2, param3, exception);
264            break;
265        case ERROR:
266            logger.error(message, param1, param2, param3, exception);
267            break;
268        }
269        verifyMessageWithoutMarker(level, threeParams, exception);
270    }
271
272    @Test
273    public void markerMessage() {
274        for (Level level : Level.values()) {
275            markerMessageCheck(level);
276        }
277    }
278
279    private void markerMessageCheck(Level level) {
280        switch (level) {
281        case TRACE:
282            logger.trace(marker, message);
283            break;
284        case DEBUG:
285            logger.debug(marker, message);
286            break;
287        case INFO:
288            logger.info(marker, message);
289            break;
290        case WARN:
291            logger.warn(marker, message);
292            break;
293        case ERROR:
294            logger.error(marker, message);
295            break;
296        }
297        verifyMessage(level, marker, null, null);
298    }
299
300    @Test
301    public void markerMessageOneParameter() {
302        for (Level level : Level.values()) {
303            markerMessageOneParameter(level);
304        }
305    }
306
307    private void markerMessageOneParameter(Level level) {
308        switch (level) {
309        case TRACE:
310            logger.trace(marker, message, param1);
311            break;
312        case DEBUG:
313            logger.debug(marker, message, param1);
314            break;
315        case INFO:
316            logger.info(marker, message, param1);
317            break;
318        case WARN:
319            logger.warn(marker, message, param1);
320            break;
321        case ERROR:
322            logger.error(marker, message, param1);
323            break;
324        }
325        verifyMessage(level, marker, oneParam, null);
326    }
327
328    @Test
329    public void traceMarkerMessageTwoParameters() {
330        for (Level level : Level.values()) {
331            markerMessageTwoParameters(level);
332        }
333    }
334
335    private void markerMessageTwoParameters(Level level) {
336        switch (level) {
337        case TRACE:
338            logger.trace(marker, message, param1, param2);
339            break;
340        case DEBUG:
341            logger.debug(marker, message, param1, param2);
342            break;
343        case INFO:
344            logger.info(marker, message, param1, param2);
345            break;
346        case WARN:
347            logger.warn(marker, message, param1, param2);
348            break;
349        case ERROR:
350            logger.error(marker, message, param1, param2);
351            break;
352        }
353        verifyMessage(level, marker, twoParams, null);
354    }
355
356    @Test
357    public void traceMarkerMessageThreeParameters() {
358        for (Level level : Level.values()) {
359            markerMessageThreeParameters(level);
360        }
361    }
362
363    private void markerMessageThreeParameters(Level level) {
364        switch (level) {
365        case TRACE:
366            logger.trace(marker, message, param1, param2, param3);
367            break;
368        case DEBUG:
369            logger.debug(marker, message, param1, param2, param3);
370            break;
371        case INFO:
372            logger.info(marker, message, param1, param2, param3);
373            break;
374        case WARN:
375            logger.warn(marker, message, param1, param2, param3);
376            break;
377        case ERROR:
378            logger.error(marker, message, param1, param2, param3);
379            break;
380        }
381        verifyMessage(level, marker, threeParams, null);
382    }
383
384    @Test
385    public void markerMessageThrowable() {
386        for (Level level : Level.values()) {
387            markerMessageThrowable(level);
388        }
389    }
390
391    private void markerMessageThrowable(Level level) {
392        switch (level) {
393        case TRACE:
394            logger.trace(marker, message, exception);
395            break;
396        case DEBUG:
397            logger.debug(marker, message, exception);
398            break;
399        case INFO:
400            logger.info(marker, message, exception);
401            break;
402        case WARN:
403            logger.warn(marker, message, exception);
404            break;
405        case ERROR:
406            logger.error(marker, message, exception);
407            break;
408        }
409        verifyMessage(level, marker, null, exception);
410    }
411
412    @Test
413    public void markerMessageOneParameterThrowable() {
414        for (Level level : Level.values()) {
415            markerMessageOneParameterThrowableCheck(level);
416        }
417    }
418
419    private void markerMessageOneParameterThrowableCheck(Level level) {
420        switch (level) {
421        case TRACE:
422            logger.trace(marker, message, param1, exception);
423            break;
424        case DEBUG:
425            logger.debug(marker, message, param1, exception);
426            break;
427        case INFO:
428            logger.info(marker, message, param1, exception);
429            break;
430        case WARN:
431            logger.warn(marker, message, param1, exception);
432            break;
433        case ERROR:
434            logger.error(marker, message, param1, exception);
435            break;
436        }
437        verifyMessage(level, marker, oneParam, exception);
438    }
439
440    @Test
441    public void traceMarkerMessageTwoParametersThrowable() {
442        for (Level level : Level.values()) {
443            markerMessageTwoParametersThrowableCheck(level);
444        }
445    }
446
447    private void markerMessageTwoParametersThrowableCheck(Level level) {
448        switch (level) {
449        case TRACE:
450            logger.trace(marker, message, param1, param2, exception);
451            break;
452        case DEBUG:
453            logger.debug(marker, message, param1, param2, exception);
454            break;
455        case INFO:
456            logger.info(marker, message, param1, param2, exception);
457            break;
458        case WARN:
459            logger.warn(marker, message, param1, param2, exception);
460            break;
461        case ERROR:
462            logger.error(marker, message, param1, param2, exception);
463            break;
464        }
465        verifyMessage(level, marker, twoParams, exception);
466    }
467
468    @Test
469    public void traceMarkerMessageThreeParametersThrowable() {
470        for (Level level : Level.values()) {
471            markerMessageThreeParametersThrowableCheck(level);
472        }
473    }
474
475    private void markerMessageThreeParametersThrowableCheck(Level level) {
476        switch (level) {
477        case TRACE:
478            logger.trace(marker, message, param1, param2, param3, exception);
479            break;
480        case DEBUG:
481            logger.debug(marker, message, param1, param2, param3, exception);
482            break;
483        case INFO:
484            logger.info(marker, message, param1, param2, param3, exception);
485            break;
486        case WARN:
487            logger.warn(marker, message, param1, param2, param3, exception);
488            break;
489        case ERROR:
490            logger.error(marker, message, param1, param2, param3, exception);
491            break;
492        }
493        verifyMessage(level, marker, threeParams, exception);
494    }
495
496    private void verifyMessageWithoutMarker(Level level, Object[] arguments, Throwable exception) {
497        verifyMessage(level, null, arguments, exception);
498    }
499
500    private void verifyMessage(Level level, Marker marker, Object[] arguments, Throwable exception) {
501
502        assertEquals("missing event: ", 1, queue.size());
503        SubstituteLoggingEvent event = queue.poll();
504        assertNotNull(event);
505
506        if (marker == null) {
507            assertNull(event.getMarkers());
508        } else {
509            assertEquals(marker, event.getMarkers().get(0));
510        }
511
512        assertEquals(message, event.getMessage());
513
514        if (arguments == null) {
515            assertNull(event.getArgumentArray());
516        } else {
517            assertArrayEquals(arguments, event.getArgumentArray());
518        }
519
520        assertEquals("wrong level: ", level, event.getLevel());
521
522        if (exception == null) {
523            assertNull(event.getThrowable());
524        } else {
525            assertEquals(exception, event.getThrowable());
526        }
527    }
528}