KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > commons > lang > exception > NestableRuntimeExceptionTestCase


1 /*
2  * Copyright 2002-2005 The Apache Software Foundation.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package org.apache.commons.lang.exception;
17
18 import java.io.ByteArrayOutputStream JavaDoc;
19 import java.io.EOFException JavaDoc;
20 import java.io.PrintStream JavaDoc;
21
22 import junit.framework.Test;
23 import junit.framework.TestSuite;
24 import junit.textui.TestRunner;
25
26 /**
27  * Tests the org.apache.commons.lang.exception.NestableRuntimeException class.
28  *
29  * @author <a HREF="mailto:steven@caswell.name">Steven Caswell</a>
30  * @version $Id: NestableRuntimeExceptionTestCase.java 161244 2005-04-14 06:16:36Z ggregory $
31  */
32 public class NestableRuntimeExceptionTestCase extends AbstractNestableTestCase {
33     
34     /**
35      * Construct a new instance of
36      * <code>NestableRuntimeExceptionTestCase</code>.
37      *
38      * @param name test case name
39      */
40     public NestableRuntimeExceptionTestCase(String JavaDoc name)
41     {
42         super(name);
43     }
44
45     /**
46      * Sets up instance variables required by this test case.
47      */
48     public void setUp()
49     {
50     }
51     
52     /**
53      * Returns the test suite
54      *
55      * @return the test suite
56      */
57     public static Test suite()
58     {
59         return new TestSuite(NestableRuntimeExceptionTestCase.class);
60     }
61     
62     /**
63      * Tears down instance variables required by this test case.
64      */
65     public void tearDown()
66     {
67     }
68     
69     /**
70      * Command line entry point for running the test suite.
71      *
72      * @param args array of command line arguments
73      */
74     public static void main(String JavaDoc args[])
75     {
76         TestRunner.run(suite());
77     }
78     
79     /**
80      * @see AbstractNestableTestCase#getNestable()
81      */
82     public Nestable getNestable()
83     {
84         return new NestableRuntimeException();
85     }
86     
87     /**
88      * @see AbstractNestableTestCase#getNestable(Nestable)
89      */
90     public Nestable getNestable(Nestable n)
91     {
92         return new NestableRuntimeException((Throwable JavaDoc) n);
93     }
94     
95     /**
96      * @see AbstractNestableTestCase#getNestable(String)
97      */
98     public Nestable getNestable(String JavaDoc msg)
99     {
100         return new NestableRuntimeException(msg);
101     }
102     
103     /**
104      * @see AbstractNestableTestCase#getNestable(Throwable)
105      */
106     public Nestable getNestable(Throwable JavaDoc t)
107     {
108         return new NestableRuntimeException(t);
109     }
110     
111     /**
112      * @see AbstractNestableTestCase#getNestable(String, Throwable)
113      */
114     public Nestable getNestable(String JavaDoc msg, Throwable JavaDoc t)
115     {
116         return new NestableRuntimeException(msg, t);
117     }
118     
119     /**
120      * @see AbstractNestableTestCase#getNestable(String, Nestable)
121      */
122     public Nestable getNestable(String JavaDoc msg, Nestable n)
123     {
124         return new NestableRuntimeException(msg, (Throwable JavaDoc) n);
125     }
126     
127     /**
128      * @see AbstractNestableTestCase#getTester1(Throwable)
129      */
130     public Nestable getTester1(Throwable JavaDoc t)
131     {
132         return new NestableRuntimeExceptionTester1(t);
133     }
134     
135     /**
136      * @see AbstractNestableTestCase#getTester1(Nestable)
137      */
138     public Nestable getTester1(Nestable n)
139     {
140         return new NestableRuntimeExceptionTester1((Throwable JavaDoc) n);
141     }
142     
143     /**
144      * @see AbstractNestableTestCase#getTester1(String, Throwable)
145      */
146     public Nestable getTester1(String JavaDoc msg, Throwable JavaDoc t)
147     {
148         return new NestableRuntimeExceptionTester1(msg, t);
149     }
150     
151     /**
152      * @see AbstractNestableTestCase#getTester1(String, Nestable)
153      */
154     public Nestable getTester1(String JavaDoc msg, Nestable n)
155     {
156         return new NestableRuntimeExceptionTester1(msg, (Throwable JavaDoc) n);
157     }
158     
159     /**
160      * @see AbstractNestableTestCase#getTester1Class()
161      */
162     public Class JavaDoc getTester1Class()
163     {
164         return NestableRuntimeExceptionTester1.class;
165     }
166     
167     /**
168      * @see AbstractNestableTestCase#getTester2(String, Throwable)
169      */
170     public Nestable getTester2(String JavaDoc msg, Throwable JavaDoc t)
171     {
172         return new NestableRuntimeExceptionTester2(msg, t);
173     }
174     
175     /**
176      * @see AbstractNestableTestCase#getTester2(String, Nestable)
177      */
178     public Nestable getTester2(String JavaDoc msg, Nestable n)
179     {
180         return new NestableRuntimeExceptionTester2(msg, (Throwable JavaDoc) n);
181     }
182     
183     /**
184      * @see AbstractNestableTestCase#getTester2Class()
185      */
186     public Class JavaDoc getTester2Class()
187     {
188         return NestableRuntimeExceptionTester2.class;
189     }
190     
191     /**
192      * @see AbstractNestableTestCase#getThrowable(String)
193      */
194     public Throwable JavaDoc getThrowable(String JavaDoc msg)
195     {
196         return new EOFException JavaDoc(msg);
197     }
198     
199     /**
200      * @see AbstractNestableTestCase#getThrowableClass()
201      */
202     public Class JavaDoc getThrowableClass()
203     {
204         return EOFException JavaDoc.class;
205     }
206     
207     /**
208      * @see AbstractNestableTestCase#getBaseThrowableClass()
209      */
210     public Class JavaDoc getBaseThrowableClass()
211     {
212         return RuntimeException JavaDoc.class;
213     }
214     
215     public void testSpecificPrintStackTrace()
216     {
217         // Test printStackTrac()
218 // Replace System.err with our own PrintStream so that we can obtain
219 // and check the printStrackTrace output
220 ByteArrayOutputStream JavaDoc baos = new ByteArrayOutputStream JavaDoc();
221         PrintStream JavaDoc ps = new PrintStream JavaDoc(baos);
222         NestableRuntimeException ne = new NestableRuntimeException("outer", new NestableRuntimeException("inner", new Exception JavaDoc("another exception")));
223         for(int i = 0; i < 2; i++)
224         {
225             if(i == 0)
226             {
227                 // Test printStackTrac()
228 // Replace System.err with our own PrintStream so that we can
229 // obtain and check the printStrackTrace output
230 PrintStream JavaDoc err = System.err;
231                 System.setErr(ps);
232                 ne.printStackTrace();
233                 // Restore the System.err
234 System.setErr(err);
235             }
236             else
237             {
238                 // Test printStackTrace(PrintStream)
239 ne.printStackTrace(ps);
240             }
241         }
242         String JavaDoc msg = baos.toString();
243         assertTrue( "printStackTrace() starts with outer message", msg.startsWith("org.apache.commons.lang.exception.NestableRuntimeException: outer"));
244         assertTrue( "printStackTrace() contains 1st nested message", msg.indexOf("Caused by: org.apache.commons.lang.exception.NestableRuntimeException: inner") >= 0);
245         assertTrue( "printStackTrace() contains 2nd nested message", msg.indexOf("Caused by: java.lang.Exception: another exception") >= 0);
246         assertTrue( "printStackTrace() inner message after outer message",
247             msg.indexOf("org.apache.commons.lang.exception.NestableRuntimeException: outer") <
248             msg.indexOf("Caused by: org.apache.commons.lang.exception.NestableRuntimeException: inner"));
249         assertTrue( "printStackTrace() cause message after inner message",
250             msg.indexOf("Caused by: org.apache.commons.lang.exception.NestableRuntimeException: inner") <
251             msg.indexOf("Caused by: java.lang.Exception: another exception"));
252     }
253     
254 }
255
256 /**
257  * First nestable tester implementation for use in test cases.
258  */
259 class NestableRuntimeExceptionTester1 extends NestableRuntimeException
260 {
261     public NestableRuntimeExceptionTester1()
262     {
263         super();
264     }
265
266     public NestableRuntimeExceptionTester1(String JavaDoc reason, Throwable JavaDoc cause)
267     {
268         super(reason, cause);
269     }
270     
271     public NestableRuntimeExceptionTester1(String JavaDoc reason)
272     {
273         super(reason);
274     }
275     
276     public NestableRuntimeExceptionTester1(Throwable JavaDoc cause)
277     {
278         super(cause);
279     }
280     
281 }
282
283 /**
284  * Second nestable tester implementation.
285  */
286 class NestableRuntimeExceptionTester2 extends NestableRuntimeException
287 {
288     public NestableRuntimeExceptionTester2()
289     {
290         super();
291     }
292     
293     public NestableRuntimeExceptionTester2(String JavaDoc reason, Throwable JavaDoc cause)
294     {
295         super(reason, cause);
296     }
297     
298     public NestableRuntimeExceptionTester2(String JavaDoc reason)
299     {
300         super(reason);
301     }
302     
303     public NestableRuntimeExceptionTester2(Throwable JavaDoc cause)
304     {
305         super(cause);
306     }
307     
308 }
309
310
Popular Tags