asunit4 4.2.1.pre

data/src/asunit/framework/MessageBridge.as

@@ -0,0 +1,24 @@
+package asunit.framework {
+
+    /**
+     * MessageBridge is a marker interface that is used
+     * by AsUnit core in order to support custom messaging
+     * schemes between TestObservers and IRunners.
+     *
+     * The idea is that you [Inject] one or more entities
+     * into your concrete IRunner and related TestObservers.
+     *
+     * The contract is between the concrete MessageBridge,
+     * and the other actors that [Inject] it into.
+     * 
+     * This implementation gives AsUnit the ability to support
+     * a variety of messaging protocols including native
+     * Flash EventDispatchers, callbacks, and even progressive
+     * systems like AS3Signals. The decision as to which
+     * messaging system to use is made by the person creating
+     * the concrete Runner and Observer.
+     */
+    public interface MessageBridge {
+    }
+}
+

data/src/asunit/framework/Method.as

@@ -0,0 +1,80 @@
+package asunit.framework {
+
+    import p2.reflect.Reflection;
+    import p2.reflect.ReflectionMethod;
+    import p2.reflect.ReflectionMetaData;
+	
+	public class Method {
+
+        private var _scopeName:String;
+
+		public var expects:String;
+		public var ignore:Boolean;
+        public var ignoreDescription:String;
+		public var metadata:ReflectionMetaData;
+		public var name:String;
+		public var order:int      = 0;
+		public var scope:Object;
+		public var timeout:int = -1;
+		public var value:Function;
+		
+		public function Method(scope:Object, reflection:ReflectionMethod) {
+            this.scope = scope;
+            this.name = reflection.name;
+            this.value = scope[reflection.name];
+
+            metadata = reflection.getMetaDataByName('Test');
+
+            if(metadata != null) {
+                var ignoreReflection:ReflectionMetaData = reflection.getMetaDataByName('Ignore');
+                if(ignoreReflection) {
+                    ignore = true;
+                    ignoreDescription = ignoreReflection.getValueFor('description');
+                }
+
+                handleTimeoutMetaData();
+                applyMetaData('expects');
+                applyMetaData('order');
+            }
+        }
+
+        public function get scopeName():String {
+            return _scopeName ||= Reflection.create(scope).name
+        }
+
+        private function handleTimeoutMetaData():void {
+            var value:* = metadata.getValueFor('timeout');
+            if(value != null) {
+                var message:String = "It seems you're using [Test(timeout=n)] for " + name + ", but this has been deprecated.\n";
+                message += "If you'd like to set a different timeout value, please send it to your Async instance methods like: async.add(null, timeoutInMilliseconds)";
+                trace("[DEPRECATION WARNING] " + message);
+            }
+        }
+
+        // The null response for timeout was updating the
+        // int field to zero when it needs to be -1...
+        private function applyMetaData(name:String):void {
+            var value:* = metadata.getValueFor(name);
+            if(value != null) {
+                this[name] = value;
+            }
+        }
+
+        public function execute():void {
+            value.call(scope);
+        }
+
+        public function get isTest():Boolean {
+            return (metadata != null || isLegacyTest);
+        }
+
+        public function get isLegacyTest():Boolean {
+            return (metadata == null && name.match(/^test/));
+        }
+
+		public function toString():String {
+			return name;
+		}
+	}
+}
+

data/src/asunit/framework/Result.as

