package junit.framework;
   
   import java.lang.reflect.InvocationTargetException;
   import java.lang.reflect.Method;
   import java.lang.reflect.Modifier;
   
   /**
    * A test case defines the fixture to run multiple tests. To define a test case<br/>
    * <ol>
   *   <li>implement a subclass of <code>TestCase</code></li>
   *   <li>define instance variables that store the state of the fixture</li>
   *   <li>initialize the fixture state by overriding {@link #setUp()}</li>
   *   <li>clean-up after a test by overriding {@link #tearDown()}.</li>
   * </ol>
   * Each test runs in its own fixture so there
   * can be no side effects among test runs.
   * Here is an example:
   * <pre>
   * public class MathTest extends TestCase {
   *    protected double fValue1;
   *    protected double fValue2;
   *
   *    protected void setUp() {
   *       fValue1= 2.0;
   *       fValue2= 3.0;
   *    }
   * }
   * </pre>
   *
   * For each test implement a method which interacts
   * with the fixture. Verify the expected results with assertions specified
   * by calling {@link junit.framework.Assert#assertTrue(String, boolean)} with a boolean.
   * <pre>
   *    public void testAdd() {
   *       double result= fValue1 + fValue2;
   *       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
   * be invoked. A convenient way to do so is with an anonymous inner class.
   * <pre>
   * TestCase test= new MathTest("add") {
   *    public void runTest() {
   *       testAdd();
   *    }
   * };
   * 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
   * to be run.
   * <pre>
   * 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
   * point to get a test to run or it will extract the suite automatically.
   * <pre>
   * public static Test suite() {
   *    suite.addTest(new MathTest("testAdd"));
   *    suite.addTest(new MathTest("testDivideByZero"));
   *    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;
         }
     }
 
     /**
      * 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;
     }
 }