001 package junit.runner; 002 003 import java.io.BufferedReader; 004 import java.io.File; 005 import java.io.FileInputStream; 006 import java.io.FileOutputStream; 007 import java.io.IOException; 008 import java.io.InputStream; 009 import java.io.PrintWriter; 010 import java.io.StringReader; 011 import java.io.StringWriter; 012 import java.lang.reflect.InvocationTargetException; 013 import java.lang.reflect.Method; 014 import java.lang.reflect.Modifier; 015 import java.text.NumberFormat; 016 import java.util.Properties; 017 018 import junit.framework.AssertionFailedError; 019 import junit.framework.Test; 020 import junit.framework.TestListener; 021 import junit.framework.TestSuite; 022 023 import org.junit.internal.Throwables; 024 025 /** 026 * Base class for all test runners. 027 * This class was born live on stage in Sardinia during XP2000. 028 */ 029 public abstract class BaseTestRunner implements TestListener { 030 public static final String SUITE_METHODNAME = "suite"; 031 032 private static Properties fPreferences; 033 static int fgMaxMessageLength = 500; 034 static boolean fgFilterStack = true; 035 boolean fLoading = true; 036 037 /* 038 * Implementation of TestListener 039 */ 040 public synchronized void startTest(Test test) { 041 testStarted(test.toString()); 042 } 043 044 protected static void setPreferences(Properties preferences) { 045 fPreferences = preferences; 046 } 047 048 protected static Properties getPreferences() { 049 if (fPreferences == null) { 050 fPreferences = new Properties(); 051 fPreferences.put("loading", "true"); 052 fPreferences.put("filterstack", "true"); 053 readPreferences(); 054 } 055 return fPreferences; 056 } 057 058 public static void savePreferences() throws IOException { 059 FileOutputStream fos = new FileOutputStream(getPreferencesFile()); 060 try { 061 getPreferences().store(fos, ""); 062 } finally { 063 fos.close(); 064 } 065 } 066 067 public static void setPreference(String key, String value) { 068 getPreferences().put(key, value); 069 } 070 071 public synchronized void endTest(Test test) { 072 testEnded(test.toString()); 073 } 074 075 public synchronized void addError(final Test test, final Throwable e) { 076 testFailed(TestRunListener.STATUS_ERROR, test, e); 077 } 078 079 public synchronized void addFailure(final Test test, final AssertionFailedError e) { 080 testFailed(TestRunListener.STATUS_FAILURE, test, e); 081 } 082 083 // TestRunListener implementation 084 085 public abstract void testStarted(String testName); 086 087 public abstract void testEnded(String testName); 088 089 public abstract void testFailed(int status, Test test, Throwable e); 090 091 /** 092 * Returns the Test corresponding to the given suite. This is 093 * a template method, subclasses override runFailed(), clearStatus(). 094 */ 095 public Test getTest(String suiteClassName) { 096 if (suiteClassName.length() <= 0) { 097 clearStatus(); 098 return null; 099 } 100 Class<?> testClass = null; 101 try { 102 testClass = loadSuiteClass(suiteClassName); 103 } catch (ClassNotFoundException e) { 104 String clazz = e.getMessage(); 105 if (clazz == null) { 106 clazz = suiteClassName; 107 } 108 runFailed("Class not found \"" + clazz + "\""); 109 return null; 110 } catch (Exception e) { 111 runFailed("Error: " + e.toString()); 112 return null; 113 } 114 Method suiteMethod = null; 115 try { 116 suiteMethod = testClass.getMethod(SUITE_METHODNAME); 117 } catch (Exception e) { 118 // try to extract a test suite automatically 119 clearStatus(); 120 return new TestSuite(testClass); 121 } 122 if (!Modifier.isStatic(suiteMethod.getModifiers())) { 123 runFailed("Suite() method must be static"); 124 return null; 125 } 126 Test test = null; 127 try { 128 test = (Test) suiteMethod.invoke(null); // static method 129 if (test == null) { 130 return test; 131 } 132 } catch (InvocationTargetException e) { 133 runFailed("Failed to invoke suite():" + e.getTargetException().toString()); 134 return null; 135 } catch (IllegalAccessException e) { 136 runFailed("Failed to invoke suite():" + e.toString()); 137 return null; 138 } 139 140 clearStatus(); 141 return test; 142 } 143 144 /** 145 * Returns the formatted string of the elapsed time. 146 */ 147 public String elapsedTimeAsString(long runTime) { 148 return NumberFormat.getInstance().format((double) runTime / 1000); 149 } 150 151 /** 152 * Processes the command line arguments and 153 * returns the name of the suite class to run or null 154 */ 155 protected String processArguments(String[] args) { 156 String suiteName = null; 157 for (int i = 0; i < args.length; i++) { 158 if (args[i].equals("-noloading")) { 159 setLoading(false); 160 } else if (args[i].equals("-nofilterstack")) { 161 fgFilterStack = false; 162 } else if (args[i].equals("-c")) { 163 if (args.length > i + 1) { 164 suiteName = extractClassName(args[i + 1]); 165 } else { 166 System.out.println("Missing Test class name"); 167 } 168 i++; 169 } else { 170 suiteName = args[i]; 171 } 172 } 173 return suiteName; 174 } 175 176 /** 177 * Sets the loading behaviour of the test runner 178 */ 179 public void setLoading(boolean enable) { 180 fLoading = enable; 181 } 182 183 /** 184 * Extract the class name from a String in VA/Java style 185 */ 186 public String extractClassName(String className) { 187 if (className.startsWith("Default package for")) { 188 return className.substring(className.lastIndexOf(".") + 1); 189 } 190 return className; 191 } 192 193 /** 194 * Truncates a String to the maximum length. 195 */ 196 public static String truncate(String s) { 197 if (fgMaxMessageLength != -1 && s.length() > fgMaxMessageLength) { 198 s = s.substring(0, fgMaxMessageLength) + "..."; 199 } 200 return s; 201 } 202 203 /** 204 * Override to define how to handle a failed loading of 205 * a test suite. 206 */ 207 protected abstract void runFailed(String message); 208 209 /** 210 * Returns the loaded Class for a suite name. 211 */ 212 protected Class<?> loadSuiteClass(String suiteClassName) throws ClassNotFoundException { 213 return Class.forName(suiteClassName); 214 } 215 216 /** 217 * Clears the status message. 218 */ 219 protected void clearStatus() { // Belongs in the GUI TestRunner class 220 } 221 222 protected boolean useReloadingTestSuiteLoader() { 223 return getPreference("loading").equals("true") && fLoading; 224 } 225 226 private static File getPreferencesFile() { 227 String home = System.getProperty("user.home"); 228 return new File(home, "junit.properties"); 229 } 230 231 private static void readPreferences() { 232 InputStream is = null; 233 try { 234 is = new FileInputStream(getPreferencesFile()); 235 setPreferences(new Properties(getPreferences())); 236 getPreferences().load(is); 237 } catch (IOException ignored) { 238 } catch (SecurityException ignored) { 239 } finally { 240 try { 241 if (is != null) { 242 is.close(); 243 } 244 } catch (IOException e1) { 245 } 246 } 247 } 248 249 public static String getPreference(String key) { 250 return getPreferences().getProperty(key); 251 } 252 253 public static int getPreference(String key, int dflt) { 254 String value = getPreference(key); 255 int intValue = dflt; 256 if (value == null) { 257 return intValue; 258 } 259 try { 260 intValue = Integer.parseInt(value); 261 } catch (NumberFormatException ne) { 262 } 263 return intValue; 264 } 265 266 /** 267 * Returns a filtered stack trace 268 */ 269 public static String getFilteredTrace(Throwable e) { 270 return BaseTestRunner.getFilteredTrace(Throwables.getStacktrace(e)); 271 } 272 273 /** 274 * Filters stack frames from internal JUnit classes 275 */ 276 public static String getFilteredTrace(String stack) { 277 if (showStackRaw()) { 278 return stack; 279 } 280 281 StringWriter sw = new StringWriter(); 282 PrintWriter pw = new PrintWriter(sw); 283 StringReader sr = new StringReader(stack); 284 BufferedReader br = new BufferedReader(sr); 285 286 String line; 287 try { 288 while ((line = br.readLine()) != null) { 289 if (!filterLine(line)) { 290 pw.println(line); 291 } 292 } 293 } catch (Exception IOException) { 294 return stack; // return the stack unfiltered 295 } 296 return sw.toString(); 297 } 298 299 protected static boolean showStackRaw() { 300 return !getPreference("filterstack").equals("true") || fgFilterStack == false; 301 } 302 303 static boolean filterLine(String line) { 304 String[] patterns = new String[]{ 305 "junit.framework.TestCase", 306 "junit.framework.TestResult", 307 "junit.framework.TestSuite", 308 "junit.framework.Assert.", // don't filter AssertionFailure 309 "junit.swingui.TestRunner", 310 "junit.awtui.TestRunner", 311 "junit.textui.TestRunner", 312 "java.lang.reflect.Method.invoke(" 313 }; 314 for (int i = 0; i < patterns.length; i++) { 315 if (line.indexOf(patterns[i]) > 0) { 316 return true; 317 } 318 } 319 return false; 320 } 321 322 static { 323 fgMaxMessageLength = getPreference("maxmessage", fgMaxMessageLength); 324 } 325 326 }