public function testDispatcher():void {
              var dispatcher:IEventDispatcher = new EventDispatcher();
              // Subscribe to an event by sending the return value of addAsync:
              dispatcher.addEventListener(Event.COMPLETE, addAsync(function(event:Event):void {
                  // Make assertions nsideyour async handler:
                  assertEquals(34, dispatcher.value);
              }));
          }
          

          public function testDispatcher():void {
              var dispatcher:IEventDispatcher = new EventDispatcher();
              dispatcher.addEventListener(Event.COMPLETE, addAsync());
          }
          

          private var instance:MyComponent;
        
          override protected function setUp():void {
              super.setUp();
              instance = new MyComponent();
              instance.addEventListener(Event.COMPLETE, addAsync());
              addChild(instance);
          }
        
          override protected function tearDown():void {
              super.tearDown();
              removeChild(instance);
          }
        
          public function testParam():void {
              assertEquals(34, instance.value);
          }
        

          private var instance:MyInstance;
          
          override protected function setUp():void {
              super.setUp();
              instance = new MyInstance();
              addChild(instance);
          }
          

          private var instance:MyInstance;
          
          override protected function setUp():void {
              super.setUp();
              instance = new MyInstance();
              addChild(instance);
          }
          
          override protected function tearDown():void {
              super.tearDown();
              removeChild(instance);
          }
          

// Assume we are testing a class that looks like this:
package utils {
    
    public class MathUtil {
        
        // Add one to the number provided:
        public function addOne(num:Number):Number {
            return num + 1;
        }
    }
}


// This is a test case for the class above:
package utils {

    import asunit.framework.TestCase;

    public class MathUtilTest extends TestCase {
        private var mathUtil:MathUtil;

        public function MathUtilTest(methodName:String=null) {
            super(methodName)
        }

        override protected function setUp():void {
            super.setUp();
            mathUtil = new MathUtil();
        }

        override protected function tearDown():void {
            super.tearDown();
            mathUtil = null;
        }

        public function testInstantiated():void {
            assertTrue("mathUtil is MathUtil", mathUtil is MathUtil);
        }

        public function testAddOne():void {
            assertEquals(5, mathUtil.addOne(4));
        }
    }
}

For the purpose of the following test example, we'll be using a Runner that
looks like this:

package {
    import asunit.textui.TestRunner;
    import controls.ViewComponentTest;
    
    public class SomeProjectRunner extends TestRunner {

        public function SomeProjectRunner() {
            // start(clazz:Class, methodName:String, showTrace:Boolean)
            // NOTE: sending a particular class and method name will
            // execute setUp(), the method and NOT tearDown.
            // This allows you to get visual confirmation while developing
            // visual entities
            start(ViewComponentTest, 'testGoToHalfSize', TestRunner.SHOW_TRACE);
        }
    }
}

The following Component is a visual component whose primary feature
is the 'goToHalfSize' method.

package controls {
    
    import flash.display.Sprite;
    import flash.events.Event;
    
    public class ViewComponent extends Sprite {
        
        private var _width:Number;
        private var _height:Number;
        
        public function ViewComponent() {
            _width = 640;
            _height = 480;
        }
        
        public function draw():void {
            graphics.clear();
            graphics.beginFill(0xFFCC00);
            graphics.drawRect(0, 0, width, height);
            graphics.endFill();
        }
        
        public function goToHalfSize():void {
            width = Math.round(width / 2);
            height = Math.round(height / 2);
            draw();
        }
        
        override public function set width(width:Number):void {
            _width = width;
        }

        override public function get width():Number {
            return _width;
        }

        override public function set height(height:Number):void {
            _height = height;
        }

        override public function get height():Number {
            return _height;
        }
    }
}

And finally, the test case that will validate the ViewComponent class and
it's goToHalfSize method.

package controls {

    import asunit.framework.TestCase;

    public class ViewComponentTest extends TestCase {
        private var instance:ViewComponent;

        public function ViewComponentTest(methodName:String=null) {
            super(methodName)
        }

        override protected function setUp():void {
            super.setUp();
            instance = new ViewComponent();
            addChild(instance);
        }

        override protected function tearDown():void {
            super.tearDown();
            removeChild(instance);
            instance = null;
        }

        public function testInstantiated():void {
            assertTrue("instance is ViewComponent", instance is ViewComponent);
        }

        public function testGoToHalfSize():void {
            instance.width = 400;
            instance.height = 200;
            instance.goToHalfSize();

            assertEquals('width', 200, instance.width);
            assertEquals('height', 100, instance.height);
        }
    }
}

Assume we have a feature that performs some asynchronous action:

package net {
    
    import flash.events.Event;
    import flash.events.EventDispatcher;
    import flash.utils.setTimeout;
    
    [Event(name="complete", type="flash.events.Event")]
    public class AsyncMethod extends EventDispatcher {
        
        public function doSomething():void {
            setTimeout(function():void {
                dispatchEvent(new Event(Event.COMPLETE));
            }, 100);
        }
    }
}

We can test this feature with the following test case:
package net {

    import asunit.framework.TestCase;
    import flash.events.Event;

    public class AsyncMethodTest extends TestCase {
        private var instance:AsyncMethod;

        public function AsyncMethodTest(methodName:String=null) {
            super(methodName)
        }

        override protected function setUp():void {
            super.setUp();
            instance = new AsyncMethod();
        }

        override protected function tearDown():void {
            super.tearDown();
            instance = null;
        }

        public function testInstantiated():void {
            assertTrue("instance is AsyncMethod", instance is AsyncMethod);
        }

        public function testDoSomething():void {
            instance.addEventListener(Event.COMPLETE, addAsync());
            instance.doSomething();
        }
    }
}