asunit4 4.2.1.pre

data/src/asunit/framework/Async.as

@@ -0,0 +1,138 @@
+package asunit.framework {
+
+	import asunit.framework.ErrorEvent;
+
+	import asunit.events.TimeoutCommandEvent;
+
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	import flash.events.IEventDispatcher;
+
+	public class Async extends EventDispatcher implements IAsync {
+		
+		public static var DEFAULT_TIMEOUT:uint = 50;
+		
+        private var _timeout:int = DEFAULT_TIMEOUT;
+		protected var pending:Array;
+		
+        /**
+         * Asynchronous handler class.
+         *
+         * This class give you the ability to create Asynchronous event handlers
+         * and pause test execution until those handlers are triggered.
+         *
+         * To take advantage of Asynchronous features, add a member variable
+         * to your test like:
+         * 
+         *  [Inject]
+         *  public var async:IAsync;
+         *
+         * This public property will be injected with an IAsync instance 
+         * before each test method. 
+         * 
+         * Within your test methods, you can add Async callbacks with:
+         *
+         *  [Test]
+         *  public function verifySomething():void {
+         *      async.add(handler);
+         *  }
+         * 
+         * In the previous example, test execution will be halted until the
+         * +handler+ method is called.
+         *
+         * It's worth noting that AsUnit does not store any state related
+         * to the playback of your test harness in global variables.
+         *
+         */
+		public function Async() {
+			pending = [];
+		}
+		
+		public function get hasPending():Boolean {
+			return pending.length > 0;
+		}
+
+        public function set timeout(timeout:int):void {
+            _timeout = timeout;
+        }
+
+        public function get timeout():int {
+            return _timeout;
+        }
+		
+        /**
+         * Returns a new async handler that should be used as the observer of some
+         * presumably asynchronous event.
+         *
+         * You can optionally pass a function closure that you would like to have
+         * executed when the provided handler is called. If this closure includes
+         * assertions, they will display in the test result.
+         *
+         * You can also override the default timeout (50ms) with a new value for
+         * this particular handler.
+         *
+         * This method may be called any number of times in a given [Test], [BeforeClass],
+         * or [Before] method.
+         *
+         * Test execution will be paused until all async handlers have returned
+         * or timed out.
+         *
+         * One way to use this method, is to simply send it to an event that you
+         * expect to have dispatched within a given time.
+         * 
+         *     instance.addEventListener(Event.COMPLETE, addAsync());
+         *
+         * In this example, you will receive a timeout error if the COMPLETE
+         * event is not dispatched within 50ms.
+         *
+         */
+		public function add(handler:Function=null, duration:int=-1):Function {
+			if (duration == -1) duration = timeout;
+            handler ||= function(...args):* {};
+			var command:TimeoutCommand = new TimeoutCommand(null, handler, duration);
+			addPending(command);
+			return command.getCallback();
+		}
+		
+		public function proceedOnEvent(target:IEventDispatcher, eventName:String, timeout:int=500, timeoutHandler:Function=null):void {
+            var asyncHandler:Function = add(null, timeout);
+			target.addEventListener(eventName, asyncHandler, false, 0, true);
+		}
+		
+		public function cancelPending():void {
+			for (var i:uint = pending.length; i--; ) {
+				var command:TimeoutCommand = TimeoutCommand(pending.pop());
+				command.cancel();
+				command.removeEventListener(TimeoutCommandEvent.CALLED,	onTestResult);
+				command.removeEventListener(TimeoutCommandEvent.TIMED_OUT,	onTestResult);
+			}
+		}
+		
+		// Partially opened for testing purposes.
+		public function getPending():Array {
+			// Clone to prevent changing by reference.
+			return pending.slice();
+		}
+		
+		protected function addPending(command:TimeoutCommand):void {
+			pending.push(command);
+			command.addEventListener(TimeoutCommandEvent.CALLED,	onTestResult);
+			command.addEventListener(TimeoutCommandEvent.TIMED_OUT,	onTestResult);
+			command.addEventListener(ErrorEvent.ERROR, 				onTestResult);
+            dispatchEvent(new TimeoutCommandEvent(TimeoutCommandEvent.ADDED, command));
+		}
+		
+		protected function onTestResult(e:Event):void {
+			var command:TimeoutCommand = TimeoutCommand(e.currentTarget);
+			command.removeEventListener(TimeoutCommandEvent.CALLED,		onTestResult);
+			command.removeEventListener(TimeoutCommandEvent.TIMED_OUT,	onTestResult);
+			removePending(command);
+			dispatchEvent(e);
+		}
+		
+		protected function removePending(command:TimeoutCommand):void {
+			pending.splice(pending.indexOf(command), 1);
+		}
+	}
+}
+

