diff options
Diffstat (limited to 'src/main/java/junit/framework/TestCase.java')
| -rw-r--r-- | src/main/java/junit/framework/TestCase.java | 610 |
1 files changed, 472 insertions, 138 deletions
diff --git a/src/main/java/junit/framework/TestCase.java b/src/main/java/junit/framework/TestCase.java index b047ec9..b89ce71 100644 --- a/src/main/java/junit/framework/TestCase.java +++ b/src/main/java/junit/framework/TestCase.java @@ -36,7 +36,7 @@ import java.lang.reflect.Modifier; * assertTrue(result == 5.0); * } * </pre> - * + * * Once the methods are defined you can run them. The framework supports * both a static type safe and more dynamic way to run a test. * In the static way you override the runTest method and define the method to @@ -49,7 +49,6 @@ import java.lang.reflect.Modifier; * }; * test.run(); * </pre> - * * The dynamic way uses reflection to implement {@link #runTest()}. It dynamically finds * and invokes a method. * In this case the name of the test case has to correspond to the test method @@ -58,7 +57,7 @@ import java.lang.reflect.Modifier; * TestCase test= new MathTest("testAdd"); * test.run(); * </pre> - * + * * The tests to be run can be collected into a TestSuite. JUnit provides * different <i>test runners</i> which can run a test suite and collect the results. * A test runner either expects a static method <code>suite</code> as the entry @@ -70,143 +69,478 @@ import java.lang.reflect.Modifier; * return suite; * } * </pre> + * * @see TestResult * @see TestSuite */ public abstract class TestCase extends Assert implements Test { - /** - * the name of the test case - */ - private String fName; - - /** - * No-arg constructor to enable serialization. This method - * is not intended to be used by mere mortals without calling setName(). - */ - public TestCase() { - fName= null; - } - /** - * Constructs a test case with the given name. - */ - public TestCase(String name) { - fName= name; - } - /** - * Counts the number of test cases executed by run(TestResult result). - */ - public int countTestCases() { - return 1; - } - /** - * Creates a default TestResult object - * - * @see TestResult - */ - protected TestResult createResult() { - return new TestResult(); - } - /** - * A convenience method to run this test, collecting the results with a - * default TestResult object. - * - * @see TestResult - */ - public TestResult run() { - TestResult result= createResult(); - run(result); - return result; - } - /** - * Runs the test case and collects the results in TestResult. - */ - public void run(TestResult result) { - result.run(this); - } - /** - * Runs the bare test sequence. - * @throws Throwable if any exception is thrown - */ - public void runBare() throws Throwable { - Throwable exception= null; - setUp(); - try { - runTest(); - } catch (Throwable running) { - exception= running; - } - finally { - try { - tearDown(); - } catch (Throwable tearingDown) { - if (exception == null) exception= tearingDown; - } - } - if (exception != null) throw exception; - } - /** - * Override to run the test and assert its state. - * @throws Throwable if any exception is thrown - */ - protected void runTest() throws Throwable { - assertNotNull("TestCase.fName cannot be null", fName); // Some VMs crash when calling getMethod(null,null); - Method runMethod= null; - try { - // use getMethod to get all public inherited - // methods. getDeclaredMethods returns all - // methods of this class but excludes the - // inherited ones. - runMethod= getClass().getMethod(fName, (Class[])null); - } catch (NoSuchMethodException e) { - fail("Method \""+fName+"\" not found"); - } - if (!Modifier.isPublic(runMethod.getModifiers())) { - fail("Method \""+fName+"\" should be public"); - } - - try { - runMethod.invoke(this); - } - catch (InvocationTargetException e) { - e.fillInStackTrace(); - throw e.getTargetException(); - } - catch (IllegalAccessException e) { - e.fillInStackTrace(); - throw e; - } - } - /** - * Sets up the fixture, for example, open a network connection. - * This method is called before a test is executed. - */ - protected void setUp() throws Exception { - } - /** - * Tears down the fixture, for example, close a network connection. - * This method is called after a test is executed. - */ - protected void tearDown() throws Exception { - } - /** - * Returns a string representation of the test case - */ - @Override - public String toString() { - return getName() + "(" + getClass().getName() + ")"; - } - /** - * Gets the name of a TestCase - * @return the name of the TestCase - */ - public String getName() { - return fName; - } - /** - * Sets the name of a TestCase - * @param name the name to set - */ - public void setName(String name) { - fName= name; - } + /** + * the name of the test case + */ + private String fName; + + /** + * No-arg constructor to enable serialization. This method + * is not intended to be used by mere mortals without calling setName(). + */ + public TestCase() { + fName = null; + } + + /** + * Constructs a test case with the given name. + */ + public TestCase(String name) { + fName = name; + } + + /** + * Counts the number of test cases executed by run(TestResult result). + */ + public int countTestCases() { + return 1; + } + + /** + * Creates a default TestResult object + * + * @see TestResult + */ + protected TestResult createResult() { + return new TestResult(); + } + + /** + * A convenience method to run this test, collecting the results with a + * default TestResult object. + * + * @see TestResult + */ + public TestResult run() { + TestResult result = createResult(); + run(result); + return result; + } + + /** + * Runs the test case and collects the results in TestResult. + */ + public void run(TestResult result) { + result.run(this); + } + + /** + * Runs the bare test sequence. + * + * @throws Throwable if any exception is thrown + */ + public void runBare() throws Throwable { + Throwable exception = null; + setUp(); + try { + runTest(); + } catch (Throwable running) { + exception = running; + } finally { + try { + tearDown(); + } catch (Throwable tearingDown) { + if (exception == null) exception = tearingDown; + } + } + if (exception != null) throw exception; + } + + /** + * Override to run the test and assert its state. + * + * @throws Throwable if any exception is thrown + */ + protected void runTest() throws Throwable { + assertNotNull("TestCase.fName cannot be null", fName); // Some VMs crash when calling getMethod(null,null); + Method runMethod = null; + try { + // use getMethod to get all public inherited + // methods. getDeclaredMethods returns all + // methods of this class but excludes the + // inherited ones. + runMethod = getClass().getMethod(fName, (Class[]) null); + } catch (NoSuchMethodException e) { + fail("Method \"" + fName + "\" not found"); + } + if (!Modifier.isPublic(runMethod.getModifiers())) { + fail("Method \"" + fName + "\" should be public"); + } + + try { + runMethod.invoke(this); + } catch (InvocationTargetException e) { + e.fillInStackTrace(); + throw e.getTargetException(); + } catch (IllegalAccessException e) { + e.fillInStackTrace(); + throw e; + } + } + + /** + * Asserts that a condition is true. If it isn't it throws + * an AssertionFailedError with the given message. + */ + @SuppressWarnings("deprecation") + public static void assertTrue(String message, boolean condition) { + Assert.assertTrue(message, condition); + } + + /** + * Asserts that a condition is true. If it isn't it throws + * an AssertionFailedError. + */ + @SuppressWarnings("deprecation") + public static void assertTrue(boolean condition) { + Assert.assertTrue(condition); + } + + /** + * Asserts that a condition is false. If it isn't it throws + * an AssertionFailedError with the given message. + */ + @SuppressWarnings("deprecation") + public static void assertFalse(String message, boolean condition) { + Assert.assertFalse(message, condition); + } + + /** + * Asserts that a condition is false. If it isn't it throws + * an AssertionFailedError. + */ + @SuppressWarnings("deprecation") + public static void assertFalse(boolean condition) { + Assert.assertFalse(condition); + } + + /** + * Fails a test with the given message. + */ + @SuppressWarnings("deprecation") + public static void fail(String message) { + Assert.fail(message); + } + + /** + * Fails a test with no message. + */ + @SuppressWarnings("deprecation") + public static void fail() { + Assert.fail(); + } + + /** + * Asserts that two objects are equal. If they are not + * an AssertionFailedError is thrown with the given message. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(String message, Object expected, Object actual) { + Assert.assertEquals(message, expected, actual); + } + + /** + * Asserts that two objects are equal. If they are not + * an AssertionFailedError is thrown. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(Object expected, Object actual) { + Assert.assertEquals(expected, actual); + } + + /** + * Asserts that two Strings are equal. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(String message, String expected, String actual) { + Assert.assertEquals(message, expected, actual); + } + + /** + * Asserts that two Strings are equal. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(String expected, String actual) { + Assert.assertEquals(expected, actual); + } + + /** + * Asserts that two doubles are equal concerning a delta. If they are not + * an AssertionFailedError is thrown with the given message. If the expected + * value is infinity then the delta value is ignored. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(String message, double expected, double actual, double delta) { + Assert.assertEquals(message, expected, actual, delta); + } + + /** + * Asserts that two doubles are equal concerning a delta. If the expected + * value is infinity then the delta value is ignored. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(double expected, double actual, double delta) { + Assert.assertEquals(expected, actual, delta); + } + + /** + * Asserts that two floats are equal concerning a positive delta. If they + * are not an AssertionFailedError is thrown with the given message. If the + * expected value is infinity then the delta value is ignored. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(String message, float expected, float actual, float delta) { + Assert.assertEquals(message, expected, actual, delta); + } + + /** + * Asserts that two floats are equal concerning a delta. If the expected + * value is infinity then the delta value is ignored. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(float expected, float actual, float delta) { + Assert.assertEquals(expected, actual, delta); + } + + /** + * Asserts that two longs are equal. If they are not + * an AssertionFailedError is thrown with the given message. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(String message, long expected, long actual) { + Assert.assertEquals(message, expected, actual); + } + + /** + * Asserts that two longs are equal. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(long expected, long actual) { + Assert.assertEquals(expected, actual); + } + + /** + * Asserts that two booleans are equal. If they are not + * an AssertionFailedError is thrown with the given message. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(String message, boolean expected, boolean actual) { + Assert.assertEquals(message, expected, actual); + } + + /** + * Asserts that two booleans are equal. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(boolean expected, boolean actual) { + Assert.assertEquals(expected, actual); + } + + /** + * Asserts that two bytes are equal. If they are not + * an AssertionFailedError is thrown with the given message. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(String message, byte expected, byte actual) { + Assert.assertEquals(message, expected, actual); + } + + /** + * Asserts that two bytes are equal. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(byte expected, byte actual) { + Assert.assertEquals(expected, actual); + } + + /** + * Asserts that two chars are equal. If they are not + * an AssertionFailedError is thrown with the given message. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(String message, char expected, char actual) { + Assert.assertEquals(message, expected, actual); + } + + /** + * Asserts that two chars are equal. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(char expected, char actual) { + Assert.assertEquals(expected, actual); + } + + /** + * Asserts that two shorts are equal. If they are not + * an AssertionFailedError is thrown with the given message. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(String message, short expected, short actual) { + Assert.assertEquals(message, expected, actual); + } + + /** + * Asserts that two shorts are equal. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(short expected, short actual) { + Assert.assertEquals(expected, actual); + } + + /** + * Asserts that two ints are equal. If they are not + * an AssertionFailedError is thrown with the given message. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(String message, int expected, int actual) { + Assert.assertEquals(message, expected, actual); + } + + /** + * Asserts that two ints are equal. + */ + @SuppressWarnings("deprecation") + public static void assertEquals(int expected, int actual) { + Assert.assertEquals(expected, actual); + } + + /** + * Asserts that an object isn't null. + */ + @SuppressWarnings("deprecation") + public static void assertNotNull(Object object) { + Assert.assertNotNull(object); + } + + /** + * Asserts that an object isn't null. If it is + * an AssertionFailedError is thrown with the given message. + */ + @SuppressWarnings("deprecation") + public static void assertNotNull(String message, Object object) { + Assert.assertNotNull(message, object); + } + + /** + * Asserts that an object is null. If it isn't an {@link AssertionError} is + * thrown. + * Message contains: Expected: <null> but was: object + * + * @param object Object to check or <code>null</code> + */ + @SuppressWarnings("deprecation") + public static void assertNull(Object object) { + Assert.assertNull(object); + } + + /** + * Asserts that an object is null. If it is not + * an AssertionFailedError is thrown with the given message. + */ + @SuppressWarnings("deprecation") + public static void assertNull(String message, Object object) { + Assert.assertNull(message, object); + } + + /** + * Asserts that two objects refer to the same object. If they are not + * an AssertionFailedError is thrown with the given message. + */ + @SuppressWarnings("deprecation") + public static void assertSame(String message, Object expected, Object actual) { + Assert.assertSame(message, expected, actual); + } + + /** + * Asserts that two objects refer to the same object. If they are not + * the same an AssertionFailedError is thrown. + */ + @SuppressWarnings("deprecation") + public static void assertSame(Object expected, Object actual) { + Assert.assertSame(expected, actual); + } + + /** + * Asserts that two objects do not refer to the same object. If they do + * refer to the same object an AssertionFailedError is thrown with the + * given message. + */ + @SuppressWarnings("deprecation") + public static void assertNotSame(String message, Object expected, Object actual) { + Assert.assertNotSame(message, expected, actual); + } + + /** + * Asserts that two objects do not refer to the same object. If they do + * refer to the same object an AssertionFailedError is thrown. + */ + @SuppressWarnings("deprecation") + public static void assertNotSame(Object expected, Object actual) { + Assert.assertNotSame(expected, actual); + } + + @SuppressWarnings("deprecation") + public static void failSame(String message) { + Assert.failSame(message); + } + + @SuppressWarnings("deprecation") + public static void failNotSame(String message, Object expected, Object actual) { + Assert.failNotSame(message, expected, actual); + } + + @SuppressWarnings("deprecation") + public static void failNotEquals(String message, Object expected, Object actual) { + Assert.failNotEquals(message, expected, actual); + } + + @SuppressWarnings("deprecation") + public static String format(String message, Object expected, Object actual) { + return Assert.format(message, expected, actual); + } + + /** + * Sets up the fixture, for example, open a network connection. + * This method is called before a test is executed. + */ + protected void setUp() throws Exception { + } + + /** + * Tears down the fixture, for example, close a network connection. + * This method is called after a test is executed. + */ + protected void tearDown() throws Exception { + } + + /** + * Returns a string representation of the test case + */ + @Override + public String toString() { + return getName() + "(" + getClass().getName() + ")"; + } + + /** + * Gets the name of a TestCase + * + * @return the name of the TestCase + */ + public String getName() { + return fName; + } + + /** + * Sets the name of a TestCase + * + * @param name the name to set + */ + public void setName(String name) { + fName = name; + } } |