asproject 0.1.21

data/templates/asproject/asunit3/project/lib/asunit/asunit/framework/AsynchronousTestCase.as

@@ -0,0 +1,52 @@
+package asunit.framework {
+	import flash.net.URLRequest;
+	import flash.net.URLLoader;
+	import flash.events.*;
+	import flash.errors.IllegalOperationError;
+
+	/**
+	 * Extend this class if you have a TestCase that requires the
+	 * asynchronous load of external data.
+	 */
+	public class AsynchronousTestCase extends TestCase {
+		
+		public function AsynchronousTestCase(testMethod:String = null) {
+			super(testMethod);
+		}
+
+		protected function configureListeners(loader:URLLoader):void {
+			loader.addEventListener(Event.COMPLETE, completeHandler);
+			loader.addEventListener(HTTPStatusEvent.HTTP_STATUS, httpStatusHandler);
+			loader.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
+			loader.addEventListener(Event.OPEN, openHandler);
+			loader.addEventListener(ProgressEvent.PROGRESS, progressHandler);
+			loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
+		}
+
+		// override this method and implement your own completeHandler
+		// you should be sure to call super.run() from the body of
+		// this override.
+		protected function completeHandler(event:Event):void {
+		}
+
+		// TODO: add support for failing status events...
+		protected function httpStatusHandler(event:HTTPStatusEvent):void {
+		}
+
+		protected function ioErrorHandler(event:IOErrorEvent):void {
+			result.addError(this, new IllegalOperationError(event.toString()));
+			isComplete = true;
+		}
+
+		protected function openHandler(event:Event):void {
+		}
+
+		protected function progressHandler(event:ProgressEvent):void {
+		}
+
+		protected function securityErrorHandler(event:SecurityErrorEvent):void {
+			result.addError(this, new IllegalOperationError(event.toString()));
+			isComplete = true;
+		}
+	}
+}

data/templates/asproject/asunit3/project/lib/asunit/asunit/framework/AsynchronousTestCaseExample.as

@@ -0,0 +1,71 @@
+package asunit.framework {
+	import flash.net.URLRequest;
+	import flash.net.URLLoader;
+	import flash.events.*;
+	
+	/**
+	 * This example is built on the following mock data:
+	 * <books>
+	 * 		<book publisher="Addison-Wesley" name="Design Patterns" />
+	 * 		<book publisher="Addison-Wesley" name="The Pragmattic Programmer" />
+	 * 		<book publisher="Addison-Wesley" name="Test Driven Development" />
+	 * 		<book publisher="Addison-Wesley" name="Refactoring to Patterns" />
+	 * 		<book publisher="O'Reilly Media" name="The Cathedral & the Bazaar" />
+	 * 		<book publisher="O'Reilly Media" name="Unit Test Frameworks" />
+	 * 	</books>
+	 * 
+	 * This example was created to illustrate how one can build an synchronous
+	 * TestCase - one that relies on remote data of some sort.
+	 * This use case is now diminished by the creation of E4X and easily
+	 * readable/editable XML data directly in source form.
+	 * But asynchronous tests will probably need to be built at some point
+	 * by somebody... If you're them, maybe you can use this as a template.
+	 */
+
+	public class AsynchronousTestCaseExample extends AsynchronousTestCase {
+		private var source:String = "asunit/framework/MockData.xml";
+		private var dataSource:XML;
+		private var instance:Object;
+
+		// Override the run method and begin the request for remote data
+		public override function run():void {
+			var request:URLRequest = new URLRequest(source);
+			var loader:URLLoader = new URLLoader();
+			// configureListeners is a method on the AsynchronousTestCase
+			// and it will handle error states by failing loudly...
+			configureListeners(loader);
+			loader.load(request);
+		}
+
+		protected override function completeHandler(event:Event):void {
+			// put a copy of the data into a member reference
+			dataSource = XML(event.target.data).copy();
+			// call super.run() to execute test methods
+			super.run();
+		}
+		
+		protected override function setUp():void {
+			// create a new instance of the class under test
+			instance = new Object();
+			// copy the data into a member or method of the instance
+			instance.data = dataSource.copy();			
+		}
+		
+		protected override function tearDown():void {
+			// destroy the class under test instance
+			instance = null;
+		}
+		
+		public function testBookCount():void {
+			var data:XML = XML(instance.data);
+			var list:XMLList = data..book;
+			assertTrue("list.length() == " + list.length() + " (6?)", list.length() == 6);
+		}
+		
+		public function testOReillyBookCount():void {
+			var data:XML = XML(instance.data);
+			var list:XMLList = data..book.(@publisher == "O'Reilly Media");
+			assertTrue("list.length() == " + list.length() + " (2?)", list.length() == 2);			
+		}
+	}
+}

