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}