data/src/asunit/framework/CallbackBridge.as

@@ -0,0 +1,175 @@
+package asunit.framework {
+    
+    public class CallbackBridge implements IResult {
+	
+        private var listeners:Array;
+		
+		[Inject]
+	 	public var model:Result;
+
+        public function CallbackBridge() {
+			initialize();
+        }
+		
+		protected function initialize():void
+		{
+			listeners = [];
+			model = new Result();
+		}
+		
+        public function get length():int {
+            return listeners.length;
+        }
+
+		public function onRunStarted():void {
+			model.onRunStarted();
+            listeners.forEach(function(listener:IRunListener, index:int, items:Array):void {
+                listener.onRunStarted();
+            });
+        }
+
+		public function onRunCompleted(result:IResult):void {
+			model.onRunCompleted(result);
+            listeners.forEach(function(listener:IRunListener, index:int, items:Array):void {
+                listener.onRunCompleted(result);
+            });
+        }
+
+		public function onTestStarted(test:Object):void {
+			model.onTestStarted(test);
+            listeners.forEach(function(listener:IRunListener, index:int, items:Array):void {
+                listener.onTestStarted(test);
+            });
+        }
+
+		public function onTestCompleted(test:Object):void {
+			model.onTestCompleted(test);
+            listeners.forEach(function(listener:IRunListener, index:int, items:Array):void {
+                listener.onTestCompleted(test);
+            });
+        }
+
+		public function onTestFailure(failure:ITestFailure):void {
+			model.onTestFailure(failure);
+            listeners.forEach(function(listener:IRunListener, index:int, items:Array):void {
+                listener.onTestFailure(failure);
+            });
+        }
+
+		public function onTestSuccess(success:ITestSuccess):void {
+			model.onTestSuccess(success);
+            listeners.forEach(function(listener:IRunListener, index:int, items:Array):void {
+                listener.onTestSuccess(success);
+            });
+        }
+
+		public function onTestIgnored(method:Method):void {
+			model.onTestIgnored(method);
+            listeners.forEach(function(listener:IRunListener, index:int, items:Array):void {
+                listener.onTestIgnored(method);
+            });
+        }
+
+        public function onWarning(warning:ITestWarning):void {
+			model.onWarning(warning);
+            listeners.forEach(function(listener:IRunListener, index:int, items:Array):void {
+                listener.onWarning(warning);
+            });
+        }
+
+		//---------------------------------------
+		// IResult Implementation
+		//---------------------------------------
+
+		public function get errors():Array
+		{
+			return model.errors;
+		}
+
+		public function get errorCount():uint
+		{
+			return model.errorCount;
+		}
+
+		public function get failures():Array
+		{
+			return model.failures;
+		}
+
+		public function get failureCount():uint
+		{
+			return model.failureCount;
+		}
+
+		public function get successes():Array
+		{
+			return model.successes;
+		}
+
+		public function get successCount():uint
+		{
+			return model.successCount;
+		}
+
+		public function get warnings():Array
+		{
+			return model.warnings;
+		}
+
+		public function get ignoredTests():Array
+		{
+			return model.ignoredTests;
+		}
+
+		public function get ignoredTestCount():uint
+		{
+			return model.ignoredTestCount;
+		}
+
+		public function get runCount():uint
+		{
+			return model.runCount;
+		}
+
+		public function get failureEncountered():Boolean
+		{
+			return model.failureEncountered;
+		}
+
+		public function get wasSuccessful():Boolean
+		{
+			return model.wasSuccessful;
+		}
+
+		public function get runTime():Number
+		{
+			return model.runTime;
+		}
+
+		public function set runTime(value:Number):void
+		{
+			model.runTime = value;
+		}
+
+		public function addListener(listener:IRunListener):void
+		{
+			model.addListener(listener);
+			listeners.push(listener);
+		}
+
+		public function removeListener(listener:IRunListener):void
+		{
+			model.removeListener(listener);
+		}
+
+		public function addObserver(observer:TestObserver):void
+		{
+			model.addObserver(observer);
+		}
+
+		public function shouldRunTest(testClass:Class):Boolean
+		{
+			return model.shouldRunTest(testClass);
+		}
+    }
+}

