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 super( msg ); 90 this.cause = ex; 91 } 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 super(); 101 this.cause = ex; 102 } 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 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 if ( getCause() == null ) 127 { 128 return super.getMessage(); 129 } 130 else 131 { 132 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 if ( getCause() == null ) 145 { 146 super.printStackTrace( ps ); 147 } 148 else 149 { 150 ps.println( this ); 151 getCause().printStackTrace( ps ); 152 } 153 } 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 if ( getCause() == null ) 163 { 164 super.printStackTrace( pw ); 165 } 166 else 167 { 168 pw.println( this ); 169 getCause().printStackTrace( pw ); 170 } 171 } 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 Throwable cause = getCause(); 183 if ( cause instanceof NestedRuntimeException ) 184 { 185 return ( (NestedRuntimeException) cause ).getRootCause(); 186 } 187 else 188 { 189 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 if ( exClass == null ) 206 { 207 return false; 208 } 209 if ( exClass.isInstance( this ) ) 210 { 211 return true; 212 } 213 Throwable cause = getCause(); 214 if ( cause instanceof NestedRuntimeException ) 215 { 216 return ( (NestedRuntimeException) cause ).contains( exClass ); 217 } 218 else 219 { 220 return ( cause != null && exClass.isInstance( cause ) ); 221 } 222 } 223 224 }