@@ -0,0 +1,181 @@
+package asunit.framework {
+
+    import asunit.errors.UsageError;
+	import asunit.framework.ITestFailure;
+
+	import flash.events.EventDispatcher;
+    import flash.utils.Dictionary;
+
+	/**
+     * A <code>Result</code> collects the results of executing
+     * a test case. It is an instance of the Collecting Parameter pattern.
+     * The test framework distinguishes between <i>failures</i> and <i>errors</i>.
+     * A failure is anticipated and checked for with assertions. Errors are
+     * unanticipated problems like an <code>ArrayIndexOutOfBoundsException</code>.
+     *
+     * @see Test
+     */
+    public class Result extends EventDispatcher implements IResult {
+
+		protected var _runCount:uint = 0;
+		protected var _runTime:Number;
+        protected var _errors:Array;
+        protected var _failures:Array;
+        protected var _ignoredTests:Array;
+        protected var _successes:Array;
+        protected var _warnings:Array;
+
+		protected var listeners:Array;
+        protected var runComplete:Boolean;
+        protected var knownTests:Dictionary;
+
+        public function Result() {
+			_errors       = [];
+			_failures     = [];
+			_ignoredTests = [];
+			_successes    = [];
+            _warnings     = [];
+			listeners     = [];
+            knownTests    = new Dictionary();
+        }
+		
+        public function get errors():Array { return _errors; }
+		
+        /**
+         * Gets the number of detected errors.
+         */
+        public function get errorCount():uint { return _errors.length; }
+		
+        /**
+         *
+         */
+        public function get failures():Array { return _failures; }
+		
+        /**
+         * Gets the number of detected failures.
+         */
+        public function get failureCount():uint { return _failures.length; }
+		
+        public function get successes():Array { return _successes; }
+		
+        public function get successCount():uint { return _successes.length; }
+
+        public function get warnings():Array { return _warnings; }
+
+        public function get ignoredTests():Array { return _ignoredTests; }
+		
+        public function get ignoredTestCount():uint { return _ignoredTests.length; }
+		
+		public function get runCount():uint {
+			return errorCount + failureCount + successCount;
+		}
+		
+		public function get runTime():Number { return _runTime; }
+		public function set runTime(value:Number):void { _runTime = value; }
+
+        public function shouldRunTest(testClass:Class):Boolean {
+            if(!knownTests[testClass]) {
+                knownTests[testClass] = testClass;
+                return true;
+            }
+            return false;
+        }
+		
+        public function addObserver(observer:TestObserver):void {
+            if(!(observer is IRunListener)) {
+                throw new UsageError("Result.addObserver called with an instance that wasn't an IRunListener. This should work soon, but doesn't yet...");
+            }
+            addListener(IRunListener(observer));
+        }
+		
+		public function addListener(listener:IRunListener):void {
+			if (listeners.indexOf(listener) >= 0) return;
+			listeners.push(listener);
+		}
+		
+		public function removeListener(listener:IRunListener):void {
+			listeners.splice(listeners.indexOf(listener), 1);
+		}
+		
+		public function onRunStarted():void {
+			for each (var listener:IRunListener in listeners) {
+				listener.onRunStarted();
+			}
+		}
+		
+		public function onRunCompleted(result:IResult):void {
+            runComplete = true;
+			for each (var listener:IRunListener in listeners) {
+				listener.onRunCompleted(this);
+			}
+		}
+	
+		public function onTestStarted(test:Object):void {
+			for each (var listener:IRunListener in listeners) {
+				listener.onTestStarted(test);
+			}
+		}
+		
+		public function onTestCompleted(test:Object):void {
+			for each (var listener:IRunListener in listeners) {
+				listener.onTestCompleted(test);
+			}
+		}
+		
+        /**
+         * Adds a failure to the list of failures. The passed in exception
+         * caused the failure.
+         */
+        public function onTestFailure(failure:ITestFailure):void {
+			if (failure.isFailure)
+				_failures.push(failure);
+			else
+				_errors.push(failure);
+				
+			for each (var listener:IRunListener in listeners) {
+				listener.onTestFailure(failure);
+			}
+        }
+		
+        public function onTestSuccess(success:ITestSuccess):void {
+			_successes.push(success);
+			
+			for each (var listener:IRunListener in listeners) {
+				listener.onTestSuccess(success);
+			}
+		}
+		
+        public function onTestIgnored(method:Method):void {
+			_ignoredTests.push(method);
+			
+			for each (var listener:IRunListener in listeners) {
+				listener.onTestIgnored(method);
+			}
+		}
+
+        public function onWarning(warning:ITestWarning):void {
+            _warnings.push(warning);
+
+            for each (var listener:IRunListener in listeners) {
+                listener.onWarning(warning);
+            }
+        }
+
+        /**
+         * Returns whether or not we have yet encountered a failure or error.
+         * Will be accurate when checked at any time during test run.
+         */
+        public function get failureEncountered():Boolean {
+            return (failureCount > 0 || errorCount > 0);
+        }
+
+        /**
+         * Returns whether or not the entire test was successful.
+         * Will only return true after +onRunCompleted+ called.
+         */
+        public function get wasSuccessful():Boolean {
+            return (runComplete && !failureEncountered);
+        }
+		
+    }
+}

data/src/asunit/framework/RunnerFactory.as

