      * Here is an example:
      * <pre>
      * public class MathTest extends TestCase {
-     *      protected double fValue1;
-     *      protected double fValue2;
+     *      private var value1:Number;
+     *      private var value2:Number;
      * 
      *      public function MathTest(methodName:String=null) {
      *         super(methodName);
      *      }
      *
-     *      protected void setUp() {
-     *         fValue1= 2.0;
-     *         fValue2= 3.0;
+     *      override protected function setUp():void {
+     *         super.setUp();
+     *         value1 = 2;
+     *         value2 = 3;
      *      }
      * }
      * </pre>
      *
      * For each test implement a method which interacts
      * with the fixture. Verify the expected results with assertions specified
-     * by calling <code>assertTrue</code> with a boolean.
+     * by calling <code>assertTrue</code> with a boolean, or <code>assertEquals</code>
+     * with two primitive values that should match.
      * <pre>
-     *    public void testAdd() {
-     *        double result= fValue1 + fValue2;
-     *        assertTrue(result == 5.0);
+     *    public function testAdd():void {
+     *        var result:Number = value1 + value2;
+     *        assertEquals(5, result);
      *    }
      * </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 <code>runTest</code>. 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= 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 class TestCase extends Assert implements Test {
         protected static const PRE_SET_UP:int        = 0;

            return methodIterator;
        }

        // Override this method in Asynchronous test cases
        // or any other time you want to perform additional
        // member cleanup after all test methods have run
        protected function cleanUp():void {
        }
        

        protected static const RUN_METHOD:int         = 2;
        protected static const TEAR_DOWN:int        = 3;
        protected static const DEFAULT_TIMEOUT:int     = 1000;

        protected var context:DisplayObjectContainer;
        protected var fName:String;
        protected var isComplete:Boolean;
        protected var result:TestListener;
        protected var testMethods:Array;

        private var asyncQueue:Array;
        private var currentMethod:String;
        private var currentState:int;
        private var layoutManager:Object;
        private var methodIterator:Iterator;
        private var runSingle:Boolean;

        /**
         * Constructs a test case with the given name.
         *  
         * Be sure to implement the constructor in your own TestCase base classes.
         * 
         * Using the optional <code>testMethod</code> constructor parameter is how we 
         * create and run a single test case and test method.
         */
        public function TestCase(testMethod:String = null) {
            var description:XML = describeType(this);