data/src/asunit/framework/Command.as

@@ -0,0 +1,6 @@
+package asunit.framework {
+	
+	public interface Command {
+		function execute():*;
+	}	
+}

data/src/asunit/framework/ErrorEvent.as

@@ -0,0 +1,20 @@
+package asunit.framework {
+
+	import flash.events.Event;
+
+	public class ErrorEvent extends Event {
+		public static const ERROR:String = 'error';
+		protected var _error:Error;
+		
+		public function ErrorEvent(type:String, error:Error) {
+			super(type);
+			this._error = error;
+		}
+		
+		override public function clone():Event {
+			return new ErrorEvent(type, _error);
+		}
+		
+		public function get error():Error { return _error; }
+	}
+}

data/src/asunit/framework/IAsync.as

@@ -0,0 +1,21 @@
+package asunit.framework {
+
+    import flash.events.IEventDispatcher;
+
+    public interface IAsync extends IEventDispatcher {
+
+        function set timeout(timeout:int):void;
+        function get timeout():int;
+
+		function add(handler:Function=null, duration:int=-1):Function;
+
+		function cancelPending():void;
+        
+		function get hasPending():Boolean;
+        
+		function getPending():Array;
+
+		function proceedOnEvent(target:IEventDispatcher, eventName:String, timeout:int = 500, timeoutHandler:Function = null):void;
+    }
+}
+

data/src/asunit/framework/IResult.as

@@ -0,0 +1,36 @@
+package asunit.framework {
+
+	import asunit.framework.ITestFailure;
+
+	public interface IResult extends MessageBridge, IRunListener, ITestListener {
+		
+		function addListener(listener:IRunListener):void;
+		function removeListener(listener:IRunListener):void;
+
+        function addObserver(observer:TestObserver):void;
+        function shouldRunTest(testClass:Class):Boolean;
+		
+		function get errors():Array;
+		function get errorCount():uint;
+		
+		function get failures():Array;
+		function get failureCount():uint;
+		
+		function get successes():Array;
+		function get successCount():uint;
+
+        function get warnings():Array;
+		
+		function get ignoredTests():Array;
+		function get ignoredTestCount():uint;
+		
+		function get runCount():uint;
+		
+        function get failureEncountered():Boolean;
+		function get wasSuccessful():Boolean;
+		
+		function get runTime():Number;
+		function set runTime(value:Number):void;
+	}
+}
+

data/src/asunit/framework/IRunListener.as

@@ -0,0 +1,11 @@
+package asunit.framework {
+
+	import asunit.framework.ITestFailure;
+	import asunit.framework.IResult;
+	
+	public interface IRunListener extends ITestListener {
+		function onRunStarted():void;
+		function onRunCompleted(result:IResult):void;
+	}
+}
+

data/src/asunit/framework/IRunner.as

@@ -0,0 +1,15 @@
+package asunit.framework {
+
+    import flash.events.IEventDispatcher;
+    import flash.display.DisplayObjectContainer;
+
+	public interface IRunner extends IEventDispatcher {
+
+		function run(testOrSuite:Class, testMethodName:String=null, visualContext:DisplayObjectContainer=null):void;
+        function shouldRunTest(testClass:Class):Boolean;
+
+        function set factory(factory:IRunnerFactory):void;
+        function get factory():IRunnerFactory;
+	}
+}
+

