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 72 expect(LoggerFactory.getLogger(EasyMock.anyObject(Class.class))).andReturn(logger);
73 73 }
74 74  
75   - @Test
  75 + @Test//1
76 76 public void testDebugWithMarkerAndString() {
77 77 Marker marker = null;
78 78 this.logger.debug(marker,"");
... ... @@ -81,7 +81,7 @@ public class Slf4jLoggerProxyTest {
81 81 PowerMock.verify(this.logger);
82 82 }
83 83  
84   - @Test
  84 + @Test//2
85 85 public void testDebugWithMarkerStringAndOneObject() {
86 86 Marker marker = null;
87 87 Object obj = null;
... ... @@ -91,485 +91,542 @@ public class Slf4jLoggerProxyTest {
91 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 }
... ...