From 3966616f2cf74ff6b9e1944ff7cf013a6a229d03 Mon Sep 17 00:00:00 2001 From: Stefan Bodewig Date: Sun, 22 May 2016 18:33:55 +0200 Subject: [PATCH 1/3] linefeeds --- .../optional/junit/JUnitTestRunnerTest.java | 434 +++++++++--------- 1 file changed, 217 insertions(+), 217 deletions(-) diff --git a/src/tests/junit/org/apache/tools/ant/taskdefs/optional/junit/JUnitTestRunnerTest.java b/src/tests/junit/org/apache/tools/ant/taskdefs/optional/junit/JUnitTestRunnerTest.java index c0d33e6ef..a75c5cbe5 100644 --- a/src/tests/junit/org/apache/tools/ant/taskdefs/optional/junit/JUnitTestRunnerTest.java +++ b/src/tests/junit/org/apache/tools/ant/taskdefs/optional/junit/JUnitTestRunnerTest.java @@ -1,217 +1,217 @@ -/* - * 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. - * - */ -package org.apache.tools.ant.taskdefs.optional.junit; - -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.fail; - -import java.io.PrintWriter; -import java.io.StringWriter; - -import junit.framework.AssertionFailedError; -import junit.framework.TestCase; -import junit.framework.TestSuite; - -import org.apache.tools.ant.BuildException; -import org.junit.Test; - -/** - * Small testcase for the runner, tests are very very very basics. - * They must be enhanced with time. - * - */ -public class JUnitTestRunnerTest{ - - - - // check that a valid method name generates no errors - @Test - public void testValidMethod(){ - TestRunner runner = createRunnerForTestMethod(ValidMethodTestCase.class,"testA"); - runner.run(); - assertEquals(runner.getFormatter().getError(), JUnitTestRunner.SUCCESS, runner.getRetCode()); - } - - // check that having an invalid method name generates an error - @Test - public void testInvalidMethod(){ - TestRunner runner = createRunnerForTestMethod(InvalidMethodTestCase.class,"testInvalid"); - runner.run(); - String error = runner.getFormatter().getError(); - // might be FAILURES or ERRORS depending on JUnit version? - assertTrue(error, runner.getRetCode() != JUnitTestRunner.SUCCESS); - } - - // check that having no suite generates no errors - @Test - public void testNoSuite(){ - TestRunner runner = createRunner(NoSuiteTestCase.class); - runner.run(); - assertEquals(runner.getFormatter().getError(), JUnitTestRunner.SUCCESS, runner.getRetCode()); - } - - // check that a suite generates no errors - @Test - public void testSuite(){ - TestRunner runner = createRunner(SuiteTestCase.class); - runner.run(); - assertEquals(runner.getFormatter().getError(), JUnitTestRunner.SUCCESS, runner.getRetCode()); - } - - // check that an invalid suite generates an error. - @Test - public void testInvalidSuite(){ - TestRunner runner = createRunner(InvalidSuiteTestCase.class); - runner.run(); - String error = runner.getFormatter().getError(); - assertEquals(error, JUnitTestRunner.ERRORS, runner.getRetCode()); - assertTrue(error, error.indexOf("thrown on purpose") != -1); - } - - // check that something which is not a testcase generates no errors - // at first even though this is incorrect. - @Test - public void testNoTestCase(){ - TestRunner runner = createRunner(NoTestCase.class); - runner.run(); - // On junit3 this is a FAILURE, on junit4 this is an ERROR - int ret = runner.getRetCode(); - - if (ret != JUnitTestRunner.FAILURES && ret != JUnitTestRunner.ERRORS) { - fail("Unexpected result " + ret + " from junit runner"); - } - // JUnit3 test - //assertEquals(runner.getFormatter().getError(), JUnitTestRunner.FAILURES, runner.getRetCode()); - } - - // check that an exception in the constructor is noticed - @Test - public void testInvalidTestCase(){ - TestRunner runner = createRunner(InvalidTestCase.class); - runner.run(); - // On junit3 this is a FAILURE, on junit4 this is an ERROR - int ret = runner.getRetCode(); - if (ret != JUnitTestRunner.FAILURES && ret != JUnitTestRunner.ERRORS) { - fail("Unexpected result " + ret + " from junit runner"); - } - // JUNIT3 test - //assertEquals(error, JUnitTestRunner.FAILURES, runner.getRetCode()); - //@fixme as of now does not report the original stacktrace. - //assertTrue(error, error.indexOf("thrown on purpose") != -1); - } - - protected TestRunner createRunner(Class clazz){ - return new TestRunner(new JUnitTest(clazz.getName()), null, - true, true, true); - } - - protected TestRunner createRunnerForTestMethod(Class clazz, String method){ - return new TestRunner(new JUnitTest(clazz.getName()), new String[] {method}, - true, true, true); - } - - // the test runner that wrap the dummy formatter that interests us - private final static class TestRunner extends JUnitTestRunner { - private ResultFormatter formatter = new ResultFormatter(); - TestRunner(JUnitTest test, String[] methods, boolean haltonerror, - boolean filtertrace, boolean haltonfailure){ - super(test, methods, haltonerror, filtertrace, haltonfailure, - false, false, TestRunner.class.getClassLoader()); - // use the classloader that loaded this class otherwise - // it will not be able to run inner classes if this test - // is ran in non-forked mode. - addFormatter(formatter); - } - ResultFormatter getFormatter(){ - return formatter; - } - } - - // dummy formatter just to catch the error - private final static class ResultFormatter implements JUnitResultFormatter { - private Throwable error; - public void setSystemOutput(String output){} - public void setSystemError(String output){} - public void startTestSuite(JUnitTest suite) throws BuildException{} - public void endTestSuite(JUnitTest suite) throws BuildException{} - public void setOutput(java.io.OutputStream out){} - public void startTest(junit.framework.Test t) {} - public void endTest(junit.framework.Test test) {} - public void addFailure(junit.framework.Test test, AssertionFailedError t) { } - public void addError(junit.framework.Test test, Throwable t) { - error = t; - } - String getError(){ - if (error == null){ - return ""; - } - StringWriter sw = new StringWriter(); - error.printStackTrace(new PrintWriter(sw)); - return sw.toString(); - } - } - - public static class NoTestCase { - } - - public static class InvalidMethodTestCase extends TestCase { - public InvalidMethodTestCase(String name){ super(name); } - public void testA(){ - throw new NullPointerException("thrown on purpose"); - } - } - - public static class ValidMethodTestCase extends TestCase { - public ValidMethodTestCase(String name){ super(name); } - public void testA(){ - // expected to be executed - } - public void testB(){ - // should not be executed - throw new NullPointerException("thrown on purpose"); - } - } - - public static class InvalidTestCase extends TestCase { - public InvalidTestCase(String name){ - super(name); - throw new NullPointerException("thrown on purpose"); - } - } - - public static class NoSuiteTestCase extends TestCase { - public NoSuiteTestCase(String name){ super(name); } - public void testA(){} - } - - public static class SuiteTestCase extends NoSuiteTestCase { - public SuiteTestCase(String name){ super(name); } - public static junit.framework.Test suite(){ - return new TestSuite(SuiteTestCase.class); - } - } - - public static class InvalidSuiteTestCase extends NoSuiteTestCase { - public InvalidSuiteTestCase(String name){ super(name); } - public static junit.framework.Test suite(){ - throw new NullPointerException("thrown on purpose"); - } - } -} - +/* + * 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. + * + */ +package org.apache.tools.ant.taskdefs.optional.junit; + +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; + +import java.io.PrintWriter; +import java.io.StringWriter; + +import junit.framework.AssertionFailedError; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +import org.apache.tools.ant.BuildException; +import org.junit.Test; + +/** + * Small testcase for the runner, tests are very very very basics. + * They must be enhanced with time. + * + */ +public class JUnitTestRunnerTest{ + + + + // check that a valid method name generates no errors + @Test + public void testValidMethod(){ + TestRunner runner = createRunnerForTestMethod(ValidMethodTestCase.class,"testA"); + runner.run(); + assertEquals(runner.getFormatter().getError(), JUnitTestRunner.SUCCESS, runner.getRetCode()); + } + + // check that having an invalid method name generates an error + @Test + public void testInvalidMethod(){ + TestRunner runner = createRunnerForTestMethod(InvalidMethodTestCase.class,"testInvalid"); + runner.run(); + String error = runner.getFormatter().getError(); + // might be FAILURES or ERRORS depending on JUnit version? + assertTrue(error, runner.getRetCode() != JUnitTestRunner.SUCCESS); + } + + // check that having no suite generates no errors + @Test + public void testNoSuite(){ + TestRunner runner = createRunner(NoSuiteTestCase.class); + runner.run(); + assertEquals(runner.getFormatter().getError(), JUnitTestRunner.SUCCESS, runner.getRetCode()); + } + + // check that a suite generates no errors + @Test + public void testSuite(){ + TestRunner runner = createRunner(SuiteTestCase.class); + runner.run(); + assertEquals(runner.getFormatter().getError(), JUnitTestRunner.SUCCESS, runner.getRetCode()); + } + + // check that an invalid suite generates an error. + @Test + public void testInvalidSuite(){ + TestRunner runner = createRunner(InvalidSuiteTestCase.class); + runner.run(); + String error = runner.getFormatter().getError(); + assertEquals(error, JUnitTestRunner.ERRORS, runner.getRetCode()); + assertTrue(error, error.indexOf("thrown on purpose") != -1); + } + + // check that something which is not a testcase generates no errors + // at first even though this is incorrect. + @Test + public void testNoTestCase(){ + TestRunner runner = createRunner(NoTestCase.class); + runner.run(); + // On junit3 this is a FAILURE, on junit4 this is an ERROR + int ret = runner.getRetCode(); + + if (ret != JUnitTestRunner.FAILURES && ret != JUnitTestRunner.ERRORS) { + fail("Unexpected result " + ret + " from junit runner"); + } + // JUnit3 test + //assertEquals(runner.getFormatter().getError(), JUnitTestRunner.FAILURES, runner.getRetCode()); + } + + // check that an exception in the constructor is noticed + @Test + public void testInvalidTestCase(){ + TestRunner runner = createRunner(InvalidTestCase.class); + runner.run(); + // On junit3 this is a FAILURE, on junit4 this is an ERROR + int ret = runner.getRetCode(); + if (ret != JUnitTestRunner.FAILURES && ret != JUnitTestRunner.ERRORS) { + fail("Unexpected result " + ret + " from junit runner"); + } + // JUNIT3 test + //assertEquals(error, JUnitTestRunner.FAILURES, runner.getRetCode()); + //@fixme as of now does not report the original stacktrace. + //assertTrue(error, error.indexOf("thrown on purpose") != -1); + } + + protected TestRunner createRunner(Class clazz){ + return new TestRunner(new JUnitTest(clazz.getName()), null, + true, true, true); + } + + protected TestRunner createRunnerForTestMethod(Class clazz, String method){ + return new TestRunner(new JUnitTest(clazz.getName()), new String[] {method}, + true, true, true); + } + + // the test runner that wrap the dummy formatter that interests us + private final static class TestRunner extends JUnitTestRunner { + private ResultFormatter formatter = new ResultFormatter(); + TestRunner(JUnitTest test, String[] methods, boolean haltonerror, + boolean filtertrace, boolean haltonfailure){ + super(test, methods, haltonerror, filtertrace, haltonfailure, + false, false, TestRunner.class.getClassLoader()); + // use the classloader that loaded this class otherwise + // it will not be able to run inner classes if this test + // is ran in non-forked mode. + addFormatter(formatter); + } + ResultFormatter getFormatter(){ + return formatter; + } + } + + // dummy formatter just to catch the error + private final static class ResultFormatter implements JUnitResultFormatter { + private Throwable error; + public void setSystemOutput(String output){} + public void setSystemError(String output){} + public void startTestSuite(JUnitTest suite) throws BuildException{} + public void endTestSuite(JUnitTest suite) throws BuildException{} + public void setOutput(java.io.OutputStream out){} + public void startTest(junit.framework.Test t) {} + public void endTest(junit.framework.Test test) {} + public void addFailure(junit.framework.Test test, AssertionFailedError t) { } + public void addError(junit.framework.Test test, Throwable t) { + error = t; + } + String getError(){ + if (error == null){ + return ""; + } + StringWriter sw = new StringWriter(); + error.printStackTrace(new PrintWriter(sw)); + return sw.toString(); + } + } + + public static class NoTestCase { + } + + public static class InvalidMethodTestCase extends TestCase { + public InvalidMethodTestCase(String name){ super(name); } + public void testA(){ + throw new NullPointerException("thrown on purpose"); + } + } + + public static class ValidMethodTestCase extends TestCase { + public ValidMethodTestCase(String name){ super(name); } + public void testA(){ + // expected to be executed + } + public void testB(){ + // should not be executed + throw new NullPointerException("thrown on purpose"); + } + } + + public static class InvalidTestCase extends TestCase { + public InvalidTestCase(String name){ + super(name); + throw new NullPointerException("thrown on purpose"); + } + } + + public static class NoSuiteTestCase extends TestCase { + public NoSuiteTestCase(String name){ super(name); } + public void testA(){} + } + + public static class SuiteTestCase extends NoSuiteTestCase { + public SuiteTestCase(String name){ super(name); } + public static junit.framework.Test suite(){ + return new TestSuite(SuiteTestCase.class); + } + } + + public static class InvalidSuiteTestCase extends NoSuiteTestCase { + public InvalidSuiteTestCase(String name){ super(name); } + public static junit.framework.Test suite(){ + throw new NullPointerException("thrown on purpose"); + } + } +} + From 421ae34d7037a8cbdb372e938e269caa081b7166 Mon Sep 17 00:00:00 2001 From: Dana Dahlstrom Date: Mon, 8 Feb 2016 21:40:56 -0800 Subject: [PATCH 2/3] Preserve cause of AssertionError MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit … when converting to AssertionFailedError in JUnitTestRunner. --- .../optional/junit/JUnitTestRunner.java | 1 + .../optional/junit/JUnitTestRunnerTest.java | 30 ++++++++++++++++++- 2 files changed, 30 insertions(+), 1 deletion(-) diff --git a/src/main/org/apache/tools/ant/taskdefs/optional/junit/JUnitTestRunner.java b/src/main/org/apache/tools/ant/taskdefs/optional/junit/JUnitTestRunner.java index a457375e2..0397d843e 100644 --- a/src/main/org/apache/tools/ant/taskdefs/optional/junit/JUnitTestRunner.java +++ b/src/main/org/apache/tools/ant/taskdefs/optional/junit/JUnitTestRunner.java @@ -1240,6 +1240,7 @@ public class JUnitTestRunner implements TestListener, JUnitTaskMirror.JUnitTestR final String msg = t.getMessage(); final AssertionFailedError failure = msg != null ? new AssertionFailedError(msg) : new AssertionFailedError(); + failure.initCause(t.getCause()); failure.setStackTrace(t.getStackTrace()); testListener.addFailure(test, failure); } else { diff --git a/src/tests/junit/org/apache/tools/ant/taskdefs/optional/junit/JUnitTestRunnerTest.java b/src/tests/junit/org/apache/tools/ant/taskdefs/optional/junit/JUnitTestRunnerTest.java index a75c5cbe5..e5092fe48 100644 --- a/src/tests/junit/org/apache/tools/ant/taskdefs/optional/junit/JUnitTestRunnerTest.java +++ b/src/tests/junit/org/apache/tools/ant/taskdefs/optional/junit/JUnitTestRunnerTest.java @@ -116,6 +116,20 @@ public class JUnitTestRunnerTest{ //assertTrue(error, error.indexOf("thrown on purpose") != -1); } + // check that JUnit 4 synthetic AssertionFailedError gets message and cause from AssertionError + @Test + public void testJUnit4AssertionError(){ + TestRunner runner = createRunnerForTestMethod(AssertionErrorTest.class,"throwsAssertionError"); + runner.run(); + + AssertionFailedError failure = runner.getFormatter().getFailure(); + assertEquals("failure message", failure.getMessage()); + + Throwable cause = failure.getCause(); + assertEquals(RuntimeException.class, cause.getClass()); + assertEquals("cause message", cause.getMessage()); + } + protected TestRunner createRunner(Class clazz){ return new TestRunner(new JUnitTest(clazz.getName()), null, true, true, true); @@ -145,6 +159,7 @@ public class JUnitTestRunnerTest{ // dummy formatter just to catch the error private final static class ResultFormatter implements JUnitResultFormatter { + private AssertionFailedError failure; private Throwable error; public void setSystemOutput(String output){} public void setSystemError(String output){} @@ -153,7 +168,12 @@ public class JUnitTestRunnerTest{ public void setOutput(java.io.OutputStream out){} public void startTest(junit.framework.Test t) {} public void endTest(junit.framework.Test test) {} - public void addFailure(junit.framework.Test test, AssertionFailedError t) { } + public void addFailure(junit.framework.Test test, AssertionFailedError t) { + failure = t; + } + AssertionFailedError getFailure() { + return failure; + } public void addError(junit.framework.Test test, Throwable t) { error = t; } @@ -213,5 +233,13 @@ public class JUnitTestRunnerTest{ throw new NullPointerException("thrown on purpose"); } } + + public static class AssertionErrorTest { + @Test public void throwsAssertionError() { + AssertionError assertionError = new AssertionError("failure message"); + assertionError.initCause(new RuntimeException("cause message")); + throw assertionError; + } + } } From e982f01953984e633e1415b7c06d56afcc2048d7 Mon Sep 17 00:00:00 2001 From: Stefan Bodewig Date: Sun, 22 May 2016 18:38:10 +0200 Subject: [PATCH 3/3] record fix for 58982 by Dana Dahlstrom https://bz.apache.org/bugzilla/show_bug.cgi?id=58982 --- CONTRIBUTORS | 1 + WHATSNEW | 4 ++++ contributors.xml | 4 ++++ 3 files changed, 9 insertions(+) diff --git a/CONTRIBUTORS b/CONTRIBUTORS index 8e47e059f..3b7b5ab8c 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -77,6 +77,7 @@ D'Arcy Smith Dale Anson Dale Sherwood Dan Armbrust +Dana Dahlstrom Daniel Henrique Daniel Ribagnac Daniel Spilker diff --git a/WHATSNEW b/WHATSNEW index 25a0464f1..cddd6628f 100644 --- a/WHATSNEW +++ b/WHATSNEW @@ -27,6 +27,10 @@ Fixed bugs: Other changes: -------------- + * now initializes the cause of the AssertionFailedError when + converting from AssertionError. + Bugzilla Report 58982 + Changes from Ant 1.9.6 TO Ant 1.9.7 =================================== diff --git a/contributors.xml b/contributors.xml index 2bfa1b071..0a079d260 100644 --- a/contributors.xml +++ b/contributors.xml @@ -331,6 +331,10 @@ Dan Armbrust + + Dana + Dahlstrom + Daniel Henrique