data/templates/asproject/asunit3/project/lib/asunit/asunit/framework/Test.as

@@ -0,0 +1,15 @@
+package asunit.framework {
+	import flash.display.DisplayObjectContainer;
+	import flash.events.IEventDispatcher;
+		
+	public interface Test extends IEventDispatcher {
+		function countTestCases():int;
+		function toString():String;
+		function setResult(result:TestResult):void;
+		function run():void;
+		function getCurrentMethod():String;
+		function getIsComplete():Boolean;
+		function setContext(context:DisplayObjectContainer):void;
+		function getContext():DisplayObjectContainer;
+	}
+}

data/templates/asproject/asunit3/project/lib/asunit/asunit/framework/TestCase.as

@@ -0,0 +1,351 @@
+package asunit.framework {
+	import asunit.errors.AssertionFailedError;
+	
+	import flash.display.DisplayObject;
+	import flash.display.DisplayObjectContainer;
+	import flash.errors.IllegalOperationError;
+	import flash.utils.describeType;
+	import asunit.util.Iterator;
+	import asunit.util.ArrayIterator;
+	import flash.net.getClassByAlias;
+	import flash.events.Event;
+	import flash.utils.Timer;
+	import flash.events.TimerEvent;
+	import flash.utils.setTimeout;
+	import flash.utils.clearTimeout;
+	import flash.utils.getDefinitionByName;
+
+	/**
+	 * A test case defines the fixture to run multiple tests. To define a test case<br>
+	 * 1) implement a subclass of TestCase<br>
+	 * 2) define instance variables that store the state of the fixture<br>
+	 * 3) initialize the fixture state by overriding <code>setUp</code><br>
+	 * 4) clean-up after a test by overriding <code>tearDown</code>.<br>
+	 * 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 <code>assertTrue</code> 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 <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 {
+		/**
+		 * the name of the test case
+		 */
+		protected static const DEFAULT_TIMEOUT:int = 1000;
+		protected var fName:String;
+		protected var result:TestResult;
+		protected var testMethods:Array;
+		protected var isComplete:Boolean;
+		protected var context:DisplayObjectContainer;
+		protected var methodIsAsynchronous:Boolean;
+		protected var timeout:Timer;
+		private var currentMethod:String;
+		private var runSingle:Boolean;
+		private var methodIterator:Iterator;
+		private var layoutManager:Object;
+
+		/**
+		 * Constructs a test case with the given name.
+		 */
+		public function TestCase(testMethod:String = null) {
+			var description:XML = describeType(this);
+			var className:Object = description.@name;
+			var methods:XMLList = description..method.(@name.match("^test"));
+			if(testMethod != null) {
+				testMethods = testMethod.split(", ").join(",").split(",");
+				if(testMethods.length == 1) {
+					runSingle = true;
+				}
+			} else {
+				setTestMethods(methods);
+			}
+			setName(className.toString());
+			resolveLayoutManager();
+		}
+		
+		private function resolveLayoutManager():void {
+			// Avoid creating import dependencies on flex framework
+			// If you have the framework.swc in your classpath,
+			// the layout manager will be found, if not, a mcok
+			// will be used.
+			try {
+				var manager:Class = getDefinitionByName("mx.managers.LayoutManager") as Class;
+				layoutManager = manager["getInstance"]();
+			}
+			catch(e:Error) {
+				layoutManager = new Object();
+				layoutManager.resetAll = function():void {
+				}
+			}
+		}
+
+		/**
+		 * Sets the name of a TestCase
+		 * @param name The name to set
+		 */
+		public function setName(name:String):void {
+			fName = name;
+		}
+
+		protected function setTestMethods(methodNodes:XMLList):void {
+			testMethods = new Array();
+			var methodNames:Object = methodNodes.@name;
+			var name:String;
+			for each(var item:Object in methodNames) {
+				name = item.toString();
+				testMethods.push(name);
+			}
+		}
+
+		/**
+		 * Counts the number of test cases executed by run(TestResult result).
+		 */
+		public function countTestCases():int {
+			return testMethods.length;
+		}
+
+		/**
+		 * Creates a default TestResult object
+		 *
+		 * @see TestResult
+		 */
+		protected function createResult():TestResult {
+		    return new TestResult();
+		}
+
+		/**
+		 * A convenience method to run this test, collecting the results with
+		 * either the TestResult provided or a default, new TestResult object.
+		 * Expects either:
+		 * run():void // will return the newly created TestResult
+		 * run(result:TestResult):TestResult // will use the TestResult
+		 * that was passed in.
+		 *
+		 * @see TestResult
+		 */
+		public function run():void {
+			getResult().run(this);
+		}
+
+		public function setResult(result:TestResult):void {
+			this.result = result;
+		}
+
+		protected function getResult():TestResult {
+			return (result == null) ? createResult() : result;
+		}
+
+		/**
+		 * Runs the bare test sequence.
+		 * @exception Error if any exception is thrown
+		 *  throws Error
+		 */
+		public function runBare():void {
+			if(isComplete) {
+				return;
+			}
+			var name:String;
+			var itr:Iterator = getMethodIterator();
+			if(itr.hasNext()) {
+				name = String(itr.next());
+				runMethod(name);
+			}
+			else {
+				cleanUp();
+				getResult().endTest(this);
+				isComplete = true;
+				dispatchEvent(new Event(Event.COMPLETE));
+			}
+		}
+		
+		private function getMethodIterator():Iterator {
+			if(methodIterator == null) {
+				methodIterator = new ArrayIterator(testMethods);
+			}
+			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 {
+		}
+		
+		private function runMethod(methodName:String):void {
+			try {
+				setUp();
+				currentMethod = methodName;
+				methodIsAsynchronous = false;
+				this[methodName]();
+			}
+			catch(assertionFailedError:AssertionFailedError) {
+				getResult().addFailure(this, assertionFailedError);
+			}
+			catch(unknownError:Error) {
+				getResult().addError(this, unknownError);
+			}
+			finally {
+				if(!methodIsAsynchronous) {
+					runTearDown();
+				}
+			}
+		}
+
+		/**
+		 * Sets up the fixture, for example, instantiate a mock object.
+		 * This method is called before each test is executed.
+		 * throws Exception on error
+		 */
+		protected function setUp():void {
+		}
+		/**
+		 * Tears down the fixture, for example, delete mock object.
+		 * This method is called after a test is executed.
+		 *  throws Exception on error
+		 */
+		protected function tearDown():void {
+		}
+		/**
+		 * Returns a string representation of the test case
+		 */
+		override public function toString():String {
+			return getName() + "." + getCurrentMethod() + "()";
+		}
+		/**
+		 * Gets the name of a TestCase
+		 * @return returns a String
+		 */
+		public function getName():String {
+			return fName;
+		}
+
+		public function getCurrentMethod():String {
+			return currentMethod;
+		}
+
+		public function getIsComplete():Boolean {
+			return isComplete;
+		}
+
+		public function setContext(context:DisplayObjectContainer):void {
+			this.context = context;
+		}
+
+		public function getContext():DisplayObjectContainer {
+			return context;
+		}
+
+		protected function addAsync(handler:Function = null, duration:Number=DEFAULT_TIMEOUT):Function {
+			if(handler == null) {
+				handler = function(args:*):* {};
+			}
+			methodIsAsynchronous = true;
+			timeout = new Timer(duration, 1);
+			timeout.addEventListener(TimerEvent.TIMER_COMPLETE, getTimeoutComplete(duration));
+			timeout.start();
+			// try ..args
+			var context:TestCase = this;
+			return function(args:*):* {
+				context.timeout.stop();
+				try {
+					handler.apply(context, arguments);
+				}
+				catch(e:AssertionFailedError) {
+					context.getResult().addFailure(context, e);
+				}
+				catch(ioe:IllegalOperationError) {
+					context.getResult().addError(context, ioe);
+				}
+				finally {
+					context.runTearDown();
+				}
+			}
+		}
+		
+		private function getTimeoutComplete(duration:Number):Function {
+			var context:TestCase = this;
+			return function(event:Event):void {
+				context.getResult().addError(context, new IllegalOperationError("TestCase.timeout (" + duration + "ms) exceeded on an asynchronous test method."));
+				context.runTearDown();
+			}
+		}
+
+		protected function runTearDown():void {
+			if(isComplete) {
+				return;
+			}
+			if(!runSingle) {
+				tearDown();
+				layoutManager.resetAll();
+			}
+			setTimeout(runBare, 5);
+		}
+		
+		protected function addChild(child:DisplayObject):DisplayObject {
+			return getContext().addChild(child);
+		}
+
+		protected function removeChild(child:DisplayObject):DisplayObject {
+			if(child == null) {
+				throw new IllegalOperationError("TestCase.removeChild must have non-null parameter child");
+			}
+			return getContext().removeChild(child);
+		}
+
+//		public function fail(message:String):void {
+//			result.addFailure(this, new AssertionFailedError(message));
+//		}
+	}
+}