|
1
16 package org.apache.commons.lang.exception;
17
18 import java.io.ByteArrayOutputStream  ;
19 import java.io.EOFException ;
20 import java.io.IOException ;
21 import java.io.PrintStream ;
22 import java.io.PrintWriter ;
23
24 import junit.framework.Test;
25 import junit.framework.TestSuite;
26 import junit.textui.TestRunner;
27
28
35 public class NestableDelegateTestCase extends junit.framework.TestCase {
36 private static final String CONSTRUCTOR_FAILED_MSG =
37 "The Nestable implementation passed to the NestableDelegate(Nestable) constructor must extend java.lang.Throwable";
38
39 private static final String PARTIAL_STACK_TRACE =
40 "ThrowableNestedNestable partial stack trace place-holder";
41
42 protected String lineSeparator;
43
44
47 public NestableDelegateTestCase(String name)
48 {
49 super(name);
50 }
51
52
55 public void setUp()
56 {
57 lineSeparator = System.getProperty("line.separator");
58 }
59
60 public static Test suite()
61 {
62 return new TestSuite(NestableDelegateTestCase.class);
63 }
64
65
68 public void tearDown()
69 {
70 lineSeparator = null;
71 }
72
73
76 public void testNestableDelegateConstructor()
77 {
78 String msg = null;
79 boolean constructorFailed = false;
80 try
81 {
82 NestableDelegate nonThrowableCause = new NestableDelegate(new NonThrowableNestable());
83 }
84 catch(IllegalArgumentException iae)
85 {
86 constructorFailed = true;
87 msg = iae.getMessage();
88 }
89 assertTrue("nestable delegate constructor with non-throwable cause failed == true", constructorFailed);
90 assertTrue("constructor failed exception msg == " + CONSTRUCTOR_FAILED_MSG,
91 msg.equals(CONSTRUCTOR_FAILED_MSG));
92
93 constructorFailed = false;
94 try
95 {
96 NestableDelegate nd1 = new NestableDelegate(new ThrowableNestable());
97 }
98 catch(IllegalArgumentException iae)
99 {
100 constructorFailed = true;
101 }
102 assertTrue("nestable delegate constructor with throwable cause failed == false", !constructorFailed);
103 }
104
105 public void testNestableDelegateGetMessage()
106 {
107 Nestable ne1 = new ThrowableNestable();
108 assertTrue("ThrowableNestable ne1 getMessage() == ThrowableNestable exception",
109 ne1.getMessage().equals("ThrowableNestable exception"));
110 NestableDelegate nd1 = new NestableDelegate(ne1);
111 assertTrue("nd1 getMessage() == " + ne1.getCause().getMessage(),
112 nd1.getMessage("base").equals("base: " + ne1.getCause().getMessage()));
113
114 Nestable ne2 = new ThrowableNestedNestable(new Exception ("nested exception 2"));
115 NestableDelegate nd2 = new NestableDelegate(ne2);
116 assertTrue("nd2 getMessage() == base: " + ne2.getCause().getMessage(),
117 nd2.getMessage("base").equals("base: " + ne2.getCause().getMessage()));
118 }
119
120 public void testNestableDelegateGetThrowableCount()
121 {
122 Nestable n = null;
123 NestableDelegate d = null;
124
125 n = new NestableDelegateTester1();
126 d = new NestableDelegate(n);
127 doNestableDelegateGetThrowableCount(d, 1);
128
129 n = new NestableDelegateTester1("level 1");
130 d = new NestableDelegate(n);
131 doNestableDelegateGetThrowableCount(d, 1);
132
133 n = new NestableDelegateTester1(new Exception ());
134 d = new NestableDelegate(n);
135 doNestableDelegateGetThrowableCount(d, 2);
136
137 n = new NestableDelegateTester1(new Exception ("level 2"));
138 d = new NestableDelegate(n);
139 doNestableDelegateGetThrowableCount(d, 2);
140
141 n = new NestableDelegateTester1("level 1",
142 new NestableDelegateTester2("level 2",
143 new NestableDelegateTester1(
144 new NestableDelegateTester2("level 4",
145 new Exception ("level 5")
146 )
147 )
148 )
149 );
150 d = new NestableDelegate(n);
151 doNestableDelegateGetThrowableCount(d, 5);
152 }
153
154 private void doNestableDelegateGetThrowableCount(NestableDelegate d, int len)
155 {
156 assertEquals("delegate length", len, d.getThrowableCount());
158 }
159
160 public void testNestableDelegateGetMessages()
161 {
162 Nestable n = null;
163 NestableDelegate d = null;
164 String msgs[] = null;
165
166 msgs = new String [1];
167 n = new NestableDelegateTester1();
168 d = new NestableDelegate(n);
169 doNestableDelegateGetMessages(d, msgs);
170
171 msgs = new String [1];
172 msgs[0] = "level 1";
173 n = new NestableDelegateTester1(msgs[0]);
174 d = new NestableDelegate(n);
175 doNestableDelegateGetMessages(d, msgs);
176
177 msgs = new String [2];
178 n = new NestableDelegateTester1(new Exception ());
179 d = new NestableDelegate(n);
180 doNestableDelegateGetMessages(d, msgs);
181
182 msgs = new String [2];
183 msgs[0] = null;
184 msgs[1] = "level 2";
185 n = new NestableDelegateTester1(new Exception (msgs[1]));
186 d = new NestableDelegate(n);
187 doNestableDelegateGetMessages(d, msgs);
188
189 msgs = new String [5];
190 msgs[0] = "level 1";
191 msgs[1] = "level 2";
192 msgs[2] = null;
193 msgs[3] = "level 4";
194 msgs[4] = "level 5";
195 n = new NestableDelegateTester1(msgs[0],
196 new NestableDelegateTester2(msgs[1],
197 new NestableDelegateTester1(
198 new NestableDelegateTester2(msgs[3],
199 new Exception (msgs[4])
200 )
201 )
202 )
203 );
204 d = new NestableDelegate(n);
205 doNestableDelegateGetMessages(d, msgs);
206 }
207
208 private void doNestableDelegateGetMessages(NestableDelegate d, String [] nMsgs)
209 {
210 String [] dMsgs = d.getMessages();
212 assertEquals("messages length", nMsgs.length, dMsgs.length);
213 for(int i = 0; i < nMsgs.length; i++)
214 {
215 assertEquals("message " + i, nMsgs[i], dMsgs[i]);
216 }
217 }
218
219 public void testNestableDelegateGetMessageN()
220 {
221 Nestable n = null;
222 NestableDelegate d = null;
223 String [] msgs = new String [5];
224 msgs[0] = "level 1";
225 msgs[1] = "level 2";
226 msgs[2] = null;
227 msgs[3] = "level 4";
228 msgs[4] = "level 5";
229 n = new NestableDelegateTester1(msgs[0],
230 new NestableDelegateTester2(msgs[1],
231 new NestableDelegateTester1(
232 new NestableDelegateTester2(msgs[3],
233 new Exception (msgs[4])
234 )
235 )
236 )
237 );
238 d = new NestableDelegate(n);
239 for(int i = 0; i < msgs.length; i++)
240 {
241 assertEquals("message " + i, msgs[i], d.getMessage(i));
242 }
243
244 try
246 {
247 String msg = d.getMessage(-1);
248 fail("getMessage(-1) should have thrown IndexOutOfBoundsException");
249 }
250 catch(IndexOutOfBoundsException ioode)
251 {
252 }
253 try
254 {
255 String msg = d.getMessage(msgs.length + 100);
256 fail("getMessage(999) should have thrown IndexOutOfBoundsException");
257 }
258 catch(IndexOutOfBoundsException ioode)
259 {
260 }
261 }
262
263 public void testNestableDelegateGetThrowableN()
264 {
265 Nestable n = null;
266 NestableDelegate d = null;
267 String msgs[] = null;
268 Class [] throwables = null;
269
270 msgs = new String [2];
271 msgs[0] = null;
272 msgs[1] = "level 2";
273 throwables = new Class [2];
274 throwables[0] = NestableDelegateTester1.class;
275 throwables[1] = Exception .class;
276 n = new NestableDelegateTester1(new Exception (msgs[1]));
277 d = new NestableDelegate(n);
278 doNestableDelegateGetThrowableN(d, throwables, msgs);
279
280 msgs = new String [5];
281 msgs[0] = "level 1";
282 msgs[1] = "level 2";
283 msgs[2] = null;
284 msgs[3] = "level 4";
285 msgs[4] = "level 5";
286 throwables = new Class [5];
287 throwables[0] = NestableDelegateTester1.class;
288 throwables[1] = NestableDelegateTester2.class;
289 throwables[2] = NestableDelegateTester1.class;
290 throwables[3] = NestableDelegateTester2.class;
291 throwables[4] = Exception .class;
292 n = new NestableDelegateTester1(msgs[0],
293 new NestableDelegateTester2(msgs[1],
294 new NestableDelegateTester1(
295 new NestableDelegateTester2(msgs[3],
296 new Exception (msgs[4])
297 )
298 )
299 )
300 );
301 d = new NestableDelegate(n);
302 doNestableDelegateGetThrowableN(d, throwables, msgs);
303 }
304
305 private void doNestableDelegateGetThrowableN(NestableDelegate d, Class [] classes, String [] msgs)
306 {
307 Throwable t = null;
308 String msg = null;
309
310 for(int i = 0; i < classes.length; i++)
311 {
312 t = d.getThrowable(i);
313 assertEquals("throwable class", classes[i], t.getClass());
314 if(Nestable.class.isInstance(t))
315 {
316 msg = ((Nestable) t).getMessage(0);
317 }
318 else
319 {
320 msg = t.getMessage();
321 }
322 assertEquals("throwable message", msgs[i], msg);
323 }
324
325 try
327 {
328 t = d.getThrowable(-1);
329 fail("getThrowable(-1) should have thrown IndexOutOfBoundsException");
330 }
331 catch(IndexOutOfBoundsException ioobe)
332 {
333 }
334 try
335 {
336 t = d.getThrowable(999);
337 fail("getThrowable(999) should have thrown IndexOutOfBoundsException");
338 }
339 catch(IndexOutOfBoundsException ioobe)
340 {
341 }
342 }
343
344 public void testNestableDelegateGetThrowables()
345 {
346 Nestable n = null;
347 NestableDelegate d = null;
348 String msgs[] = null;
349 Class [] throwables = null;
350
351 msgs = new String [2];
352 msgs[0] = null;
353 msgs[1] = "level 2";
354 throwables = new Class [2];
355 throwables[0] = NestableDelegateTester1.class;
356 throwables[1] = Exception .class;
357 n = new NestableDelegateTester1(new Exception (msgs[1]));
358 d = new NestableDelegate(n);
359 doNestableDelegateGetThrowables(d, throwables, msgs);
360
361 msgs = new String [5];
362 msgs[0] = "level 1";
363 msgs[1] = "level 2";
364 msgs[2] = null;
365 msgs[3] = "level 4";
366 msgs[4] = "level 5";
367 throwables = new Class [5];
368 throwables[0] = NestableDelegateTester1.class;
369 throwables[1] = NestableDelegateTester2.class;
370 throwables[2] = NestableDelegateTester1.class;
371 throwables[3] = NestableDelegateTester2.class;
372 throwables[4] = Exception .class;
373 n = new NestableDelegateTester1(msgs[0],
374 new NestableDelegateTester2(msgs[1],
375 new NestableDelegateTester1(
376 new NestableDelegateTester2(msgs[3],
377 new Exception (msgs[4])
378 )
379 )
380 )
381 );
382 d = new NestableDelegate(n);
383 doNestableDelegateGetThrowables(d, throwables, msgs);
384 }
385
386 private void doNestableDelegateGetThrowables(NestableDelegate d, Class [] classes, String [] msgs)
387 {
388 Throwable [] throwables = null;
389 String msg = null;
390
391 throwables = d.getThrowables();
392 assertEquals("throwables length", classes.length, throwables.length);
393 for(int i = 0; i < classes.length; i++)
394 {
395 assertEquals("throwable class", classes[i], throwables[i].getClass());
396 Throwable t = throwables[i];
397 if(Nestable.class.isInstance(t))
398 {
399 msg = ((Nestable) t).getMessage(0);
400 }
401 else
402 {
403 msg = t.getMessage();
404 }
405 assertEquals("throwable message", msgs[i], msg);
406 }
407 }
408
409 public void testIndexOfThrowable()
410 {
411 Nestable n = null;
412 NestableDelegate d = null;
413 String msgs[] = null;
414 Class [] throwables = null;
415
416 msgs = new String [5];
417 msgs[0] = "level 1";
418 msgs[1] = "level 2";
419 msgs[2] = null;
420 msgs[3] = "level 4";
421 msgs[4] = "level 5";
422 throwables = new Class [5];
423 throwables[0] = NestableDelegateTester1.class;
424 throwables[1] = NestableDelegateTester2.class;
425 throwables[2] = NestableDelegateTester1.class;
426 throwables[3] = NestableDelegateTester2.class;
427 throwables[4] = EOFException .class;
428 int[] indexes = {0, 1, 0, 1, 4};
429 n = new NestableDelegateTester1(msgs[0],
430 new NestableDelegateTester2(msgs[1],
431 new NestableDelegateTester1(
432 new NestableDelegateTester2(msgs[3],
433 new EOFException (msgs[4])
434 )
435 )
436 )
437 );
438 d = new NestableDelegate(n);
439 for(int i = 0; i < throwables.length; i++)
440 {
441 doNestableDelegateIndexOfThrowable(d, throwables[i], 0, indexes[i], msgs[indexes[i]]);
442 }
443 doNestableDelegateIndexOfThrowable(d, NestableDelegateTester2.class, 2, 3, msgs[3]);
444 doNestableDelegateIndexOfThrowable(d, NestableDelegateTester1.class, 1, 2, msgs[2]);
445 doNestableDelegateIndexOfThrowable(d, NestableDelegateTester1.class, 3, -1, null);
446 doNestableDelegateIndexOfThrowable(d, NestableDelegateTester1.class, 4, -1, null);
447 doNestableDelegateIndexOfThrowable(d, EOFException .class, 2, 4, msgs[4]);
448 doNestableDelegateIndexOfThrowable(d, IOException .class, 2, 4, msgs[4]);
449 doNestableDelegateIndexOfThrowable(d, Exception .class, 2, 2, msgs[2]);
450 doNestableDelegateIndexOfThrowable(d, Exception .class, 0, 0, msgs[0]);
451 doNestableDelegateIndexOfThrowable(d, java.util.Date .class, 0, -1, null);
452 doNestableDelegateIndexOfThrowable(d, null, 0, -1, null);
453
454 try
456 {
457 int index = d.indexOfThrowable(NestableDelegateTester1.class, -1);
458 fail("method should have thrown IndexOutOfBoundsException");
459 }
460 catch(IndexOutOfBoundsException iooob)
461 {
462 }
463 try
464 {
465 int index = d.indexOfThrowable(NestableDelegateTester1.class, 5);
466 fail("method should have thrown IndexOutOfBoundsException");
467 }
468 catch(IndexOutOfBoundsException iooob)
469 {
470 }
471 }
472
473 private void doNestableDelegateIndexOfThrowable(NestableDelegate d, Class type, int fromIndex, int expectedIndex, String expectedMsg)
474 {
475 Throwable t = null;
476
477 int index = d.indexOfThrowable(type, fromIndex);
478 assertEquals("index of throwable " + (type == null ? "null" : type.getName()), expectedIndex, index);
479 if(expectedIndex > -1)
480 {
481 t = d.getThrowable(index);
482 if(expectedMsg != null)
483 {
484 String msg = null;
485 if(Nestable.class.isInstance(t))
486 {
487 msg = ((Nestable) t).getMessage(0);
488 }
489 else
490 {
491 msg = t.getMessage();
492 }
493 assertEquals("message of indexed throwable", expectedMsg, msg);
494 }
495 }
496 }
497
498 public void testNestableDelegetePrintStackTrace()
499 {
500 int lineSepLen = lineSeparator.length();
501 int partialStackTraceLen = PARTIAL_STACK_TRACE.length();
502 Nestable ne3 = new ThrowableNestedNestable(new Exception ("nested exception 3"));
503 NestableDelegate nd3 = new NestableDelegate(ne3);
504
505 ByteArrayOutputStream baos1 = new ByteArrayOutputStream ();
506 PrintStream ps1 = new PrintStream (baos1);
507 nd3.printStackTrace(ps1);
508 String stack1 = baos1.toString();
509 assertTrue("stack trace startsWith", stack1.startsWith(PARTIAL_STACK_TRACE));
510
511 Nestable n = new NestableDelegateTester1("level 1",
512 new NestableDelegateTester2("level 2",
513 new NestableDelegateTester1(
514 new NestableDelegateTester2("level 4",
515 new Exception ("level 5")
516 )
517 )
518 )
519 );
520 NestableDelegate d = new NestableDelegate(n);
521
522 if (!ExceptionUtils.isThrowableNested()) {
524 NestableDelegate.topDown = true; NestableDelegate.trimStackFrames = true;
525 checkStackTrace(d, true, true, NestableDelegateTester1.class.getName()+": level 1", 24);
526 NestableDelegate.topDown = true; NestableDelegate.trimStackFrames = false;
527 checkStackTrace(d, true, false, NestableDelegateTester1.class.getName()+": level 1", 80);
528 NestableDelegate.topDown = false; NestableDelegate.trimStackFrames = true;
529 checkStackTrace(d, false, true, "java.lang.Exception: level 5", 24);
530 NestableDelegate.topDown = false; NestableDelegate.trimStackFrames = false;
531 checkStackTrace(d, false, false, "java.lang.Exception: level 5", 80);
532 NestableDelegate.topDown = true; NestableDelegate.trimStackFrames = true;
533 }
534 }
535 private void checkStackTrace(NestableDelegate d, boolean topDown, boolean trimStackFrames,
536 String startsWith, int expCount) {
537 ByteArrayOutputStream baos1 = new ByteArrayOutputStream ();
538 PrintStream ps1 = new PrintStream (baos1);
539 d.printStackTrace(ps1);
540 String stack1 = baos1.toString();
541 int actCount = countLines(stack1);
542 assertTrue("topDown: "+topDown+", trimStackFrames: "+trimStackFrames+" startsWith",
543 stack1.startsWith(startsWith));
544 }
548 private int countLines(String s) {
549 if (s == null) return 0;
550
551 int i = 0, ndx = -1;
552 while ((ndx = s.indexOf("\n", ndx+1)) != -1) {
553 i++;
554 }
555 return i;
556 }
557
558 public static void main(String args[])
559 {
560 TestRunner.run(suite());
561 }
562 }
563
564
569 class NestableDelegateTester1 extends Exception implements Nestable
570 {
571 private Throwable cause = null;
572
573 public NestableDelegateTester1()
574 {
575 super();
576 }
577
578 public NestableDelegateTester1(String reason, Throwable cause)
579 {
580 super(reason);
581 this.cause = cause;
582 }
583
584 public NestableDelegateTester1(String reason)
585 {
586 super(reason);
587 }
588
589 public NestableDelegateTester1(Throwable cause)
590 {
591 super();
592 this.cause = cause;
593 }
594
595
599 public Throwable [] getThrowables()
600 {
601 return new Throwable [0];
602 }
603
604
608 public String [] getMessages()
609 {
610 return new String [0];
611 }
612
613
617 public int indexOfThrowable(Class type)
618 {
619 return -1;
620 }
621
622
626 public Throwable getThrowable(int index)
627 {
628 return null;
629 }
630
631
635 public int getThrowableCount()
636 {
637 return 1;
638 }
639
640
643 public Throwable getCause()
644 {
645 return cause;
646 }
647
648
654 public void printPartialStackTrace(PrintWriter out)
655 {
656 super.printStackTrace(out);
657 }
658
659
662 public String getMessage(int index)
663 {
664 if(index == 0)
665 {
666 return super.getMessage();
667 }
668 else
669 {
670 return "";
671 }
672 }
673
674
678 public int indexOfThrowable(Class type, int fromIndex)
679 {
680 return -1;
681 }
682
683 }
684
685
690 class NestableDelegateTester2 extends Throwable implements Nestable
691 {
692 private Throwable cause = null;
693
694 public NestableDelegateTester2()
695 {
696 super();
697 }
698
699 public NestableDelegateTester2(String reason, Throwable cause)
700 {
701 super(reason);
702 this.cause = cause;
703 }
704
705 public NestableDelegateTester2(String reason)
706 {
707 super(reason);
708 }
709
710 public NestableDelegateTester2(Throwable cause)
711 {
712 super();
713 this.cause = cause;
714 }
715
716
720 public Throwable [] getThrowables()
721 {
722 return new Throwable [0];
723 }
724
725
729 public String [] getMessages()
730 {
731 return new String [0];
732 }
733
734
738 public int indexOfThrowable(Class type)
739 {
740 return -1;
741 }
742
743
747 public Throwable getThrowable(int index)
748 {
749 return null;
750 }
751
752
758 public int getThrowableCount()
759 {
760 return 1;
761 }
762
763
766 public Throwable getCause()
767 {
768 return cause;
769 }
770
771
777 public void printPartialStackTrace(PrintWriter out)
778 {
779 super.printStackTrace(out);
780 }
781
782
785 public String getMessage(int index)
786 {
787 if(index == 0)
788 {
789 return super.getMessage();
790 }
791 else
792 {
793 return "";
794 }
795 }
796
797
801 public int indexOfThrowable(Class type, int fromIndex)
802 {
803 return -1;
804 }
805
806 }
807
808
813 class ThrowableNestable extends Throwable implements Nestable
814 {
815 private Throwable cause = new Exception ("ThrowableNestable cause");
816
817
821 public int getThrowableCount()
822 {
823 return 1;
824 }
825
826
831 public String getMessage()
832 {
833 return "ThrowableNestable exception";
834 }
835
836
841 public String getMessage(int index)
842 {
843 return getMessage();
844 }
845
846
850 public String [] getMessages()
851 {
852 String msgs[] = new String [1];
853 msgs[0] = getMessage();
854 return msgs;
855 }
856
857
860 public Throwable getCause()
861 {
862 return cause;
863 }
864
865
870 public void printStackTrace(PrintWriter out)
871 {
872 }
873
874
879 public void printPartialStackTrace(PrintWriter out)
880 {
881 }
882
883
886 public Throwable getThrowable(int index)
887 {
888 return cause;
889 }
890
891
894 public Throwable [] getThrowables()
895 {
896 Throwable throwables[] = new Throwable [1];
897 throwables[0] = cause;
898 return throwables;
899 }
900
901
904 public int indexOfThrowable(Class type)
905 {
906 if(Exception .class.isInstance(type))
907 {
908 return 0;
909 }
910 return -1;
911 }
912
913
916 public int indexOfThrowable(Class type, int fromIndex)
917 {
918 return indexOfThrowable(type);
919 }
920
921 }
922
923
928 class ThrowableNestedNestable extends Throwable implements Nestable
929 {
930 private Throwable cause = null;
931
932 public ThrowableNestedNestable(Throwable cause)
933 {
934 this.cause = cause;
935 }
936
937
941 public int getThrowableCount()
942 {
943 return 1;
944 }
945
946
951 public String getMessage()
952 {
953 return "ThrowableNestedNestable exception (" + cause.getMessage() + ")";
954 }
955
956
961 public String getMessage(int index)
962 {
963 return "ThrowableNestedNestable exception (" + cause.getMessage() + ")";
964 }
965
966
972 public String [] getMessages()
973 {
974 String [] msgs = new String [1];
975 msgs[0] = "ThrowableNestedNestable exception (" + cause.getMessage() + ")";
976 return msgs;
977 }
978
979
982 public Throwable getCause()
983 {
984 return cause;
985 }
986
987
992 public void printStackTrace(PrintWriter out)
993 {
994 out.println("ThrowableNestedNestable stack trace place-holder");
995 }
996
997
1003 public void printPartialStackTrace(PrintWriter out)
1004 {
1005 out.println("ThrowableNestedNestable partial stack trace place-holder");
1006 }
1007
1008
1011 public Throwable getThrowable(int index)
1012 {
1013 return cause;
1014 }
1015
1016
1019 public Throwable [] getThrowables()
1020 {
1021 Throwable throwables[] = new Throwable [1];
1022 throwables[0] = cause;
1023 return throwables;
1024 }
1025
1026
1029 public int indexOfThrowable(Class type)
1030 {
1031 if(Exception .class.isInstance(type))
1032 {
1033 return 0;
1034 }
1035 return -1;
1036 }
1037
1038
1041 public int indexOfThrowable(Class type, int fromIndex)
1042 {
1043 return indexOfThrowable(type);
1044 }
1045
1046}
1047
1048
1051class NonThrowableNestable implements Nestable
1052{
1053
1057 public int getThrowableCount()
1058 {
1059 return 1;
1060 }
1061
1062
1066 public String getMessage()
1067 {
1068 return "non-throwable";
1069 }
1070
1071
1075 public String getMessage(int index)
1076 {
1077 return "non-throwable";
1078 }
1079
1080
1085 public String [] getMessages()
1086 {
1087 String [] msgs = new String [1];
1088 msgs[0] = "non-throwable";
1089 return msgs;
1090 }
1091
1092
1096 public Throwable getCause()
1097 {
1098 return null;
1099 }
1100
1101
1106 public void printStackTrace(PrintWriter out)
1107 {
1108 }
1109
1110
1115 public void printStackTrace(PrintStream out)
1116 {
1117 }
1118
1119
1124 public void printPartialStackTrace(PrintWriter out)
1125 {
1126 }
1127
1128
1129
1133 public Throwable getThrowable(int index)
1134 {
1135 return null;
1136 }
1137
1138
1142 public Throwable [] getThrowables()
1143 {
1144 return new Throwable [0];
1145 }
1146
1147
1151 public int indexOfThrowable(Class type)
1152 {
1153 return -1;
1154 }
1155
1156
1160 public int indexOfThrowable(Class type, int fromIndex)
1161 {
1162 return -1;
1163 }
1164
1165}
1166 |
Popular Tags |
Java API By Example, From Geeks To Geeks.