data/src/asunit/framework/IRunnerFactory.as

@@ -0,0 +1,9 @@
+package asunit.framework {
+
+
+    public interface IRunnerFactory {
+		function get injector():InjectionDelegate;
+		function set injector(value:InjectionDelegate):void;
+        function runnerFor(testOrSuite:Class):IRunner;
+    }
+}

data/src/asunit/framework/ITestFailure.as

@@ -0,0 +1,32 @@
+package asunit.framework
+{
+
+	/**
+     *
+	 */
+	public interface ITestFailure {
+
+		function get failedFeature():String;
+
+		function get failedMethod():String;
+
+		/**
+		 * Gets the failed test case.
+		 */
+		function get failedTest():Object;
+
+		/**
+		 * Gets the thrown exception.
+		 */
+		function get thrownException():Error;
+
+		function get exceptionMessage():String;
+
+		function get isFailure():Boolean;
+
+		/**
+		 * Returns a short description of the failure.
+		 */
+		function toString():String;
+	}
+}

data/src/asunit/framework/ITestListener.as

@@ -0,0 +1,15 @@
+package asunit.framework {
+
+	import asunit.framework.ITestFailure;
+    import asunit.framework.TestObserver;
+	
+	public interface ITestListener extends TestObserver {
+		function onTestStarted(test:Object):void;
+		function onTestCompleted(test:Object):void;
+		function onTestFailure(failure:ITestFailure):void;
+		function onTestSuccess(success:ITestSuccess):void;
+		function onTestIgnored(method:Method):void;
+        function onWarning(warning:ITestWarning):void;
+	}
+}
+

data/src/asunit/framework/ITestResult.as

@@ -0,0 +1,21 @@
+package asunit.framework {
+
+	public interface ITestResult {
+		
+		function addFailure(failure:ITestFailure):void;
+		
+		function get errors():Array;
+		function get errorCount():uint;
+		
+		function get failures():Array;
+		function get failureCount():uint;
+		
+		function get runCount():uint;
+		function set runCount(value:uint):void;
+		
+		function get wasSuccessful():Boolean;
+		
+		function addListener(listener:ITestListener):void;
+		function removeListener(listener:ITestListener):void;
+	}
+}

data/src/asunit/framework/ITestSuccess.as

@@ -0,0 +1,22 @@
+package asunit.framework {
+
+	/**
+     *
+	 */
+	public interface ITestSuccess {
+
+		/**
+		 * Gets the test case.
+		 */
+		function get test():Object;
+
+		function get method():String;
+
+		function get feature():String;
+		
+		/**
+		 * Returns a short description of the failure.
+		 */
+		function toString():String;
+	}
+}

data/src/asunit/framework/ITestWarning.as

@@ -0,0 +1,14 @@
+package asunit.framework {
+
+    public interface ITestWarning {
+
+        function set message(message:String):void;
+        function get message():String;
+
+        function set method(method:Method):void;
+        function get method():Method;
+
+        function toString():String;
+    }
+}
+

data/src/asunit/framework/InjectionDelegate.as

