Download as
Browse Code »

Commit aaaac14cf65f3d1a992216db7ce6965eebf4e38d

Authored by Emerson Oliveira
1 parent 6674b267
Exists in master

Alteração e adições dos testes restantes da Slf4LoggerProxyTest

Showing 1 changed file with 540 additions and 483 deletions   Show diff stats
impl/core/src/test/java/br/gov/frameworkdemoiselle/internal/proxy/Slf4jLoggerProxyTest.java
  Diff comments   View file @aaaac14
@@ -72,7 +72,7 @@ public class Slf4jLoggerProxyTest { @@ -72,7 +72,7 @@ public class Slf4jLoggerProxyTest {
72 expect(LoggerFactory.getLogger(EasyMock.anyObject(Class.class))).andReturn(logger); 72 expect(LoggerFactory.getLogger(EasyMock.anyObject(Class.class))).andReturn(logger);
73 } 73 }
74 74
75 - @Test 75 + @Test//1
76 public void testDebugWithMarkerAndString() { 76 public void testDebugWithMarkerAndString() {
77 Marker marker = null; 77 Marker marker = null;
78 this.logger.debug(marker,""); 78 this.logger.debug(marker,"");
@@ -81,7 +81,7 @@ public class Slf4jLoggerProxyTest { @@ -81,7 +81,7 @@ public class Slf4jLoggerProxyTest {
81 PowerMock.verify(this.logger); 81 PowerMock.verify(this.logger);
82 } 82 }
83 83
84 - @Test 84 + @Test//2
85 public void testDebugWithMarkerStringAndOneObject() { 85 public void testDebugWithMarkerStringAndOneObject() {
86 Marker marker = null; 86 Marker marker = null;
87 Object obj = null; 87 Object obj = null;
@@ -91,485 +91,542 @@ public class Slf4jLoggerProxyTest { @@ -91,485 +91,542 @@ public class Slf4jLoggerProxyTest {
91 PowerMock.verify(this.logger); 91 PowerMock.verify(this.logger);
92 } 92 }
93 93
94 -// @Test  
95 -// public void testDebugWithMarkerStringAndTwoObjects() {  
96 -// Marker marker = nullthis.slf4jLoggerProxy = new Slf4jLoggerProxy(Logger.class);;  
97 -// Object obj1 = null, obj2 = null;  
98 -// this.logger.debug(marker,"",obj1,obj2);  
99 -// replay(this.logger);  
100 -// this.slf4jLoggerProxy.debug(marker,"",obj1,obj2);  
101 -// verify(this.logger);  
102 -// }  
103 -// @Test  
104 -// public void testDebugWithMarkerStringAndObjectArray() {  
105 -// Marker marker = null;  
106 -// Object[] obj = null;  
107 -// this.logger.debug(marker,"",obj);  
108 -// replay(this.logger);  
109 -// this.slf4jLoggerProxy.debug(marker,"",obj);  
110 -// verify(this.logger);  
111 -// }  
112 -//  
113 -// @Test  
114 -// public void testDebugWithMarkerStringAndThrowable() {  
115 -// Marker marker = null;  
116 -// Throwable t = null;  
117 -// this.logger.debug(marker,"",t);  
118 -// replay(this.logger);  
119 -// this.slf4jLoggerProxy.debug(marker,"",t);  
120 -// verify(this.logger);  
121 -// }  
122 -// @Test  
123 -// public void testDebugWithString() {  
124 -// this.logger.debug("");  
125 -// replay(this.logger);  
126 -// this.slf4jLoggerProxy.debug("");  
127 -// verify(this.logger);  
128 -// }  
129 -// @Test  
130 -// public void testDebugWithStringAndOneObject() {  
131 -// Object obj = null;  
132 -// this.logger.debug("",obj);  
133 -// replay(this.logger);  
134 -// this.slf4jLoggerProxy.debug("",obj);  
135 -// verify(this.logger);  
136 -// }  
137 -// @Test  
138 -// public void testDebugWithStringAndTwoObjects() {  
139 -// Object obj1 = null, obj2 = null;  
140 -// this.logger.debug("",obj1,obj2);  
141 -// replay(this.logger);  
142 -// this.slf4jLoggerProxy.debug("",obj1,obj2);  
143 -// verify(this.logger);  
144 -// }  
145 -// @Test  
146 -// public void testDebugWithStringAndObjectArray() {  
147 -// Object[] obj = null;  
148 -// this.logger.debug("",obj);  
149 -// replay(this.logger);  
150 -// this.slf4jLoggerProxy.debug("",obj);  
151 -// verify(this.logger);  
152 -// }  
153 -// @Test  
154 -// public void testDebugWithStringAndThrowable() {  
155 -// Throwable t = null;  
156 -// this.logger.debug("",t);  
157 -// replay(this.logger);  
158 -// this.slf4jLoggerProxy.debug("",t);  
159 -// verify(this.logger);  
160 -// }  
161 -// @Test  
162 -// public void testErrorWithMarkerAndString() {  
163 -// Marker marker = null;  
164 -// this.logger.error(marker,"");  
165 -// replay(this.logger);  
166 -// this.slf4jLoggerProxy.error(marker,"");  
167 -// verify(this.logger);  
168 -// }  
169 -// @Test  
170 -// public void testErrorWithMarkerStringAndOneObject() {  
171 -// Marker marker = null;  
172 -// Object obj = null;  
173 -// this.logger.error(marker,"",obj);  
174 -// replay(this.logger);  
175 -// this.slf4jLoggerProxy.error(marker,"",obj);  
176 -// verify(this.logger);  
177 -// }  
178 -// @Test  
179 -// public void testErrorWithMarkerStringAndTwoObjects() {  
180 -// Marker marker = null;  
181 -// Object obj1 = null, obj2 = null;  
182 -// this.logger.error(marker,"",obj1,obj2);  
183 -// replay(this.logger);  
184 -// this.slf4jLoggerProxy.error(marker,"",obj1,obj2);  
185 -// verify(this.logger);  
186 -// }  
187 -// @Test  
188 -// public void testErrorWithMarkerStringAndObjectArray() {  
189 -// Marker marker = null;  
190 -// Object[] obj1 = null;  
191 -// this.logger.error(marker,"",obj1);  
192 -// replay(this.logger);  
193 -// this.slf4jLoggerProxy.error(marker,"",obj1);  
194 -// verify(this.logger);  
195 -// }  
196 -// @Test  
197 -// public void testErrorWithMarkerStringAndThrowable() {  
198 -// Marker marker = null;  
199 -// Throwable t = null;  
200 -// this.logger.error(marker,"",t);  
201 -// replay(this.logger);  
202 -// this.slf4jLoggerProxy.error(marker,"",t);  
203 -// verify(this.logger);  
204 -// }  
205 -// @Test  
206 -// public void testErrorWithString() {  
207 -// this.logger.error("");  
208 -// replay(this.logger);  
209 -// this.slf4jLoggerProxy.error("");  
210 -// verify(this.logger);  
211 -// }  
212 -// @Test  
213 -// public void testErrorWithStringAndOneObject() {  
214 -// Object obj = null;  
215 -// this.logger.error("",obj);  
216 -// replay(this.logger);  
217 -// this.slf4jLoggerProxy.error("",obj);  
218 -// verify(this.logger);  
219 -// }  
220 -// @Test  
221 -// public void testErrorWithStringAndTwoObjects() {  
222 -// Object obj1 = null,obj2 = null;  
223 -// this.logger.error("",obj1,obj2);  
224 -// replay(this.logger);  
225 -// this.slf4jLoggerProxy.error("",obj1,obj2);  
226 -// verify(this.logger);  
227 -// }  
228 -// @Test  
229 -// public void testErrorWithStringAndObjectArray() {  
230 -// Object[] obj = null;  
231 -// this.logger.error("",obj);  
232 -// replay(this.logger);  
233 -// this.slf4jLoggerProxy.error("",obj);  
234 -// verify(this.logger);  
235 -// }  
236 -// @Test  
237 -// public void testErrorWithStringAndThrowable() {  
238 -// Throwable t = null;  
239 -// this.logger.error("",t);  
240 -// replay(this.logger);  
241 -// this.slf4jLoggerProxy.error("",t);  
242 -// verify(this.logger);  
243 -// }  
244 -// @Test  
245 -// public void testGetName() {  
246 -// expect(this.logger.getName()).andReturn("xxx");  
247 -// replay(this.logger);  
248 -// assertEquals("xxx", this.slf4jLoggerProxy.getName());  
249 -// verify(this.logger);  
250 -// }  
251 -// @Test  
252 -// public void testInfoWithMarkerAndString() {  
253 -// Marker marker = null;  
254 -// this.logger.info(marker,"");  
255 -// replay(this.logger);  
256 -// this.slf4jLoggerProxy.info(marker,"");  
257 -// verify(this.logger);  
258 -// }  
259 -// @Test  
260 -// public void testInfoWithMarkerStringAndOneObject() {  
261 -// Marker marker = null;  
262 -// Object obj = null;  
263 -// this.logger.info(marker,"",obj);  
264 -// replay(this.logger);  
265 -// this.slf4jLoggerProxy.info(marker,"",obj);  
266 -// verify(this.logger);  
267 -// }  
268 -// @Test  
269 -// public void testInfoWithMarkerStringAndTwoObjects() {  
270 -// Marker marker = null;  
271 -// Object obj1 = null, obj2 = null;  
272 -// this.logger.info(marker,"",obj1, obj2);  
273 -// replay(this.logger);  
274 -// this.slf4jLoggerProxy.info(marker,"",obj1,obj2);  
275 -// verify(this.logger);  
276 -// }  
277 -// @Test  
278 -// public void testInfoWithMarkerStringAndObjectArray() {  
279 -// Marker marker = null;  
280 -// Object[] obj = null;  
281 -// this.logger.info(marker,"",obj);  
282 -// replay(this.logger);  
283 -// this.slf4jLoggerProxy.info(marker,"",obj);  
284 -// verify(this.logger);  
285 -// }  
286 -// @Test  
287 -// public void testInfoWithMarkerStringAndThrowable() {  
288 -// Marker marker = null;  
289 -// Throwable t = null;  
290 -// this.logger.info(marker,"",t);  
291 -// replay(this.logger);  
292 -// this.slf4jLoggerProxy.info(marker,"",t);  
293 -// verify(this.logger);  
294 -// }  
295 -// @Test  
296 -// public void testInfoWithString() {  
297 -// this.logger.info("");  
298 -// replay(this.logger);  
299 -// this.slf4jLoggerProxy.info("");  
300 -// verify(this.logger);  
301 -// }  
302 -// @Test  
303 -// public void testInfoWithStringAndOneObject() {  
304 -// Object obj = null;  
305 -// this.logger.info("",obj);  
306 -// replay(this.logger);  
307 -// this.slf4jLoggerProxy.info("",obj);  
308 -// verify(this.logger);  
309 -// }  
310 -// @Test  
311 -// public void testInfoWithStringAndTwoObjects() {  
312 -// Object obj1 = null, obj2 = null;  
313 -// this.logger.info("",obj1,obj2);  
314 -// replay(this.logger);  
315 -// this.slf4jLoggerProxy.info("",obj1,obj2);  
316 -// verify(this.logger);  
317 -// }  
318 -// @Test  
319 -// public void testInfoWithStringAndObjectArray() {  
320 -// Object[] obj = null;  
321 -// this.logger.info("",obj);  
322 -// replay(this.logger);  
323 -// this.slf4jLoggerProxy.info("",obj);  
324 -// verify(this.logger);  
325 -// }  
326 -// @Test  
327 -// public void testInfoWithStringAndThrowable() {  
328 -// Throwable t = null;  
329 -// this.logger.info("",t);  
330 -// replay(this.logger);  
331 -// this.slf4jLoggerProxy.info("",t);  
332 -// verify(this.logger);  
333 -// }  
334 -// @Test  
335 -// public void testIsDebugEnabled() {  
336 -// expect(this.logger.isDebugEnabled()).andReturn(true);  
337 -// replay(this.logger);  
338 -// assertEquals(true, this.slf4jLoggerProxy.isDebugEnabled());  
339 -// verify(this.logger);  
340 -// }  
341 -// @Test  
342 -// public void testIsDebugEnabledWithMarker() {  
343 -// Marker marker = null;  
344 -// expect(this.logger.isDebugEnabled(marker)).andReturn(true);  
345 -// replay(this.logger);  
346 -// assertEquals(true, this.slf4jLoggerProxy.isDebugEnabled(marker));  
347 -// verify(this.logger);  
348 -// }  
349 -// @Test  
350 -// public void testIsErrorEnabled() {  
351 -// expect(this.logger.isErrorEnabled()).andReturn(true);  
352 -// replay(this.logger);  
353 -// assertEquals(true, this.slf4jLoggerProxy.isErrorEnabled());  
354 -// verify(this.logger);  
355 -// }  
356 -// @Test  
357 -// public void testIsErrorEnabledWithMarker() {  
358 -// Marker marker = null;  
359 -// expect(this.logger.isErrorEnabled(marker)).andReturn(true);  
360 -// replay(this.logger);  
361 -// assertEquals(true, this.slf4jLoggerProxy.isErrorEnabled(marker));  
362 -// verify(this.logger);  
363 -// }  
364 -// @Test  
365 -// public void testIsInfoEnabled() {  
366 -// expect(this.logger.isInfoEnabled()).andReturn(true);  
367 -// replay(this.logger);  
368 -// assertEquals(true, this.slf4jLoggerProxy.isInfoEnabled());  
369 -// verify(this.logger);  
370 -// }  
371 -// @Test  
372 -// public void testIsInfoEnabledWithMarker() {  
373 -// Marker marker = null;  
374 -// expect(this.logger.isInfoEnabled(marker)).andReturn(true);  
375 -// replay(this.logger);  
376 -// assertEquals(true, this.slf4jLoggerProxy.isInfoEnabled(marker));  
377 -// verify(this.logger);  
378 -// }  
379 -// @Test  
380 -// public void testIsTRaceEnabled() {  
381 -// expect(this.logger.isTraceEnabled()).andReturn(true);  
382 -// replay(this.logger);  
383 -// assertEquals(true, this.slf4jLoggerProxy.isTraceEnabled());  
384 -// verify(this.logger);  
385 -// }  
386 -// @Test  
387 -// public void testIsTraceEnabledWithMarker() {  
388 -// Marker marker = null;  
389 -// expect(this.logger.isTraceEnabled(marker)).andReturn(true);  
390 -// replay(this.logger);  
391 -// assertEquals(true, this.slf4jLoggerProxy.isTraceEnabled(marker));  
392 -// verify(this.logger);  
393 -// }  
394 -// @Test  
395 -// public void testIsWarnEnabled() {  
396 -// expect(this.logger.isWarnEnabled()).andReturn(true);  
397 -// replay(this.logger);  
398 -// assertEquals(true, this.slf4jLoggerProxy.isWarnEnabled());  
399 -// verify(this.logger);  
400 -// }  
401 -// @Test  
402 -// public void testIsWarnEnabledWithMarker() {  
403 -// Marker marker = null;  
404 -// expect(this.logger.isWarnEnabled(marker)).andReturn(true);  
405 -// replay(this.logger);  
406 -// assertEquals(true, this.slf4jLoggerProxy.isWarnEnabled(marker));  
407 -// verify(this.logger);  
408 -// }  
409 -// @Test  
410 -// public void testTraceWithMarkerAndString() {  
411 -// Marker marker = null;  
412 -// this.logger.trace(marker,"");  
413 -// replay(this.logger);  
414 -// this.slf4jLoggerProxy.trace(marker,"");  
415 -// verify(this.logger);  
416 -// }  
417 -// @Test  
418 -// public void testTraceWithMarkerStringAndOneObject() {  
419 -// Marker marker = null;  
420 -// Object obj = null;  
421 -// this.logger.trace(marker,"",obj);  
422 -// replay(this.logger);  
423 -// this.slf4jLoggerProxy.trace(marker,"",obj);  
424 -// verify(this.logger);  
425 -// }  
426 -// @Test  
427 -// public void testTraceWithMarkerStringAndTwoObjects() {  
428 -// Marker marker = null;  
429 -// Object obj1 = null, obj2 = null;  
430 -// this.logger.trace(marker,"",obj1, obj2);  
431 -// replay(this.logger);  
432 -// this.slf4jLoggerProxy.trace(marker,"",obj1,obj2);  
433 -// verify(this.logger);  
434 -// }  
435 -// @Test  
436 -// public void testTraceWithMarkerStringAndObjectArray() {  
437 -// Marker marker = null;  
438 -// Object[] obj = null;  
439 -// this.logger.trace(marker,"",obj);  
440 -// replay(this.logger);  
441 -// this.slf4jLoggerProxy.trace(marker,"",obj);  
442 -// verify(this.logger);  
443 -// }  
444 -// @Test  
445 -// public void testTraceWithMarkerStringAndThrowable() {  
446 -// Marker marker = null;  
447 -// Throwable t = null;  
448 -// this.logger.trace(marker,"",t);  
449 -// replay(this.logger);  
450 -// this.slf4jLoggerProxy.trace(marker,"",t);  
451 -// verify(this.logger);  
452 -// }  
453 -// @Test  
454 -// public void testTraceWithString() {  
455 -// this.logger.trace("");  
456 -// replay(this.logger);  
457 -// this.slf4jLoggerProxy.trace("");  
458 -// verify(this.logger);  
459 -// }  
460 -// @Test  
461 -// public void testTraceWithStringAndOneObject() {  
462 -// Object obj = null;  
463 -// this.logger.trace("",obj);  
464 -// replay(this.logger);  
465 -// this.slf4jLoggerProxy.trace("",obj);  
466 -// verify(this.logger);  
467 -// }  
468 -// @Test  
469 -// public void testTraceWithStringAndTwoObjects() {  
470 -// Object obj1 = null, obj2 = null;  
471 -// this.logger.trace("",obj1,obj2);  
472 -// replay(this.logger);  
473 -// this.slf4jLoggerProxy.trace("",obj1,obj2);  
474 -// verify(this.logger);  
475 -// }  
476 -// @Test  
477 -// public void testTraceWithStringAndObjectArray() {  
478 -// Object[] obj = null;  
479 -// this.logger.trace("",obj);  
480 -// replay(this.logger);  
481 -// this.slf4jLoggerProxy.trace("",obj);  
482 -// verify(this.logger);  
483 -// }  
484 -// @Test  
485 -// public void testTraceWithStringAndThrowable() {  
486 -// Throwable t = null;  
487 -// this.logger.trace("",t);  
488 -// replay(this.logger);  
489 -// this.slf4jLoggerProxy.trace("",t);  
490 -// verify(this.logger);  
491 -// }  
492 -// @Test  
493 -// public void testWarnWithMarkerAndString() {  
494 -// Marker marker = null;  
495 -// this.logger.warn(marker,"");  
496 -// replay(this.logger);  
497 -// this.slf4jLoggerProxy.warn(marker,"");  
498 -// verify(this.logger);  
499 -// }  
500 -// @Test  
501 -// public void testWarnWithMarkerStringAndOneObject() {  
502 -// Marker marker = null;  
503 -// Object obj = null;  
504 -// this.logger.warn(marker,"",obj);  
505 -// replay(this.logger);  
506 -// this.slf4jLoggerProxy.warn(marker,"",obj);  
507 -// verify(this.logger);  
508 -// }  
509 -// @Test  
510 -// public void testWarnWithMarkerStringAndTwoObjects() {  
511 -// Marker marker = null;  
512 -// Object obj1 = null, obj2 = null;  
513 -// this.logger.warn(marker,"",obj1, obj2);  
514 -// replay(this.logger);  
515 -// this.slf4jLoggerProxy.warn(marker,"",obj1,obj2);  
516 -// verify(this.logger);  
517 -// }  
518 -// @Test  
519 -// public void testWarnWithMarkerStringAndObjectArray() {  
520 -// Marker marker = null;  
521 -// Object[] obj = null;  
522 -// this.logger.warn(marker,"",obj);  
523 -// replay(this.logger);  
524 -// this.slf4jLoggerProxy.warn(marker,"",obj);  
525 -// verify(this.logger);  
526 -// }  
527 -// @Test  
528 -// public void testWarnWithMarkerStringAndThrowable() {  
529 -// Marker marker = null;  
530 -// Throwable t = null;  
531 -// this.logger.warn(marker,"",t);  
532 -// replay(this.logger);  
533 -// this.slf4jLoggerProxy.warn(marker,"",t);  
534 -// verify(this.logger);  
535 -// }  
536 -// @Test  
537 -// public void testWarnWithString() {  
538 -// this.logger.warn("");  
539 -// replay(this.logger);  
540 -// this.slf4jLoggerProxy.warn("");  
541 -// verify(this.logger);  
542 -// }  
543 -// @Test  
544 -// public void testWarnWithStringAndOneObject() {  
545 -// Object obj = null;  
546 -// this.logger.warn("",obj);  
547 -// replay(this.logger);  
548 -// this.slf4jLoggerProxy.warn("",obj);  
549 -// verify(this.logger);  
550 -// }  
551 -// @Test  
552 -// public void testWarnWithStringAndTwoObjects() {  
553 -// Object obj1 = null, obj2 = null;  
554 -// this.logger.warn("",obj1,obj2);  
555 -// replay(this.logger);  
556 -// this.slf4jLoggerProxy.warn("",obj1,obj2);  
557 -// verify(this.logger);  
558 -// }  
559 -// @Test  
560 -// public void testWarnWithStringAndObjectArray() {  
561 -// Object[] obj = null;  
562 -// this.logger.warn("",obj);  
563 -// replay(this.logger);  
564 -// this.slf4jLoggerProxy.warn("",obj);  
565 -// verify(this.logger);  
566 -// }  
567 -// @Test  
568 -// public void testWarnWithStringAndThrowable() {  
569 -// Throwable t = null;  
570 -// this.logger.warn("",t);  
571 -// replay(this.logger);  
572 -// this.slf4jLoggerProxy.warn("",t);  
573 -// verify(this.logger);  
574 -// } 94 + @Test//3
  95 + public void testDebugWithMarkerStringAndTwoObjects() {
  96 + Marker marker = null;
  97 + Object obj1 = null, obj2 = null;
  98 + this.logger.debug(marker,"",obj1,obj2);
  99 + PowerMock.replay(LoggerFactory.class, this.logger);
  100 + this.slf4jLoggerProxy.debug(marker,"",obj1,obj2);
  101 + PowerMock.verify(this.logger);
  102 + }
  103 +
  104 + @Test//4
  105 + public void testDebugWithMarkerStringAndObjectArray() {
  106 + Marker marker = null;
  107 + Object[] obj = null;
  108 + this.logger.debug(marker,"",obj);
  109 + PowerMock.replay(LoggerFactory.class, this.logger);
  110 + this.slf4jLoggerProxy.debug(marker,"",obj);
  111 + PowerMock.verify(this.logger);
  112 + }
  113 +
  114 + @Test//5
  115 + public void testDebugWithMarkerStringAndThrowable() {
  116 + Marker marker = null;
  117 + Throwable t = null;
  118 + this.logger.debug(marker,"",t);
  119 + PowerMock.replay(LoggerFactory.class, this.logger);
  120 + this.slf4jLoggerProxy.debug(marker,"",t);
  121 + PowerMock.verify(this.logger);
  122 + }
  123 +
  124 + @Test//6
  125 + public void testDebugWithString() {
  126 + this.logger.debug("");
  127 + PowerMock.replay(LoggerFactory.class, this.logger);
  128 + this.slf4jLoggerProxy.debug("");
  129 + PowerMock.verify(this.logger);
  130 + }
  131 +
  132 + @Test//7
  133 + public void testDebugWithStringAndOneObject() {
  134 + Object obj = null;
  135 + this.logger.debug("",obj);
  136 + PowerMock.replay(LoggerFactory.class, this.logger);
  137 + this.slf4jLoggerProxy.debug("",obj);
  138 + PowerMock.verify(this.logger);
  139 + }
  140 +
  141 + @Test//8
  142 + public void testDebugWithStringAndTwoObjects() {
  143 + Object obj1 = null, obj2 = null;
  144 + this.logger.debug("",obj1,obj2);
  145 + PowerMock.replay(LoggerFactory.class, this.logger);
  146 + this.slf4jLoggerProxy.debug("",obj1,obj2);
  147 + PowerMock.verify(this.logger);
  148 + }
  149 +
  150 + @Test//9
  151 + public void testDebugWithStringAndObjectArray() {
  152 + Object[] obj = null;
  153 + this.logger.debug("",obj);
  154 + PowerMock.replay(LoggerFactory.class, this.logger);
  155 + this.slf4jLoggerProxy.debug("",obj);
  156 + PowerMock.verify(this.logger);
  157 + }
  158 +
  159 + @Test//10
  160 + public void testDebugWithStringAndThrowable() {
  161 + Throwable t = null;
  162 + this.logger.debug("",t);
  163 + PowerMock.replay(LoggerFactory.class, this.logger);
  164 + this.slf4jLoggerProxy.debug("",t);
  165 + PowerMock.verify(this.logger);
  166 + }
  167 +
  168 + @Test//11
  169 + public void testErrorWithMarkerAndString() {
  170 + Marker marker = null;
  171 + this.logger.error(marker,"");
  172 + PowerMock.replay(LoggerFactory.class, this.logger);
  173 + this.slf4jLoggerProxy.error(marker,"");
  174 + PowerMock.verify(this.logger);
  175 + }
  176 +
  177 + @Test//12
  178 + public void testErrorWithMarkerStringAndOneObject() {
  179 + Marker marker = null;
  180 + Object obj = null;
  181 + this.logger.error(marker,"",obj);
  182 + PowerMock.replay(LoggerFactory.class, this.logger);
  183 + this.slf4jLoggerProxy.error(marker,"",obj);
  184 + PowerMock.verify(this.logger);
  185 + }
  186 +
  187 + @Test//13
  188 + public void testErrorWithMarkerStringAndTwoObjects() {
  189 + Marker marker = null;
  190 + Object obj1 = null, obj2 = null;
  191 + this.logger.error(marker,"",obj1,obj2);
  192 + PowerMock.replay(LoggerFactory.class, this.logger);
  193 + this.slf4jLoggerProxy.error(marker,"",obj1,obj2);
  194 + PowerMock.verify(this.logger);
  195 + }
  196 +
  197 + @Test//14
  198 + public void testErrorWithMarkerStringAndObjectArray() {
  199 + Marker marker = null;
  200 + Object[] obj1 = null;
  201 + this.logger.error(marker,"",obj1);
  202 + PowerMock.replay(LoggerFactory.class, this.logger);
  203 + this.slf4jLoggerProxy.error(marker,"",obj1);
  204 + PowerMock.verify(this.logger);
  205 + }
  206 +
  207 + @Test//15
  208 + public void testErrorWithMarkerStringAndThrowable() {
  209 + Marker marker = null;
  210 + Throwable t = null;
  211 + this.logger.error(marker,"",t);
  212 + PowerMock.replay(LoggerFactory.class, this.logger);
  213 + this.slf4jLoggerProxy.error(marker,"",t);
  214 + PowerMock.verify(this.logger);
  215 + }
  216 +
  217 + @Test//16
  218 + public void testErrorWithString() {
  219 + this.logger.error("");
  220 + PowerMock.replay(LoggerFactory.class, this.logger);
  221 + this.slf4jLoggerProxy.error("");
  222 + PowerMock.verify(this.logger);
  223 + }
  224 +
  225 + @Test//17
  226 + public void testErrorWithStringAndOneObject() {
  227 + Object obj = null;
  228 + this.logger.error("",obj);
  229 + PowerMock.replay(LoggerFactory.class, this.logger);
  230 + this.slf4jLoggerProxy.error("",obj);
  231 + PowerMock.verify(this.logger);
  232 + }
  233 +
  234 + @Test//18
  235 + public void testErrorWithStringAndTwoObjects() {
  236 + Object obj1 = null,obj2 = null;
  237 + this.logger.error("",obj1,obj2);
  238 + PowerMock.replay(LoggerFactory.class, this.logger);
  239 + this.slf4jLoggerProxy.error("",obj1,obj2);
  240 + PowerMock.verify(this.logger);
  241 + }
  242 +
  243 + @Test//19
  244 + public void testErrorWithStringAndObjectArray() {
  245 + Object[] obj = null;
  246 + this.logger.error("",obj);
  247 + PowerMock.replay(LoggerFactory.class, this.logger);
  248 + this.slf4jLoggerProxy.error("",obj);
  249 + PowerMock.verify(this.logger);
  250 + }
  251 +
  252 + @Test//20
  253 + public void testErrorWithStringAndThrowable() {
  254 + Throwable t = null;
  255 + this.logger.error("",t);
  256 + PowerMock.replay(LoggerFactory.class, this.logger);
  257 + this.slf4jLoggerProxy.error("",t);
  258 + PowerMock.verify(this.logger);
  259 + }
  260 +
  261 + @Test//21
  262 + public void testGetName() {
  263 + expect(this.logger.getName()).andReturn("xxx");
  264 + PowerMock.replay(LoggerFactory.class, this.logger);
  265 + assertEquals("xxx", this.slf4jLoggerProxy.getName());
  266 + PowerMock.verify(this.logger);
  267 + }
  268 +
  269 + @Test//22
  270 + public void testInfoWithMarkerAndString() {
  271 + Marker marker = null;
  272 + this.logger.info(marker,"");
  273 + PowerMock.replay(LoggerFactory.class, this.logger);
  274 + this.slf4jLoggerProxy.info(marker,"");
  275 + PowerMock.verify(this.logger);
  276 + }
  277 +
  278 + @Test//23
  279 + public void testInfoWithMarkerStringAndOneObject() {
  280 + Marker marker = null;
  281 + Object obj = null;
  282 + this.logger.info(marker,"",obj);
  283 + PowerMock.replay(LoggerFactory.class, this.logger);
  284 + this.slf4jLoggerProxy.info(marker,"",obj);
  285 + PowerMock.verify(this.logger);
  286 + }
  287 +
  288 + @Test//24
  289 + public void testInfoWithMarkerStringAndTwoObjects() {
  290 + Marker marker = null;
  291 + Object obj1 = null, obj2 = null;
  292 + this.logger.info(marker,"",obj1, obj2);
  293 + PowerMock.replay(LoggerFactory.class, this.logger);
  294 + this.slf4jLoggerProxy.info(marker,"",obj1,obj2);
  295 + PowerMock.verify(this.logger);
  296 + }
  297 +
  298 + @Test//25
  299 + public void testInfoWithMarkerStringAndObjectArray() {
  300 + Marker marker = null;
  301 + Object[] obj = null;
  302 + this.logger.info(marker,"",obj);
  303 + PowerMock.replay(LoggerFactory.class, this.logger);
  304 + this.slf4jLoggerProxy.info(marker,"",obj);
  305 + PowerMock.verify(this.logger);
  306 + }
  307 +
  308 + @Test//26
  309 + public void testInfoWithMarkerStringAndThrowable() {
  310 + Marker marker = null;
  311 + Throwable t = null;
  312 + this.logger.info(marker,"",t);
  313 + PowerMock.replay(LoggerFactory.class, this.logger);
  314 + this.slf4jLoggerProxy.info(marker,"",t);
  315 + PowerMock.verify(this.logger);
  316 + }
  317 +
  318 + @Test//27
  319 + public void testInfoWithString() {
  320 + this.logger.info("");
  321 + PowerMock.replay(LoggerFactory.class, this.logger);
  322 + this.slf4jLoggerProxy.info("");
  323 + PowerMock.verify(this.logger);
  324 + }
  325 +
  326 + @Test//28
  327 + public void testInfoWithStringAndOneObject() {
  328 + Object obj = null;
  329 + this.logger.info("",obj);
  330 + PowerMock.replay(LoggerFactory.class, this.logger);
  331 + this.slf4jLoggerProxy.info("",obj);
  332 + PowerMock.verify(this.logger);
  333 + }
  334 +
  335 + @Test//29
  336 + public void testInfoWithStringAndTwoObjects() {
  337 + Object obj1 = null, obj2 = null;
  338 + this.logger.info("",obj1,obj2);
  339 + PowerMock.replay(LoggerFactory.class, this.logger);
  340 + this.slf4jLoggerProxy.info("",obj1,obj2);
  341 + PowerMock.verify(this.logger);
  342 + }
  343 +
  344 + @Test//30
  345 + public void testInfoWithStringAndObjectArray() {
  346 + Object[] obj = null;
  347 + this.logger.info("",obj);
  348 + PowerMock.replay(LoggerFactory.class, this.logger);
  349 + this.slf4jLoggerProxy.info("",obj);
  350 + PowerMock.verify(this.logger);
  351 + }
  352 +
  353 + @Test//31
  354 + public void testInfoWithStringAndThrowable() {
  355 + Throwable t = null;
  356 + this.logger.info("",t);
  357 + PowerMock.replay(LoggerFactory.class, this.logger);
  358 + this.slf4jLoggerProxy.info("",t);
  359 + PowerMock.verify(this.logger);
  360 + }
  361 +
  362 + @Test//32
  363 + public void testIsDebugEnabled() {
  364 + expect(this.logger.isDebugEnabled()).andReturn(true);
  365 + PowerMock.replay(LoggerFactory.class, this.logger);
  366 + assertEquals(true, this.slf4jLoggerProxy.isDebugEnabled());
  367 + PowerMock.verify(this.logger);
  368 + }
  369 +
  370 + @Test//33
  371 + public void testIsDebugEnabledWithMarker() {
  372 + Marker marker = null;
  373 + expect(this.logger.isDebugEnabled(marker)).andReturn(true);
  374 + PowerMock.replay(LoggerFactory.class, this.logger);
  375 + assertEquals(true, this.slf4jLoggerProxy.isDebugEnabled(marker));
  376 + PowerMock.verify(this.logger);
  377 + }
  378 +
  379 + @Test//34
  380 + public void testIsErrorEnabled() {
  381 + expect(this.logger.isErrorEnabled()).andReturn(true);
  382 + PowerMock.replay(LoggerFactory.class, this.logger);
  383 + assertEquals(true, this.slf4jLoggerProxy.isErrorEnabled());
  384 + PowerMock.verify(this.logger);
  385 + }
  386 +
  387 + @Test//35
  388 + public void testIsErrorEnabledWithMarker() {
  389 + Marker marker = null;
  390 + expect(this.logger.isErrorEnabled(marker)).andReturn(true);
  391 + PowerMock.replay(LoggerFactory.class, this.logger);
  392 + assertEquals(true, this.slf4jLoggerProxy.isErrorEnabled(marker));
  393 + PowerMock.verify(this.logger);
  394 + }
  395 +
  396 + @Test//36
  397 + public void testIsInfoEnabled() {
  398 + expect(this.logger.isInfoEnabled()).andReturn(true);
  399 + PowerMock.replay(LoggerFactory.class, this.logger);
  400 + assertEquals(true, this.slf4jLoggerProxy.isInfoEnabled());
  401 + PowerMock.verify(this.logger);
  402 + }
  403 +
  404 + @Test//37
  405 + public void testIsInfoEnabledWithMarker() {
  406 + Marker marker = null;
  407 + expect(this.logger.isInfoEnabled(marker)).andReturn(true);
  408 + PowerMock.replay(LoggerFactory.class, this.logger);
  409 + assertEquals(true, this.slf4jLoggerProxy.isInfoEnabled(marker));
  410 + PowerMock.verify(this.logger);
  411 + }
  412 +
  413 + @Test//38
  414 + public void testIsTRaceEnabled() {
  415 + expect(this.logger.isTraceEnabled()).andReturn(true);
  416 + PowerMock.replay(LoggerFactory.class, this.logger);
  417 + assertEquals(true, this.slf4jLoggerProxy.isTraceEnabled());
  418 + PowerMock.verify(this.logger);
  419 + }
  420 +
  421 + @Test//39
  422 + public void testIsTraceEnabledWithMarker() {
  423 + Marker marker = null;
  424 + expect(this.logger.isTraceEnabled(marker)).andReturn(true);
  425 + PowerMock.replay(LoggerFactory.class, this.logger);
  426 + assertEquals(true, this.slf4jLoggerProxy.isTraceEnabled(marker));
  427 + PowerMock.verify(this.logger);
  428 + }
  429 +
  430 + @Test//40
  431 + public void testIsWarnEnabled() {
  432 + expect(this.logger.isWarnEnabled()).andReturn(true);
  433 + PowerMock.replay(LoggerFactory.class, this.logger);
  434 + assertEquals(true, this.slf4jLoggerProxy.isWarnEnabled());
  435 + PowerMock.verify(this.logger);
  436 + }
  437 +
  438 + @Test//41
  439 + public void testIsWarnEnabledWithMarker() {
  440 + Marker marker = null;
  441 + expect(this.logger.isWarnEnabled(marker)).andReturn(true);
  442 + PowerMock.replay(LoggerFactory.class, this.logger);
  443 + assertEquals(true, this.slf4jLoggerProxy.isWarnEnabled(marker));
  444 + PowerMock.verify(this.logger);
  445 + }
  446 +
  447 + @Test//42
  448 + public void testTraceWithMarkerAndString() {
  449 + Marker marker = null;
  450 + this.logger.trace(marker,"");
  451 + PowerMock.replay(LoggerFactory.class, this.logger);
  452 + this.slf4jLoggerProxy.trace(marker,"");
  453 + PowerMock.verify(this.logger);
  454 + }
  455 +
  456 + @Test//43
  457 + public void testTraceWithMarkerStringAndOneObject() {
  458 + Marker marker = null;
  459 + Object obj = null;
  460 + this.logger.trace(marker,"",obj);
  461 + PowerMock.replay(LoggerFactory.class, this.logger);
  462 + this.slf4jLoggerProxy.trace(marker,"",obj);
  463 + PowerMock.verify(this.logger);
  464 + }
  465 +
  466 + @Test//44
  467 + public void testTraceWithMarkerStringAndTwoObjects() {
  468 + Marker marker = null;
  469 + Object obj1 = null, obj2 = null;
  470 + this.logger.trace(marker,"",obj1, obj2);
  471 + PowerMock.replay(LoggerFactory.class, this.logger);
  472 + this.slf4jLoggerProxy.trace(marker,"",obj1,obj2);
  473 + PowerMock.verify(this.logger);
  474 + }
  475 +
  476 + @Test//45
  477 + public void testTraceWithMarkerStringAndObjectArray() {
  478 + Marker marker = null;
  479 + Object[] obj = null;
  480 + this.logger.trace(marker,"",obj);
  481 + PowerMock.replay(LoggerFactory.class, this.logger);
  482 + this.slf4jLoggerProxy.trace(marker,"",obj);
  483 + PowerMock.verify(this.logger);
  484 + }
  485 +
  486 + @Test//46
  487 + public void testTraceWithMarkerStringAndThrowable() {
  488 + Marker marker = null;
  489 + Throwable t = null;
  490 + this.logger.trace(marker,"",t);
  491 + PowerMock.replay(LoggerFactory.class, this.logger);
  492 + this.slf4jLoggerProxy.trace(marker,"",t);
  493 + PowerMock.verify(this.logger);
  494 + }
  495 +
  496 + @Test//47
  497 + public void testTraceWithString() {
  498 + this.logger.trace("");
  499 + PowerMock.replay(LoggerFactory.class, this.logger);
  500 + this.slf4jLoggerProxy.trace("");
  501 + PowerMock.verify(this.logger);
  502 + }
  503 +
  504 + @Test//48
  505 + public void testTraceWithStringAndOneObject() {
  506 + Object obj = null;
  507 + this.logger.trace("",obj);
  508 + PowerMock.replay(LoggerFactory.class, this.logger);
  509 + this.slf4jLoggerProxy.trace("",obj);
  510 + PowerMock.verify(this.logger);
  511 + }
  512 +
  513 + @Test//49
  514 + public void testTraceWithStringAndTwoObjects() {
  515 + Object obj1 = null, obj2 = null;
  516 + this.logger.trace("",obj1,obj2);
  517 + PowerMock.replay(LoggerFactory.class, this.logger);
  518 + this.slf4jLoggerProxy.trace("",obj1,obj2);
  519 + PowerMock.verify(this.logger);
  520 + }
  521 +
  522 + @Test//50
  523 + public void testTraceWithStringAndObjectArray() {
  524 + Object[] obj = null;
  525 + this.logger.trace("",obj);
  526 + PowerMock.replay(LoggerFactory.class, this.logger);
  527 + this.slf4jLoggerProxy.trace("",obj);
  528 + PowerMock.verify(this.logger);
  529 + }
  530 +
  531 + @Test//51
  532 + public void testTraceWithStringAndThrowable() {
  533 + Throwable t = null;
  534 + this.logger.trace("",t);
  535 + PowerMock.replay(LoggerFactory.class, this.logger);
  536 + this.slf4jLoggerProxy.trace("",t);
  537 + PowerMock.verify(this.logger);
  538 + }
  539 +
  540 + @Test//52
  541 + public void testWarnWithMarkerAndString() {
  542 + Marker marker = null;
  543 + this.logger.warn(marker,"");
  544 + PowerMock.replay(LoggerFactory.class, this.logger);
  545 + this.slf4jLoggerProxy.warn(marker,"");
  546 + PowerMock.verify(this.logger);
  547 + }
  548 +
  549 + @Test//53
  550 + public void testWarnWithMarkerStringAndOneObject() {
  551 + Marker marker = null;
  552 + Object obj = null;
  553 + this.logger.warn(marker,"",obj);
  554 + PowerMock.replay(LoggerFactory.class, this.logger);
  555 + this.slf4jLoggerProxy.warn(marker,"",obj);
  556 + PowerMock.verify(this.logger);
  557 + }
  558 +
  559 + @Test//54
  560 + public void testWarnWithMarkerStringAndTwoObjects() {
  561 + Marker marker = null;
  562 + Object obj1 = null, obj2 = null;
  563 + this.logger.warn(marker,"",obj1, obj2);
  564 + PowerMock.replay(LoggerFactory.class, this.logger);
  565 + this.slf4jLoggerProxy.warn(marker,"",obj1,obj2);
  566 + PowerMock.verify(this.logger);
  567 + }
  568 +
  569 + @Test//55
  570 + public void testWarnWithMarkerStringAndObjectArray() {
  571 + Marker marker = null;
  572 + Object[] obj = null;
  573 + this.logger.warn(marker,"",obj);
  574 + PowerMock.replay(LoggerFactory.class, this.logger);
  575 + this.slf4jLoggerProxy.warn(marker,"",obj);
  576 + PowerMock.verify(this.logger);
  577 + }
  578 +
  579 + @Test//56
  580 + public void testWarnWithMarkerStringAndThrowable() {
  581 + Marker marker = null;
  582 + Throwable t = null;
  583 + this.logger.warn(marker,"",t);
  584 + PowerMock.replay(LoggerFactory.class, this.logger);
  585 + this.slf4jLoggerProxy.warn(marker,"",t);
  586 + PowerMock.verify(this.logger);
  587 + }
  588 +
  589 + @Test//57
  590 + public void testWarnWithString() {
  591 + this.logger.warn("");
  592 + PowerMock.replay(LoggerFactory.class, this.logger);
  593 + this.slf4jLoggerProxy.warn("");
  594 + PowerMock.verify(this.logger);
  595 + }
  596 +
  597 + @Test//58
  598 + public void testWarnWithStringAndOneObject() {
  599 + Object obj = null;
  600 + this.logger.warn("",obj);
  601 + PowerMock.replay(LoggerFactory.class, this.logger);
  602 + this.slf4jLoggerProxy.warn("",obj);
  603 + PowerMock.verify(this.logger);
  604 + }
  605 +
  606 + @Test//59
  607 + public void testWarnWithStringAndTwoObjects() {
  608 + Object obj1 = null, obj2 = null;
  609 + this.logger.warn("",obj1,obj2);
  610 + PowerMock.replay(LoggerFactory.class, this.logger);
  611 + this.slf4jLoggerProxy.warn("",obj1,obj2);
  612 + PowerMock.verify(this.logger);
  613 + }
  614 +
  615 + @Test//60
  616 + public void testWarnWithStringAndObjectArray() {
  617 + Object[] obj = null;
  618 + this.logger.warn("",obj);
  619 + PowerMock.replay(LoggerFactory.class, this.logger);
  620 + this.slf4jLoggerProxy.warn("",obj);
  621 + PowerMock.verify(this.logger);
  622 + }
  623 +
  624 + @Test//61
  625 + public void testWarnWithStringAndThrowable() {
  626 + Throwable t = null;
  627 + this.logger.warn("",t);
  628 + PowerMock.replay(LoggerFactory.class, this.logger);
  629 + this.slf4jLoggerProxy.warn("",t);
  630 + PowerMock.verify(this.logger);
  631 + }
575 } 632 }