Coverage Report

Coverage Report - org.apache.maven.surefire.util.NestedRuntimeException

Classes in this File

Line Coverage

Branch Coverage

Complexity

NestedRuntimeException

0 %

0/32

0 %

0/20

2,5

 package org.apache.maven.surefire.util;
 
 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 
 /*
  * Copyright 2002-2005 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 import java.io.PrintStream;
 import java.io.PrintWriter;
 
 /**
  * <p>Copied from Spring framework to keep Java 1.3 compatability.</p>
  * <p/>
  * <p>Handy class for wrapping runtime Exceptions with a root cause.</p>
  * <p/>
  * <p>This time-honoured technique is no longer necessary in Java 1.4, which
  * finally provides built-in support for exception nesting. Thus exceptions in
  * applications written to use Java 1.4 need not extend this class. To ease
  * migration, this class mirrors Java 1.4's nested exceptions as closely as possible.
  * <p/>
  * <p>Abstract to force the programmer to extend the class. <code>getMessage</code>
  * will include nested exception information; <code>printStackTrace</code> etc will
  * delegate to the wrapped exception, if any.
  * <p/>
  * <p>The similarity between this class and the NestedCheckedException class is
  * unavoidable, as Java forces these two classes to have different superclasses
  * (ah, the inflexibility of concrete inheritance!).
  * <p/>
  * <p>As discussed in
  * <a href="http://www.amazon.com/exec/obidos/tg/detail/-/0764543857/">Expert One-On-One J2EE Design and
  * Development</a>, runtime exceptions are often a better alternative to checked exceptions.
  * However, all exceptions should preserve their stack trace, if caused by a
  * lower-level exception.
  *
  * @author Rod Johnson
  * @author Juergen Hoeller
  * @see #getMessage
  * @see #printStackTrace
  * @see NestedCheckedException
  */
 public class NestedRuntimeException
     extends RuntimeException
 {
 
     /**
      * Root cause of this nested exception
      */
     private final Throwable cause;
 
     /**
      * Construct a <code>NestedRuntimeException</code> with the specified detail message
      * and nested exception.
      *
      * @param msg the detail message
      * @param ex  the nested exception
      */
     public NestedRuntimeException( String msg, Throwable ex )
     {
         super( msg );
         this.cause = ex;
     }
 
     /**
      * Construct a <code>NestedRuntimeException</code> with the specified nested exception.
      *
      * @param ex the nested exception
      */
     public NestedRuntimeException( Throwable ex )
     {
         super();
         this.cause = ex;
     }
 
     /**
      * Return the nested cause, or <code>null</code> if none.
      * <p>Note that this will only check one level of nesting.
      * Use <code>getRootCause()</code> to retrieve the innermost cause.
      *
      * @see #getRootCause()
      */
     public Throwable getCause()
     {
         // Even if you cannot set the cause of this exception other than through
         // the constructor, we check for the cause being "this" here, as the cause
         // could still be set to "this" via reflection: for example, by a remoting
         // deserializer like Hessian's.
         return ( this.cause == this ? null : this.cause );
     }
 
     /**
      * Return the detail message, including the message from the nested exception
      * if there is one.
      */
     public String getMessage()
     {
         if ( getCause() == null )
         {
             return super.getMessage();
         }
         else
         {
             return super.getMessage() + "; nested exception is " + getCause().getClass().getName() + ": "
                 + getCause().getMessage();
         }
     }
 
     /**
      * Print the composite message and the embedded stack trace to the specified stream.
      *
      * @param ps the print stream
      */
     public void printStackTrace( PrintStream ps )
     {
         if ( getCause() == null )
         {
             super.printStackTrace( ps );
         }
         else
         {
             ps.println( this );
             getCause().printStackTrace( ps );
         }
     }
 
     /**
      * Print the composite message and the embedded stack trace to the specified writer.
      *
      * @param pw the print writer
      */
     public void printStackTrace( PrintWriter pw )
     {
         if ( getCause() == null )
         {
             super.printStackTrace( pw );
         }
         else
         {
             pw.println( this );
             getCause().printStackTrace( pw );
         }
     }
 
     /**
      * Retrieve the innermost cause of this exception, if any.
      * <p>Currently just traverses NestedRuntimeException causes. Will use
      * the JDK 1.4 exception cause mechanism once Spring requires JDK 1.4.
      *
      * @return the innermost exception, or <code>null</code> if none
      */
     public Throwable getRootCause()
     {
         Throwable cause = getCause();
         if ( cause instanceof NestedRuntimeException )
         {
             return ( (NestedRuntimeException) cause ).getRootCause();
         }
         else
         {
             return cause;
         }
     }
 
     /**
      * Check whether this exception contains an exception of the given class:
      * either it is of the given class itself or it contains a nested cause
      * of the given class.
      * <p>Currently just traverses NestedRuntimeException causes. Will use
      * the JDK 1.4 exception cause mechanism once Spring requires JDK 1.4.
      *
      * @param exClass the exception class to look for
      * @return true if the class is contained
      */
     public boolean contains( Class exClass )
     {
         if ( exClass == null )
         {
             return false;
         }
         if ( exClass.isInstance( this ) )
         {
             return true;
         }
         Throwable cause = getCause();
         if ( cause instanceof NestedRuntimeException )
         {
             return ( (NestedRuntimeException) cause ).contains( exClass );
         }
         else
         {
             return ( cause != null && exClass.isInstance( cause ) );
         }
     }
 
 }