@@ -0,0 +1,179 @@
+package asunit.framework {
+
+    import asunit.errors.UsageError;
+    import asunit.runners.LegacyRunner;
+    import asunit.runners.TestRunner;
+    import asunit.runners.SuiteRunner;
+
+    import flash.utils.getDefinitionByName;
+
+    import p2.reflect.Reflection;
+    import p2.reflect.ReflectionMetaData;
+    import asunit.framework.InjectionDelegate;
+
+	public class RunnerFactory implements IRunnerFactory {
+
+        public static var DEFAULT_SUITE_RUNNER:Class = SuiteRunner;
+		public static var DEFAULT_TEST_RUNNER:Class = TestRunner;
+
+        /**
+         * The DefaultTestRunner will be updated whenever
+         * a TestSuite is encountered that has a [RunWith]
+         * declaration.
+         *
+         * All subsequent create calls for a Test that
+         * don't have a RunWith will use the IRunner that
+         * was defined on the Suite.
+         *
+         */
+        public var DefaultTestRunner:Class;
+
+        /**
+         * The DefaultSuiteRunner is what
+         * we use for all TestSuites
+         */
+        public var DefaultSuiteRunner:Class;
+		
+        public function RunnerFactory() {
+            DefaultSuiteRunner = DEFAULT_SUITE_RUNNER;
+            DefaultTestRunner  = DEFAULT_TEST_RUNNER;
+            injector = new InjectionDelegate();
+        }
+		
+		private var _injector:InjectionDelegate;
+		
+		public function get injector():InjectionDelegate
+		{
+			return _injector;
+		}
+		
+		public function set injector(value:InjectionDelegate):void
+		{
+			_injector = value;
+		}
+		
+        /**
+         * runnerFor is the primary inerface to the RunnerFactory
+         */
+        public function runnerFor(testOrSuite:Class):IRunner {
+            //trace(">> runnerFor: " + testOrSuite + " with current default of: " + DefaultTestRunner);
+            validate(testOrSuite);
+            return getRunnerForTestOrSuite(testOrSuite);
+        }
+
+        protected function validate(testOrSuite:Class):void {
+            if(testOrSuite == null) {
+                throw new UsageError("RunnerFactory.runnerFor must be provided with a known test or suite class");
+            }
+        }
+
+        protected function getRunnerForTestOrSuite(testOrSuite:Class):IRunner {
+            var reflection:Reflection = Reflection.create(testOrSuite);
+            if(RunnerFactory.isSuite(reflection)) {
+                return getRunnerForSuite(reflection);
+            }
+            else if(RunnerFactory.isLegacyTest(reflection)) {
+                return getLegacyRunnerForTest(reflection);
+            }
+            else if(RunnerFactory.isTest(reflection)) {
+                return getRunnerForTest(reflection);
+            }
+
+            throw new UsageError("RunnerFactory was asked for a Runner, but was not able to identify: " + reflection.name + " as a LegacyTest, Test or Suite.");
+            return null;
+        }
+
+        protected function getRunnerForSuite(reflection:Reflection):IRunner {
+            // First update the DefaultTestRunner with the provided RunWith
+            // if necessary...
+            var Constructor:Class = getRunWithConstructor(reflection);
+            if(Constructor) {
+                DefaultTestRunner = Constructor;
+            }
+            // Always return the default Suite Runner:
+            var runner:IRunner = new DefaultSuiteRunner();
+            configureRunner(runner);
+            return runner;
+        }
+
+        protected function getLegacyRunnerForTest(reflection:Reflection):IRunner {
+            var runner:IRunner = new LegacyRunner();
+            configureRunner(runner);
+            return runner;
+        }
+
+        protected function getRunnerForTest(reflection:Reflection):IRunner {
+            // Use the provided RunWith class, or the DefaultTestRunner (this may
+            // have been overridden by a parent Suite
+            var Constructor:Class = getRunWithConstructor(reflection) || DefaultTestRunner;
+			//FIXME: This will choke if given a class with constructor arguments!
+            var runner:IRunner = new Constructor();
+            configureRunner(runner);
+            return runner;
+        }
+
+        protected function getRunWithConstructor(reflection:Reflection):Class {
+            var runWith:ReflectionMetaData = getRunWithDeclaration(reflection);
+
+            if(runWith) {
+                if(runWith.args.length == 0) {
+                    throw new UsageError("Encountered [RunWith] declaration that's missing the class argument. Try [RunWith(my.class.Name)] instead.");
+                }
+                try {
+                    var className:String = runWith.args[0];
+                    return getDefinitionByName(className) as Class;
+                }
+                catch(e:ReferenceError) {
+                    var message:String = "Encountered [RunWith] declaration but cannot instantiate the provided runner. " + className + ". ";
+                    message += "Is there an actual reference to this class somewhere in your project?";
+                    throw new UsageError(message);
+                }
+            }
+
+            return null;
+        }
+		
+		protected function getRunWithDeclaration(reflection:Reflection):ReflectionMetaData {
+		    var result:ReflectionMetaData = reflection.getMetaDataByName('RunWith');
+		    if(result) {
+		        return result;
+	        }
+		    
+		    var baseClass:*;
+		    var baseClassReflection:Reflection;
+		    var len:int = reflection.extendedClasses.length;
+		    for(var i:int; i < len; i++) {
+		        baseClass = getDefinitionByName(reflection.extendedClasses[i]);
+		        baseClassReflection = Reflection.create(baseClass);
+		        result = baseClassReflection.getMetaDataByName('RunWith');
+		        if(result) {
+		            return result;
+	            }
+	        }
+	        return null;
+	    }
+	
+		/**
+		 * @private
+		 */
+		protected function configureRunner(runner:IRunner):void
+		{
+			runner.factory = this;
+			injector.updateInjectionPoints(runner, InjectionDelegate.THROW_ERROR_ON_MISSING_INJECTION_POINT);
+		}
+
+		public static function isSuite(reflection:Reflection):Boolean {
+            return (reflection.getMetaDataByName('Suite') != null);
+		}
+
+        public static function isLegacyTest(reflection:Reflection):Boolean {
+            return reflection.isA('asunit.framework.TestCase');
+        }
+
+        public static function isTest(reflection:Reflection):Boolean {
+            var testMethods:Array = reflection.getMethodsByMetaData('Test');
+            var runWith:ReflectionMetaData = reflection.getMetaDataByName('RunWith');
+            return (runWith != null || testMethods.length > 0);
+        }
+	}
+}

