diff --git a/src/main/java/junit/runner/BaseTestRunner.java b/src/main/java/junit/runner/BaseTestRunner.java index 8268323103a7..d8190697ef51 100644 --- a/src/main/java/junit/runner/BaseTestRunner.java +++ b/src/main/java/junit/runner/BaseTestRunner.java @@ -1,13 +1,11 @@ package junit.runner; -import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.PrintWriter; -import java.io.StringReader; import java.io.StringWriter; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; @@ -19,6 +17,7 @@ import junit.framework.Test; import junit.framework.TestListener; import junit.framework.TestSuite; +import org.junit.internal.StackTraces; /** * Base class for all test runners. @@ -264,6 +263,10 @@ public static int getPreference(String key, int dflt) { * Returns a filtered stack trace */ public static String getFilteredTrace(Throwable e) { + if (!showStackRaw()) { + return StackTraces.getTrimmedStackTrace(e); + } + StringWriter stringWriter = new StringWriter(); PrintWriter writer = new PrintWriter(stringWriter); e.printStackTrace(writer); @@ -275,53 +278,14 @@ public static String getFilteredTrace(Throwable e) { * Filters stack frames from internal JUnit classes */ public static String getFilteredTrace(String stack) { - if (showStackRaw()) { - return stack; - } - - StringWriter sw = new StringWriter(); - PrintWriter pw = new PrintWriter(sw); - StringReader sr = new StringReader(stack); - BufferedReader br = new BufferedReader(sr); - - String line; - try { - while ((line = br.readLine()) != null) { - if (!filterLine(line)) { - pw.println(line); - } - } - } catch (Exception IOException) { - return stack; // return the stack unfiltered - } - return sw.toString(); + return showStackRaw() ? stack : StackTraces.trimStackTrace(stack); } protected static boolean showStackRaw() { return !getPreference("filterstack").equals("true") || fgFilterStack == false; } - static boolean filterLine(String line) { - String[] patterns = new String[]{ - "junit.framework.TestCase", - "junit.framework.TestResult", - "junit.framework.TestSuite", - "junit.framework.Assert.", // don't filter AssertionFailure - "junit.swingui.TestRunner", - "junit.awtui.TestRunner", - "junit.textui.TestRunner", - "java.lang.reflect.Method.invoke(" - }; - for (int i = 0; i < patterns.length; i++) { - if (line.indexOf(patterns[i]) > 0) { - return true; - } - } - return false; - } - static { fgMaxMessageLength = getPreference("maxmessage", fgMaxMessageLength); } - } diff --git a/src/main/java/org/junit/internal/StackTraces.java b/src/main/java/org/junit/internal/StackTraces.java new file mode 100644 index 000000000000..b8775428dcab --- /dev/null +++ b/src/main/java/org/junit/internal/StackTraces.java @@ -0,0 +1,203 @@ +package org.junit.internal; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.PrintWriter; +import java.io.StringReader; +import java.io.StringWriter; +import java.util.AbstractList; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +/** + * Utility class for working with stack traces. + */ +public class StackTraces { + private StackTraces() { + } + + /** + * Gets a trimmed version of the stack trace of the given exception. Stack trace + * elements that are below the test method are filtered out. + * + * @return a trimmed stack trace, or the original trace if trimming wasn't possible + */ + public static String getTrimmedStackTrace(Throwable exception) { + StringWriter stringWriter = new StringWriter(); + PrintWriter writer = new PrintWriter(stringWriter); + exception.printStackTrace(writer); + return trimStackTrace(exception.toString(), stringWriter.toString()); + } + + /** + * Trims the given stack trace. Stack trace elements that are below the test method are + * filtered. out. + * + * @param fullTrace the full stack trace + * @return a trimmed stack trace, or the original trace if trimming wasn't possible + */ + public static String trimStackTrace(String fullTrace) { + return trimStackTrace("", fullTrace); + } + + static String trimStackTrace(String extracedExceptionMessage, String fullTrace) { + StringBuilder trimmedTrace = new StringBuilder(extracedExceptionMessage); + BufferedReader reader = new BufferedReader( + new StringReader(fullTrace.substring(extracedExceptionMessage.length()))); + + try { + // Collect the stack trace lines for "exception" (but not the cause). + List stackTraceLines = new ArrayList(); + String line; + boolean hasCause = false; + while ((line = reader.readLine()) != null) { + if (line.startsWith("Caused by: ")) { + hasCause= true; + break; + } + stackTraceLines.add(line); + } + if (stackTraceLines.isEmpty()) { + // No stack trace? + return fullTrace; + } + stackTraceLines = trimStackTraceLines(stackTraceLines, hasCause); + if (stackTraceLines.isEmpty()) { + // Could not trim stack trace lines. + return fullTrace; + } + appendStackTraceLines(stackTraceLines, trimmedTrace); + if (line != null) { + // Print remaining stack trace lines. + do { + trimmedTrace.append(line).append("\n"); + line = reader.readLine(); + } while (line != null); + } + return trimmedTrace.toString(); + } catch (IOException e) { + } + return fullTrace; + } + + private static void appendStackTraceLines( + List stackTraceLines, StringBuilder destBuilder) { + for (String stackTraceLine : stackTraceLines) { + destBuilder.append(stackTraceLine).append("\n"); + } + } + + private static List trimStackTraceLines( + List stackTraceLines, boolean hasCause) { + State state = State.PROCESSING_OTHER_CODE; + int linesToInclude = stackTraceLines.size(); + for (String stackTraceLine : asReversedList(stackTraceLines)) { + state = state.processLine(stackTraceLine); + if (state == State.DONE) { + List trimmedLines = stackTraceLines.subList(0, linesToInclude); + if (!hasCause) { + return trimmedLines; + } + List copy = new ArrayList(trimmedLines); + copy.add("\t..." + (stackTraceLines.size() - copy.size()) + "more"); + return copy; + } + linesToInclude--; + } + return Collections.emptyList(); + } + + private static List asReversedList(final List list) { + return new AbstractList() { + + @Override + public T get(int index) { + return list.get(list.size() - index - 1); + } + + @Override + public int size() { + return list.size(); + } + }; + } + + private enum State { + PROCESSING_OTHER_CODE { + @Override public State processLine(String line) { + if (isTestFrameworkStackTraceLine(line)) { + return PROCESSING_TEST_FRAMEWORK_CODE; + } + return this; + } + }, + PROCESSING_TEST_FRAMEWORK_CODE { + @Override public State processLine(String line) { + if (isReflectionStackTraceLine(line)) { + return PROCESSING_REFLECTION_CODE; + } else if (isTestFrameworkStackTraceLine(line)) { + return this; + } + return PROCESSING_OTHER_CODE; + } + }, + PROCESSING_REFLECTION_CODE { + @Override public State processLine(String line) { + if (isReflectionStackTraceLine(line)) { + return this; + } else if (isTestFrameworkStackTraceLine(line)) { + // This is here to handle TestCase.runBare() calling TestCase.runTest(). + return PROCESSING_TEST_FRAMEWORK_CODE; + } + return DONE; + } + }, + DONE { + @Override public State processLine(String line) { + return this; + } + }; + + /** Processes a stack trace line, possibly moving to a new state. */ + public abstract State processLine(String line); + } + + private static final String[] TEST_FRAMEWORK_METHOD_NAME_PREFIXES = { + "org.junit.runner.", + "org.junit.runners.", + "org.junit.experimental.runners.", + "org.junit.internal.", + "junit.", + "org.apache.maven.surefire." + }; + + private static boolean isTestFrameworkStackTraceLine(String line) { + return isMatchingStackTraceLine(line, TEST_FRAMEWORK_METHOD_NAME_PREFIXES); + } + + private static final String[] REFLECTION_METHOD_NAME_PREFIXES = { + "sun.reflect.", + "java.lang.reflect.", + "org.junit.rules.RunRules.evaluate(", // get better stack traces for failures in method rules + "junit.framework.TestCase.runBare(", // runBare() directly calls setUp() and tearDown() + }; + + private static boolean isReflectionStackTraceLine(String line) { + return isMatchingStackTraceLine(line, REFLECTION_METHOD_NAME_PREFIXES); + } + + private static boolean isMatchingStackTraceLine(String line, String[] packagePrefixes) { + if (!line.startsWith("\tat ")) { + return false; + } + line = line.substring(4); + for (String packagePrefix : packagePrefixes) { + if (line.startsWith(packagePrefix)) { + return true; + } + } + + return false; + } +} diff --git a/src/main/java/org/junit/internal/TextListener.java b/src/main/java/org/junit/internal/TextListener.java index 9aa56c75f5ec..6856ec1ea77e 100644 --- a/src/main/java/org/junit/internal/TextListener.java +++ b/src/main/java/org/junit/internal/TextListener.java @@ -74,7 +74,7 @@ protected void printFailures(Result result) { protected void printFailure(Failure each, String prefix) { getWriter().println(prefix + ") " + each.getTestHeader()); - getWriter().print(each.getTrace()); + getWriter().print(each.getTrimmedTrace()); } protected void printFooter(Result result) { diff --git a/src/main/java/org/junit/runner/notification/Failure.java b/src/main/java/org/junit/runner/notification/Failure.java index c03b4c181407..b20de7a782fd 100644 --- a/src/main/java/org/junit/runner/notification/Failure.java +++ b/src/main/java/org/junit/runner/notification/Failure.java @@ -4,6 +4,7 @@ import java.io.Serializable; import java.io.StringWriter; +import org.junit.internal.StackTraces; import org.junit.runner.Description; /** @@ -65,9 +66,7 @@ public String toString() { } /** - * Convenience method - * - * @return the printed form of the exception + * Gets the printed form of the exception and its stack trace. */ public String getTrace() { StringWriter stringWriter = new StringWriter(); @@ -76,6 +75,15 @@ public String getTrace() { return stringWriter.toString(); } + /** + * Gets a the printed form of the exception, with a trimmed version of the stack trace. + * This method will attempt to filter out frames of the stack trace that are below + * the test method call. + */ + public String getTrimmedTrace() { + return StackTraces.getTrimmedStackTrace(getException()); + } + /** * Convenience method * diff --git a/src/test/java/junit/tests/runner/StackFilterTest.java b/src/test/java/junit/tests/runner/StackFilterTest.java index 741fc3484612..a5bfaf429b24 100644 --- a/src/test/java/junit/tests/runner/StackFilterTest.java +++ b/src/test/java/junit/tests/runner/StackFilterTest.java @@ -15,28 +15,31 @@ protected void setUp() { StringWriter swin = new StringWriter(); PrintWriter pwin = new PrintWriter(swin); pwin.println("junit.framework.AssertionFailedError"); - pwin.println(" at junit.framework.Assert.fail(Assert.java:144)"); - pwin.println(" at junit.framework.Assert.assert(Assert.java:19)"); - pwin.println(" at junit.framework.Assert.assert(Assert.java:26)"); - pwin.println(" at MyTest.f(MyTest.java:13)"); - pwin.println(" at MyTest.testStackTrace(MyTest.java:8)"); - pwin.println(" at java.lang.reflect.Method.invoke(Native Method)"); - pwin.println(" at junit.framework.TestCase.runTest(TestCase.java:156)"); - pwin.println(" at junit.framework.TestCase.runBare(TestCase.java:130)"); - pwin.println(" at junit.framework.TestResult$1.protect(TestResult.java:100)"); - pwin.println(" at junit.framework.TestResult.runProtected(TestResult.java:118)"); - pwin.println(" at junit.framework.TestResult.run(TestResult.java:103)"); - pwin.println(" at junit.framework.TestCase.run(TestCase.java:121)"); - pwin.println(" at junit.framework.TestSuite.runTest(TestSuite.java:157)"); - pwin.println(" at junit.framework.TestSuite.run(TestSuite.java, Compiled Code)"); - pwin.println(" at junit.swingui.TestRunner$17.run(TestRunner.java:669)"); + pwin.println("\tat junit.framework.Assert.fail(Assert.java:144)"); + pwin.println("\tat junit.framework.Assert.assert(Assert.java:19)"); + pwin.println("\tat junit.framework.Assert.assert(Assert.java:26)"); + pwin.println("\tat MyTest.f(MyTest.java:13)"); + pwin.println("\tat MyTest.testStackTrace(MyTest.java:8)"); + pwin.println("\tat java.lang.reflect.Method.invoke(Native Method)"); + pwin.println("\tat junit.framework.TestCase.runTest(TestCase.java:156)"); + pwin.println("\tat junit.framework.TestCase.runBare(TestCase.java:130)"); + pwin.println("\tat junit.framework.TestResult$1.protect(TestResult.java:100)"); + pwin.println("\tat junit.framework.TestResult.runProtected(TestResult.java:118)"); + pwin.println("\tat junit.framework.TestResult.run(TestResult.java:103)"); + pwin.println("\tat junit.framework.TestCase.run(TestCase.java:121)"); + pwin.println("\tat junit.framework.TestSuite.runTest(TestSuite.java:157)"); + pwin.println("\tat junit.framework.TestSuite.run(TestSuite.java, Compiled Code)"); + pwin.println("\tat junit.swingui.TestRunner$17.run(TestRunner.java:669)"); fUnfiltered = swin.toString(); StringWriter swout = new StringWriter(); PrintWriter pwout = new PrintWriter(swout); pwout.println("junit.framework.AssertionFailedError"); - pwout.println(" at MyTest.f(MyTest.java:13)"); - pwout.println(" at MyTest.testStackTrace(MyTest.java:8)"); + pwout.println("\tat junit.framework.Assert.fail(Assert.java:144)"); + pwout.println("\tat junit.framework.Assert.assert(Assert.java:19)"); + pwout.println("\tat junit.framework.Assert.assert(Assert.java:26)"); + pwout.println("\tat MyTest.f(MyTest.java:13)"); + pwout.println("\tat MyTest.testStackTrace(MyTest.java:8)"); fFiltered = swout.toString(); } diff --git a/src/test/java/org/junit/internal/StackTracesTest.java b/src/test/java/org/junit/internal/StackTracesTest.java new file mode 100644 index 000000000000..c3043c009dba --- /dev/null +++ b/src/test/java/org/junit/internal/StackTracesTest.java @@ -0,0 +1,160 @@ +package org.junit.internal; + +import static org.junit.Assert.assertEquals; +import org.junit.Test; + +public class StackTracesTest { + + @Test + public void trimStackTraceForJUnit4TestFailingInTestMethod() { + String exceptionMessage = "java.lang.AssertionError: message\n" + + "with multiple lines"; + String expectedTrace = exceptionMessage + "\n" + + "\tat org.junit.Assert.fail(Assert.java:88)\n" + + "\tat com.example.Example.methodUnderTest(Example.java:18)\n" + + "\tat com.example.ExampleTest.testMethodUnderTest(ExampleTest.java:11)\n"; + String fullTrace = expectedTrace + + "\tat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n" + + "\tat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)\n" + + "\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\n" + + "\tat java.lang.reflect.Method.invoke(Method.java:606)\n" + + "\tat org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)\n" + + "\tat org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)\n" + + "\tat org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:52)\n" + + "\tat org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)\n" + + "\tat org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)\n" + + "\tat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:87)\n" + + "\tat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:1)\n" + + "\tat org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)\n" + + "\tat org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)\n" + + "\tat org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)\n" + + "\tat org.junit.runners.ParentRunner.access$0(ParentRunner.java:284)\n" + + "\tat org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)\n" + + "\tat org.junit.runners.ParentRunner.run(ParentRunner.java:363)\n" + + "\tat org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:459)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:675)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:382)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:192)\n"; + + assertEquals(expectedTrace, StackTraces.trimStackTrace(exceptionMessage, fullTrace)); + } + + @Test + public void trimStackTraceForJUnit4TestFailingInBeforeMethod() { + String exceptionMessage = "java.lang.AssertionError: message\n" + + "with multiple lines"; + String expectedTrace = exceptionMessage + "\n" + + "\tat org.junit.Assert.fail(Assert.java:88)\n" + + "\tat com.example.ExampleTest.beforeMethod(ExampleTest.java:28)\n"; + String fullTrace = expectedTrace + + "\tat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n" + + "\tat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)\n" + + "\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\n" + + "\tat java.lang.reflect.Method.invoke(Method.java:606)\n" + + "\tat org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)\n" + + "\tat org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)\n" + + "\tat org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:52)\n" + + "\tat org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:24)\n" + + "\tat org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)\n" + + "\tat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:87)\n" + + "\tat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:1)\n" + + "\tat org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)\n" + + "\tat org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)\n" + + "\tat org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)\n" + + "\tat org.junit.runners.ParentRunner.access$0(ParentRunner.java:284)\n" + + "\tat org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)\n" + + "\tat org.junit.runners.ParentRunner.run(ParentRunner.java:363)\n" + + "\tat org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)\n" + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:459)\n" + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:675)\n" + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:382)\n" + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:192)\n"; + + assertEquals(expectedTrace, StackTraces.trimStackTrace(exceptionMessage, fullTrace)); + } + + @Test + public void trimStackTraceForJUnit4TestFailingInRule() { + String exceptionMessage = "java.lang.AssertionError: message\n" + + "with multiple lines"; + String expectedTrace = exceptionMessage + "\n" + + "\tat org.junit.Assert.fail(Assert.java:88)\n" + + "\tat org.example.ExampleRule$1.evaluate(ExampleRule.java:46)\n"; + String fullTrace = expectedTrace + + "\tat org.junit.rules.RunRules.evaluate(RunRules.java:20)\n" + + "\tat org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)\n" + + "\tat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:87)\n" + + "\tat org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:1)\n" + + "\tat org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)\n" + + "\tat org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)\n" + + "\tat org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)\n" + + "\tat org.junit.runners.ParentRunner.access$0(ParentRunner.java:284)\n" + + "\tat org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)\n" + + "\tat org.junit.runners.ParentRunner.run(ParentRunner.java:363)\n" + + "\tat org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:459)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:675)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:382)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:192)\n"; + + assertEquals(expectedTrace, StackTraces.trimStackTrace(exceptionMessage, fullTrace)); + } + + @Test + public void trimStackTraceForJUnit3TestFailingInTestMethod() { + String exceptionMessage = "java.lang.AssertionError: message\n" + + "with multiple lines"; + String expectedTrace = exceptionMessage + "\n" + + "\tat junit.framework.TestCase.fail(TestCase.java:223)\n" + + "\tat com.example.ExampleTest.testFilter(ExampleTest.java:48)\n"; + String fullTrace = expectedTrace + + "\tat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n" + + "\tat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)\n" + + "\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\n" + + "\tat java.lang.reflect.Method.invoke(Method.java:606)\n" + + "\tat junit.framework.TestCase.runTest(TestCase.java:177)\n" + + "\tat junit.framework.TestCase.runBare(TestCase.java:142)\n" + + "\tat junit.framework.TestResult$1.protect(TestResult.java:125)\n" + + "\tat junit.framework.TestResult.runProtected(TestResult.java:145)\n" + + "\tat junit.framework.TestResult.run(TestResult.java:128)\n" + + "\tat junit.framework.TestCase.run(TestCase.java:130)\n" + + "\tat junit.framework.TestSuite.runTest(TestSuite.java:252)\n" + + "\tat junit.framework.TestSuite.run(TestSuite.java:247)\n" + + "\tat org.junit.internal.runners.JUnit38ClassRunner.run(JUnit38ClassRunner.java:86)\n" + + "\tat org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:459)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:675)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:382)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:192)\n"; + + assertEquals(expectedTrace, StackTraces.trimStackTrace(exceptionMessage, fullTrace)); + } + + @Test + public void trimStackTraceForJUnit3TestFailingInSetUpMethod() { + String exceptionMessage = "java.lang.AssertionError: message\n" + + "with multiple lines"; + String expectedTrace = exceptionMessage + "\n" + + "\tat junit.framework.Assert.fail(Assert.java:57)\n" + + "\tat junit.framework.TestCase.fail(TestCase.java:223)\n" + + "\tat com.example.ExampleTest.setUp(StackFilterTest.java:44)\n"; + String fullTrace = expectedTrace + + "\tat junit.framework.TestCase.runBare(TestCase.java:140)\n" + + "\tat junit.framework.TestResult$1.protect(TestResult.java:125)\n" + + "\tat junit.framework.TestResult.runProtected(TestResult.java:145)\n" + + "\tat junit.framework.TestResult.run(TestResult.java:128)\n" + + "\tat junit.framework.TestCase.run(TestCase.java:130)\n" + + "\tat junit.framework.TestSuite.runTest(TestSuite.java:252)\n" + + "\tat junit.framework.TestSuite.run(TestSuite.java:247)\n" + + "\tat org.junit.internal.runners.JUnit38ClassRunner.run(JUnit38ClassRunner.java:86)\n" + + "\tat org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:459)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:675)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:382)\n" + + "\tat org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:192)\n"; + + assertEquals(expectedTrace, StackTraces.trimStackTrace(exceptionMessage, fullTrace)); + } +} diff --git a/src/test/java/org/junit/tests/AllTests.java b/src/test/java/org/junit/tests/AllTests.java index b3d0d4527246..048bc9be773a 100644 --- a/src/test/java/org/junit/tests/AllTests.java +++ b/src/test/java/org/junit/tests/AllTests.java @@ -6,6 +6,7 @@ import org.junit.AssumptionViolatedExceptionTest; import org.junit.experimental.categories.CategoryFilterFactoryTest; import org.junit.internal.MethodSorterTest; +import org.junit.internal.StackTracesTest; import org.junit.internal.matchers.StacktracePrintingMatcherTest; import org.junit.internal.matchers.ThrowableCauseMatcherTest; import org.junit.rules.DisableOnDebugTest; @@ -235,6 +236,7 @@ ForwardCompatibilityPrintingTest.class, DescriptionTest.class, ErrorReportingRunnerTest.class, + StackTracesTest.class, TemporaryFolderRuleAssuredDeletionTest.class }) public class AllTests {