@@ -0,0 +1,96 @@
+package asunit.framework {
+	
+	import p2.reflect.ReflectionMetaData;
+	import p2.reflect.Reflection;
+		
+	import flash.utils.Dictionary;
+	import asunit.errors.UsageError;
+	import p2.reflect.ReflectionVariable;
+	import p2.reflect.ReflectionMember;
+	import flash.utils.getDefinitionByName;
+
+	public class InjectionDelegate {
+		//---------------------------------------
+		// CLASS CONSTANTS
+		//---------------------------------------
+		
+		public static const THROW_ERROR_ON_MISSING_INJECTION_POINT:Boolean = true;
+		public static const INJECT_ANNOTATION:String = "Inject";
+		
+		private var entities:Dictionary;
+		
+		public function InjectionDelegate()
+		{
+			entities = new Dictionary();
+		}
+		
+		/**
+		 * @param addict * an entity with at least one [Inject] annotation
+		*/
+		public function updateInjectionPoints(addict:*, throwErrorOnMissingInjection:Boolean=false):void {
+			var reflection:Reflection = Reflection.create(addict);
+			var members:Array = reflection.getMembersByMetaData(INJECT_ANNOTATION);
+			var addictName:String = reflection.name
+			if (throwErrorOnMissingInjection)
+			{
+				validateMembers(members, addictName);
+			}			
+			var reflectionVariable:ReflectionVariable;
+			var injectionPointFound:Boolean;
+			members.forEach(function(member:ReflectionMember, index:int, items:Array):void {
+				reflectionVariable = member as ReflectionVariable;
+				if (reflectionVariable)
+				{
+					updateInjectionPoint(addict, reflectionVariable);
+					injectionPointFound = true;
+				}
+			});
+			
+			if (!injectionPointFound && throwErrorOnMissingInjection)
+			{
+				throw new UsageError("InjectionDelegate expected at least one [Inject] annotation on a variable or accessor on" + addictName);
+			}
+			
+		}
+		
+		/**
+		 * For each inject annotation we call this method
+		 * @private
+		 * @return 
+		*/
+		private function updateInjectionPoint(addict:*, member:ReflectionVariable):void {
+			//FIXME: This actually could be a getter. If someone has their head up their booty.
+			var instance:* = getInstanceFromTypeName(member.type);
+			addict[member.name] = instance;
+		}
+		
+		private function getInstanceFromTypeName(name:String):* {
+			var clazz:Class = getDefinitionByName(name) as Class;
+			 return getOrCacheInstanceFromClass(clazz);
+		}
+		
+		private function getOrCacheInstanceFromClass(clazz:Class):* {
+			if (!entities[clazz])
+			{
+				//FIXME: This will choke if given a class with constructor arguments!
+				entities[clazz] = new clazz();
+				updateInjectionPoints(entities[clazz]);
+			}
+
+			return entities[clazz];
+		}
+		
+		/**
+		 * @private
+		 */
+		private function validateMembers(members:Array, name:String):void
+		{
+			if (!members || members.length == 0)
+			{
+				throw new UsageError("InjectionDelegate expects at least one [Inject] annotation on " + name);
+			}
+			
+		}
+		
+	}
+}

data/src/asunit/framework/LegacyTestIterator.as

@@ -0,0 +1,40 @@
+package asunit.framework {
+
+    import p2.reflect.Reflection;
+    import p2.reflect.ReflectionMethod;
+	
+	public class LegacyTestIterator extends TestIterator {
+		
+        public function LegacyTestIterator(test:Object, testMethodName:String = "") {
+            super(test, testMethodName);
+		} 
+
+        override protected function getTestMethods(test:Object):Array {
+            var annotatedMethods:Array = super.getTestMethods(test);
+            var namedMethods:Array = getTestMethodsByName(test);
+            return annotatedMethods.concat(namedMethods);
+        }
+
+        protected function getTestMethodsByName(instance:Object):Array {
+            var methods:Array = [];
+            var reflection:Reflection = Reflection.create(instance);
+            reflection.methods.forEach(function(methodReflection:ReflectionMethod, index:int, list:Array):void {
+                if(methodNameBeginsWithTest(methodReflection) && methodDoesNotHaveTestAnnotation(methodReflection)) {
+                    methods.push( new Method(instance, methodReflection) );
+                }
+            });
+
+            methods.sortOn('name');
+            return methods;
+        }
+
+        protected function methodNameBeginsWithTest(method:ReflectionMethod):Boolean {
+            return (method.name.match(/^test/) != null);
+        }
+
+        protected function methodDoesNotHaveTestAnnotation(method:ReflectionMethod):Boolean {
+            return (method.getMetaDataByName('Test') == null);
+        }
+	}
+}
+