data/src/asunit/framework/SuiteIterator.as

@@ -0,0 +1,71 @@
+package asunit.framework {
+
+    import asunit.util.Iterator;
+
+	import flash.utils.getDefinitionByName;
+
+    import p2.reflect.Reflection;
+    import p2.reflect.ReflectionVariable;
+    import p2.reflect.ReflectionMetaData;
+
+	public class SuiteIterator implements Iterator {
+		
+        protected var index:int;
+        protected var list:Array;
+				
+		public function SuiteIterator(Suite:Class, bridge:CallbackBridge=null) {
+			list = getTestClasses(Suite, bridge);
+		}
+		
+        private function getTestClasses(Suite:Class, bridge:CallbackBridge=null):Array {
+			if(bridge == null) bridge = new CallbackBridge();
+			
+            var reflection:Reflection = Reflection.create(Suite);
+
+            if(!isSuite(reflection) && isTest(reflection)) {
+                return [Suite];
+            }
+
+            var variable:ReflectionVariable;
+            var TestConstructor:Class;
+            var response:Array = [];
+            for each(variable in reflection.variables) {
+                TestConstructor = Class(getDefinitionByName(variable.type));
+                if(isSuite(Reflection.create(TestConstructor))) {
+                    response = response.concat( getTestClasses(TestConstructor, bridge) );
+                }
+                else if(bridge.shouldRunTest(TestConstructor)) {
+                    response.push(TestConstructor);
+                }
+            }
+            response.sort();
+            return response;
+        }
+
+        public function get length():uint {
+            return list.length;
+        }
+
+		private function isSuite(reflection:Reflection):Boolean {
+            return RunnerFactory.isSuite(reflection);
+		}
+
+        private function isTest(reflection:Reflection):Boolean {
+            return RunnerFactory.isTest(reflection);
+        }
+        
+        public function hasNext():Boolean {
+            return list[index] != null;
+        }
+
+        // Returns a Class reference:
+        public function next():* {
+            return list[index++];
+        }
+
+        public function reset():void {
+            index = 0;
+        }
+	}
+}
+

data/src/asunit/framework/TestCase.as

