    001    package junit.framework;
    002
    003    import java.lang.reflect.InvocationTargetException;
    004    import java.lang.reflect.Method;
    005    import java.lang.reflect.Modifier;
    006
    007    /**
    008     * A test case defines the fixture to run multiple tests. To define a test case<br/>
    009     * <ol>
    010     *   <li>implement a subclass of <code>TestCase</code></li>
    011     *   <li>define instance variables that store the state of the fixture</li>
    012     *   <li>initialize the fixture state by overriding {@link #setUp()}</li>
    013     *   <li>clean-up after a test by overriding {@link #tearDown()}.</li>
    014     * </ol>
    015     * Each test runs in its own fixture so there
    016     * can be no side effects among test runs.
    017     * Here is an example:
    018     * <pre>
    019     * public class MathTest extends TestCase {
    020     *    protected double fValue1;
    021     *    protected double fValue2;
    022     *
    023     *    protected void setUp() {
    024     *       fValue1= 2.0;
    025     *       fValue2= 3.0;
    026     *    }
    027     * }
    028     * </pre>
    029     *
    030     * For each test implement a method which interacts
    031     * with the fixture. Verify the expected results with assertions specified
    032     * by calling {@link junit.framework.Assert#assertTrue(String, boolean)} with a boolean.
    033     * <pre>
    034     *    public void testAdd() {
    035     *       double result= fValue1 + fValue2;
    036     *       assertTrue(result == 5.0);
    037     *    }
    038     * </pre>
    039     *
    040     * Once the methods are defined you can run them. The framework supports
    041     * both a static type safe and more dynamic way to run a test.
    042     * In the static way you override the runTest method and define the method to
    043     * be invoked. A convenient way to do so is with an anonymous inner class.
    044     * <pre>
    045     * TestCase test= new MathTest("add") {
    046     *    public void runTest() {
    047     *       testAdd();
    048     *    }
    049     * };
    050     * test.run();
    051     * </pre>
    052     * The dynamic way uses reflection to implement {@link #runTest()}. It dynamically finds
    053     * and invokes a method.
    054     * In this case the name of the test case has to correspond to the test method
    055     * to be run.
    056     * <pre>
    057     * TestCase test= new MathTest("testAdd");
    058     * test.run();
    059     * </pre>
    060     *
    061     * The tests to be run can be collected into a TestSuite. JUnit provides
    062     * different <i>test runners</i> which can run a test suite and collect the results.
    063     * A test runner either expects a static method <code>suite</code> as the entry
    064     * point to get a test to run or it will extract the suite automatically.
    065     * <pre>
    066     * public static Test suite() {
    067     *    suite.addTest(new MathTest("testAdd"));
    068     *    suite.addTest(new MathTest("testDivideByZero"));
    069     *    return suite;
    070     * }
    071     * </pre>
    072     *
    073     * @see TestResult
    074     * @see TestSuite
    075     */
    076    @SuppressWarnings("deprecation")
    077    public abstract class TestCase extends Assert implements Test {
    078        /**
    079         * the name of the test case
    080         */
    081        private String fName;
    082
    083        /**
    084         * No-arg constructor to enable serialization. This method
    085         * is not intended to be used by mere mortals without calling setName().
    086         */
    087        public TestCase() {
    088            fName = null;
    089        }
    090
    091        /**
    092         * Constructs a test case with the given name.
    093         */
    094        public TestCase(String name) {
    095            fName = name;
    096        }
    097
    098        /**
    099         * Counts the number of test cases executed by run(TestResult result).
    100         */
    101        public int countTestCases() {
    102            return 1;
    103        }
    104
    105        /**
    106         * Creates a default TestResult object.
    107         *
    108         * @see TestResult
    109         */
    110        protected TestResult createResult() {
    111            return new TestResult();
    112        }
    113
    114        /**
    115         * A convenience method to run this test, collecting the results with a
    116         * default TestResult object.
    117         *
    118         * @see TestResult
    119         */
    120        public TestResult run() {
    121            TestResult result = createResult();
    122            run(result);
    123            return result;
    124        }
    125
    126        /**
    127         * Runs the test case and collects the results in TestResult.
    128         */
    129        public void run(TestResult result) {
    130            result.run(this);
    131        }
    132
    133        /**
    134         * Runs the bare test sequence.
    135         *
    136         * @throws Throwable if any exception is thrown
    137         */
    138        public void runBare() throws Throwable {
    139            Throwable exception = null;
    140            setUp();
    141            try {
    142                runTest();
    143            } catch (Throwable running) {
    144                exception = running;
    145            } finally {
    146                try {
    147                    tearDown();
    148                } catch (Throwable tearingDown) {
    149                    if (exception == null) exception = tearingDown;
    150                }
    151            }
    152            if (exception != null) throw exception;
    153        }
    154
    155        /**
    156         * Override to run the test and assert its state.
    157         *
    158         * @throws Throwable if any exception is thrown
    159         */
    160        protected void runTest() throws Throwable {
    161            assertNotNull("TestCase.fName cannot be null", fName); // Some VMs crash when calling getMethod(null,null);
    162            Method runMethod = null;
    163            try {
    164                // use getMethod to get all public inherited
    165                // methods. getDeclaredMethods returns all
    166                // methods of this class but excludes the
    167                // inherited ones.
    168                runMethod = getClass().getMethod(fName, (Class[]) null);
    169            } catch (NoSuchMethodException e) {
    170                fail("Method \"" + fName + "\" not found");
    171            }
    172            if (!Modifier.isPublic(runMethod.getModifiers())) {
    173                fail("Method \"" + fName + "\" should be public");
    174            }
    175
    176            try {
    177                runMethod.invoke(this);
    178            } catch (InvocationTargetException e) {
    179                e.fillInStackTrace();
    180                throw e.getTargetException();
    181            } catch (IllegalAccessException e) {
    182                e.fillInStackTrace();
    183                throw e;
    184            }
    185        }
    186
    187        /**
    188         * Asserts that a condition is true. If it isn't it throws
    189         * an AssertionFailedError with the given message.
    190         */
    191        public static void assertTrue(String message, boolean condition) {
    192            Assert.assertTrue(message, condition);
    193        }
    194
    195        /**
    196         * Asserts that a condition is true. If it isn't it throws
    197         * an AssertionFailedError.
    198         */
    199        public static void assertTrue(boolean condition) {
    200            Assert.assertTrue(condition);
    201        }
    202
    203        /**
    204         * Asserts that a condition is false. If it isn't it throws
    205         * an AssertionFailedError with the given message.
    206         */
    207        public static void assertFalse(String message, boolean condition) {
    208            Assert.assertFalse(message, condition);
    209        }
    210
    211        /**
    212         * Asserts that a condition is false. If it isn't it throws
    213         * an AssertionFailedError.
    214         */
    215        public static void assertFalse(boolean condition) {
    216            Assert.assertFalse(condition);
    217        }
    218
    219        /**
    220         * Fails a test with the given message.
    221         */
    222        public static void fail(String message) {
    223            Assert.fail(message);
    224        }
    225
    226        /**
    227         * Fails a test with no message.
    228         */
    229        public static void fail() {
    230            Assert.fail();
    231        }
    232
    233        /**
    234         * Asserts that two objects are equal. If they are not
    235         * an AssertionFailedError is thrown with the given message.
    236         */
    237        public static void assertEquals(String message, Object expected, Object actual) {
    238            Assert.assertEquals(message, expected, actual);
    239        }
    240
    241        /**
    242         * Asserts that two objects are equal. If they are not
    243         * an AssertionFailedError is thrown.
    244         */
    245        public static void assertEquals(Object expected, Object actual) {
    246            Assert.assertEquals(expected, actual);
    247        }
    248
    249        /**
    250         * Asserts that two Strings are equal.
    251         */
    252        public static void assertEquals(String message, String expected, String actual) {
    253            Assert.assertEquals(message, expected, actual);
    254        }
    255
    256        /**
    257         * Asserts that two Strings are equal.
    258         */
    259        public static void assertEquals(String expected, String actual) {
    260            Assert.assertEquals(expected, actual);
    261        }
    262
    263        /**
    264         * Asserts that two doubles are equal concerning a delta.  If they are not
    265         * an AssertionFailedError is thrown with the given message.  If the expected
    266         * value is infinity then the delta value is ignored.
    267         */
    268        public static void assertEquals(String message, double expected, double actual, double delta) {
    269            Assert.assertEquals(message, expected, actual, delta);
    270        }
    271
    272        /**
    273         * Asserts that two doubles are equal concerning a delta. If the expected
    274         * value is infinity then the delta value is ignored.
    275         */
    276        public static void assertEquals(double expected, double actual, double delta) {
    277            Assert.assertEquals(expected, actual, delta);
    278        }
    279
    280        /**
    281         * Asserts that two floats are equal concerning a positive delta. If they
    282         * are not an AssertionFailedError is thrown with the given message. If the
    283         * expected value is infinity then the delta value is ignored.
    284         */
    285        public static void assertEquals(String message, float expected, float actual, float delta) {
    286            Assert.assertEquals(message, expected, actual, delta);
    287        }
    288
    289        /**
    290         * Asserts that two floats are equal concerning a delta. If the expected
    291         * value is infinity then the delta value is ignored.
    292         */
    293        public static void assertEquals(float expected, float actual, float delta) {
    294            Assert.assertEquals(expected, actual, delta);
    295        }
    296
    297        /**
    298         * Asserts that two longs are equal. If they are not
    299         * an AssertionFailedError is thrown with the given message.
    300         */
    301        public static void assertEquals(String message, long expected, long actual) {
    302            Assert.assertEquals(message, expected, actual);
    303        }
    304
    305        /**
    306         * Asserts that two longs are equal.
    307         */
    308        public static void assertEquals(long expected, long actual) {
    309            Assert.assertEquals(expected, actual);
    310        }
    311
    312        /**
    313         * Asserts that two booleans are equal. If they are not
    314         * an AssertionFailedError is thrown with the given message.
    315         */
    316        public static void assertEquals(String message, boolean expected, boolean actual) {
    317            Assert.assertEquals(message, expected, actual);
    318        }
    319
    320        /**
    321         * Asserts that two booleans are equal.
    322         */
    323        public static void assertEquals(boolean expected, boolean actual) {
    324            Assert.assertEquals(expected, actual);
    325        }
    326
    327        /**
    328         * Asserts that two bytes are equal. If they are not
    329         * an AssertionFailedError is thrown with the given message.
    330         */
    331        public static void assertEquals(String message, byte expected, byte actual) {
    332            Assert.assertEquals(message, expected, actual);
    333        }
    334
    335        /**
    336         * Asserts that two bytes are equal.
    337         */
    338        public static void assertEquals(byte expected, byte actual) {
    339            Assert.assertEquals(expected, actual);
    340        }
    341
    342        /**
    343         * Asserts that two chars are equal. If they are not
    344         * an AssertionFailedError is thrown with the given message.
    345         */
    346        public static void assertEquals(String message, char expected, char actual) {
    347            Assert.assertEquals(message, expected, actual);
    348        }
    349
    350        /**
    351         * Asserts that two chars are equal.
    352         */
    353        public static void assertEquals(char expected, char actual) {
    354            Assert.assertEquals(expected, actual);
    355        }
    356
    357        /**
    358         * Asserts that two shorts are equal. If they are not
    359         * an AssertionFailedError is thrown with the given message.
    360         */
    361        public static void assertEquals(String message, short expected, short actual) {
    362            Assert.assertEquals(message, expected, actual);
    363        }
    364
    365        /**
    366         * Asserts that two shorts are equal.
    367         */
    368        public static void assertEquals(short expected, short actual) {
    369            Assert.assertEquals(expected, actual);
    370        }
    371
    372        /**
    373         * Asserts that two ints are equal. If they are not
    374         * an AssertionFailedError is thrown with the given message.
    375         */
    376        public static void assertEquals(String message, int expected, int actual) {
    377            Assert.assertEquals(message, expected, actual);
    378        }
    379
    380        /**
    381         * Asserts that two ints are equal.
    382         */
    383        public static void assertEquals(int expected, int actual) {
    384            Assert.assertEquals(expected, actual);
    385        }
    386
    387        /**
    388         * Asserts that an object isn't null.
    389         */
    390        public static void assertNotNull(Object object) {
    391            Assert.assertNotNull(object);
    392        }
    393
    394        /**
    395         * Asserts that an object isn't null. If it is
    396         * an AssertionFailedError is thrown with the given message.
    397         */
    398        public static void assertNotNull(String message, Object object) {
    399            Assert.assertNotNull(message, object);
    400        }
    401
    402        /**
    403         * Asserts that an object is null. If it isn't an {@link AssertionError} is
    404         * thrown.
    405         * Message contains: Expected: <null> but was: object
    406         *
    407         * @param object Object to check or <code>null</code>
    408         */
    409        public static void assertNull(Object object) {
    410            Assert.assertNull(object);
    411        }
    412
    413        /**
    414         * Asserts that an object is null.  If it is not
    415         * an AssertionFailedError is thrown with the given message.
    416         */
    417        public static void assertNull(String message, Object object) {
    418            Assert.assertNull(message, object);
    419        }
    420
    421        /**
    422         * Asserts that two objects refer to the same object. If they are not
    423         * an AssertionFailedError is thrown with the given message.
    424         */
    425        public static void assertSame(String message, Object expected, Object actual) {
    426            Assert.assertSame(message, expected, actual);
    427        }
    428
    429        /**
    430         * Asserts that two objects refer to the same object. If they are not
    431         * the same an AssertionFailedError is thrown.
    432         */
    433        public static void assertSame(Object expected, Object actual) {
    434            Assert.assertSame(expected, actual);
    435        }
    436
    437        /**
    438         * Asserts that two objects do not refer to the same object. If they do
    439         * refer to the same object an AssertionFailedError is thrown with the
    440         * given message.
    441         */
    442        public static void assertNotSame(String message, Object expected, Object actual) {
    443            Assert.assertNotSame(message, expected, actual);
    444        }
    445
    446        /**
    447         * Asserts that two objects do not refer to the same object. If they do
    448         * refer to the same object an AssertionFailedError is thrown.
    449         */
    450        public static void assertNotSame(Object expected, Object actual) {
    451            Assert.assertNotSame(expected, actual);
    452        }
    453
    454        public static void failSame(String message) {
    455            Assert.failSame(message);
    456        }
    457
    458        public static void failNotSame(String message, Object expected, Object actual) {
    459            Assert.failNotSame(message, expected, actual);
    460        }
    461
    462        public static void failNotEquals(String message, Object expected, Object actual) {
    463            Assert.failNotEquals(message, expected, actual);
    464        }
    465
    466        public static String format(String message, Object expected, Object actual) {
    467            return Assert.format(message, expected, actual);
    468        }
    469
    470        /**
    471         * Sets up the fixture, for example, open a network connection.
    472         * This method is called before a test is executed.
    473         */
    474        protected void setUp() throws Exception {
    475        }
    476
    477        /**
    478         * Tears down the fixture, for example, close a network connection.
    479         * This method is called after a test is executed.
    480         */
    481        protected void tearDown() throws Exception {
    482        }
    483
    484        /**
    485         * Returns a string representation of the test case.
    486         */
    487        @Override
    488        public String toString() {
    489            return getName() + "(" + getClass().getName() + ")";
    490        }
    491
    492        /**
    493         * Gets the name of a TestCase.
    494         *
    495         * @return the name of the TestCase
    496         */
    497        public String getName() {
    498            return fName;
    499        }
    500
    501        /**
    502         * Sets the name of a TestCase.
    503         *
    504         * @param name the name to set
    505         */
    506        public void setName(String name) {
    507            fName = name;
    508        }
    509    }