1		package org.apache.maven.surefire.util;
2
3		/*
4		* Licensed to the Apache Software Foundation (ASF) under one
5		* or more contributor license agreements. See the NOTICE file
6		* distributed with this work for additional information
7		* regarding copyright ownership. The ASF licenses this file
8		* to you under the Apache License, Version 2.0 (the
9		* "License"); you may not use this file except in compliance
10		* with the License. You may obtain a copy of the License at
11		*
12		* http://www.apache.org/licenses/LICENSE-2.0
13		*
14		* Unless required by applicable law or agreed to in writing,
15		* software distributed under the License is distributed on an
16		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17		* KIND, either express or implied. See the License for the
18		* specific language governing permissions and limitations
19		* under the License.
20		*/
21
22		/*
23		* Copyright 2002-2005 the original author or authors.
24		*
25		* Licensed under the Apache License, Version 2.0 (the "License");
26		* you may not use this file except in compliance with the License.
27		* You may obtain a copy of the License at
28		*
29		* http://www.apache.org/licenses/LICENSE-2.0
30		*
31		* Unless required by applicable law or agreed to in writing, software
32		* distributed under the License is distributed on an "AS IS" BASIS,
33		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
34		* See the License for the specific language governing permissions and
35		* limitations under the License.
36		*/
37
38		import java.io.PrintStream;
39		import java.io.PrintWriter;
40
41		/**
42		* <p>Copied from Spring framework to keep Java 1.3 compatability.</p>
43		* <p/>
44		* <p>Handy class for wrapping runtime Exceptions with a root cause.</p>
45		* <p/>
46		* <p>This time-honoured technique is no longer necessary in Java 1.4, which
47		* finally provides built-in support for exception nesting. Thus exceptions in
48		* applications written to use Java 1.4 need not extend this class. To ease
49		* migration, this class mirrors Java 1.4's nested exceptions as closely as possible.
50		* <p/>
51		* <p>Abstract to force the programmer to extend the class. <code>getMessage</code>
52		* will include nested exception information; <code>printStackTrace</code> etc will
53		* delegate to the wrapped exception, if any.
54		* <p/>
55		* <p>The similarity between this class and the NestedCheckedException class is
56		* unavoidable, as Java forces these two classes to have different superclasses
57		* (ah, the inflexibility of concrete inheritance!).
58		* <p/>
59		* <p>As discussed in
60		* <a href="http://www.amazon.com/exec/obidos/tg/detail/-/0764543857/">Expert One-On-One J2EE Design and
61		* Development</a>, runtime exceptions are often a better alternative to checked exceptions.
62		* However, all exceptions should preserve their stack trace, if caused by a
63		* lower-level exception.
64		*
65		* @author Rod Johnson
66		* @author Juergen Hoeller
67		* @see #getMessage
68		* @see #printStackTrace
69		* @see NestedCheckedException
70		*/
71		public class NestedRuntimeException
72		extends RuntimeException
73		{
74
75		/**
76		* Root cause of this nested exception
77		*/
78		private final Throwable cause;
79
80		/**
81		* Construct a <code>NestedRuntimeException</code> with the specified detail message
82		* and nested exception.
83		*
84		* @param msg the detail message
85		* @param ex the nested exception
86		*/
87		public NestedRuntimeException( String msg, Throwable ex )
88		{
89	0	super( msg );
90	0	this.cause = ex;
91	0	}
92
93		/**
94		* Construct a <code>NestedRuntimeException</code> with the specified nested exception.
95		*
96		* @param ex the nested exception
97		*/
98		public NestedRuntimeException( Throwable ex )
99		{
100	0	super();
101	0	this.cause = ex;
102	0	}
103
104		/**
105		* Return the nested cause, or <code>null</code> if none.
106		* <p>Note that this will only check one level of nesting.
107		* Use <code>getRootCause()</code> to retrieve the innermost cause.
108		*
109		* @see #getRootCause()
110		*/
111		public Throwable getCause()
112		{
113		// Even if you cannot set the cause of this exception other than through
114		// the constructor, we check for the cause being "this" here, as the cause
115		// could still be set to "this" via reflection: for example, by a remoting
116		// deserializer like Hessian's.
117	0	return ( this.cause == this ? null : this.cause );
118		}
119
120		/**
121		* Return the detail message, including the message from the nested exception
122		* if there is one.
123		*/
124		public String getMessage()
125		{
126	0	if ( getCause() == null )
127		{
128	0	return super.getMessage();
129		}
130		else
131		{
132	0	return super.getMessage() + "; nested exception is " + getCause().getClass().getName() + ": "
133		+ getCause().getMessage();
134		}
135		}
136
137		/**
138		* Print the composite message and the embedded stack trace to the specified stream.
139		*
140		* @param ps the print stream
141		*/
142		public void printStackTrace( PrintStream ps )
143		{
144	0	if ( getCause() == null )
145		{
146	0	super.printStackTrace( ps );
147		}
148		else
149		{
150	0	ps.println( this );
151	0	getCause().printStackTrace( ps );
152		}
153	0	}
154
155		/**
156		* Print the composite message and the embedded stack trace to the specified writer.
157		*
158		* @param pw the print writer
159		*/
160		public void printStackTrace( PrintWriter pw )
161		{
162	0	if ( getCause() == null )
163		{
164	0	super.printStackTrace( pw );
165		}
166		else
167		{
168	0	pw.println( this );
169	0	getCause().printStackTrace( pw );
170		}
171	0	}
172
173		/**
174		* Retrieve the innermost cause of this exception, if any.
175		* <p>Currently just traverses NestedRuntimeException causes. Will use
176		* the JDK 1.4 exception cause mechanism once Spring requires JDK 1.4.
177		*
178		* @return the innermost exception, or <code>null</code> if none
179		*/
180		public Throwable getRootCause()
181		{
182	0	Throwable cause = getCause();
183	0	if ( cause instanceof NestedRuntimeException )
184		{
185	0	return ( (NestedRuntimeException) cause ).getRootCause();
186		}
187		else
188		{
189	0	return cause;
190		}
191		}
192
193		/**
194		* Check whether this exception contains an exception of the given class:
195		* either it is of the given class itself or it contains a nested cause
196		* of the given class.
197		* <p>Currently just traverses NestedRuntimeException causes. Will use
198		* the JDK 1.4 exception cause mechanism once Spring requires JDK 1.4.
199		*
200		* @param exClass the exception class to look for
201		* @return true if the class is contained
202		*/
203		public boolean contains( Class exClass )
204		{
205	0	if ( exClass == null )
206		{
207	0	return false;
208		}
209	0	if ( exClass.isInstance( this ) )
210		{
211	0	return true;
212		}
213	0	Throwable cause = getCause();
214	0	if ( cause instanceof NestedRuntimeException )
215		{
216	0	return ( (NestedRuntimeException) cause ).contains( exClass );
217		}
218		else
219		{
220	0	return ( cause != null && exClass.isInstance( cause ) );
221		}
222		}
223
224		}