@@ -0,0 +1,106 @@
+package asunit.framework {
+
+    import asunit.framework.Assert;
+    import asunit.framework.IAsync;
+
+    import flash.display.DisplayObject;
+    import flash.display.DisplayObjectContainer;
+    import flash.display.Sprite;
+    
+    [RunWith("asunit.runners.LegacyRunner")]
+    public class TestCase {
+        
+        public function TestCase(testMethod:String=null) {
+        }
+
+        [Inject]
+        public var asyncDelegate:IAsync;
+
+        [Inject]
+        public var context:Sprite;
+
+        [Before]
+        public function callSetUp():void {
+            setUp();
+        }
+
+        protected function setUp():void {
+        }
+
+        [After]
+        public function callTearDown():void {
+            tearDown();
+        }
+
+        protected function tearDown():void {
+        }
+
+        protected function addAsync(handler:Function, timeout:int=-1):Function {
+            return asyncDelegate.add(handler, timeout);
+        }
+
+        protected function getContext():DisplayObjectContainer {
+            return context;
+        }
+
+        protected function addChild(child:DisplayObject):DisplayObject {
+            context.addChild(child);
+            return child;
+        }
+
+        protected function removeChild(child:DisplayObject):DisplayObject {
+            if(child && child.parent === context) {
+                context.removeChild(child);
+            }
+            return child;
+        } 
+
+        protected function assertTrue(...args:Array):void {
+            Assert.assertTrue.apply(null, args);
+        }
+
+        public function assertFalse(...args:Array):void {
+            Assert.assertFalse.apply(null, args);
+        }
+
+        protected function fail(message:String):void {
+            Assert.fail(message);
+        }
+
+        protected function assertThrows(errorType:Class, block:Function):void {
+            Assert.assertThrows(errorType, block);
+        }
+
+        protected function assertEquals(...args:Array):void {
+            Assert.assertEquals.apply(null, args);
+        }
+
+        protected function assertNotNull(...args:Array):void {
+            Assert.assertNotNull.apply(null, args);
+        }
+
+        protected function assertNull(...args:Array):void {
+            Assert.assertNull.apply(null, args);
+        }
+
+        protected function assertSame(...args:Array):void {
+            Assert.assertSame.apply(null, args);
+        }
+
+        protected function assertNotSame(...args:Array):void {
+            Assert.assertNotSame.apply(null, args);
+        }
+
+        protected function assertEqualsFloat(...args:Array):void {
+            Assert.assertEquals.apply(null, args);
+        }
+
+        protected function assertEqualsArrays(...args:Array):void {
+            Assert.assertEqualsArrays.apply(null, args);
+        }
+        
+        protected function assertEqualsArraysIgnoringOrder(...args:Array):void {
+            Assert.assertEqualsArraysIgnoringOrder.apply(null, args);
+        }
+    }
+}

data/src/asunit/framework/TestFailure.as

@@ -0,0 +1,65 @@
+package asunit.framework {
+    import asunit.errors.AssertionFailedError;
+	import flash.utils.getQualifiedClassName;
+	import asunit.framework.ITestFailure;
+
+    /**
+     * A <code>TestFailure</code> collects a failed test together with
+     * the caught exception.
+     * @see Result
+     */
+    public class TestFailure implements ITestFailure {
+        protected var _failedTest:Object;
+        protected var _failedMethod:String;
+        protected var _thrownException:Error;
+
+        /**
+         * Constructs a TestFailure with the given test and exception.
+         */
+        public function TestFailure(failedTest:Object, methodName:String, thrownException:Error) {
+            _failedTest = failedTest;
+            _failedMethod = methodName;
+            _thrownException = thrownException;
+        }
+
+        public function get failedFeature():String {
+            return getQualifiedClassName(_failedTest) + '.' + _failedMethod;
+        }
+
+        public function get failedMethod():String {
+            return _failedMethod;
+        }
+		
+		public function set failedMethod(value:String):void {
+			_failedMethod = value;
+		}
+
+        /**
+         * Gets the failed test case.
+         */
+        public function get failedTest():Object {
+            return _failedTest;
+        }
+        /**
+         * Gets the thrown exception.
+         */
+        public function get thrownException():Error {
+            return _thrownException;
+        }
+        /**
+         * Returns a short description of the failure.
+         */
+        public function toString():String {
+            return '[TestFailure ' + failedMethod + ']';
+        }
+
+        public function get exceptionMessage():String {
+            return thrownException.message;
+        }
+
+        public function get isFailure():Boolean {
+            return thrownException is AssertionFailedError;
+        }
+		
+    }
+}