asunit4 4.2.1.pre

data/src/asunit/framework/TestIterator.as

@@ -0,0 +1,282 @@
+package asunit.framework {
+
+    import asunit.errors.UsageError;
+    import asunit.util.ArrayIterator;
+    import asunit.util.Iterator;
+
+    import p2.reflect.Reflection;
+    import p2.reflect.ReflectionMethod;
+
+    public class TestIterator implements Iterator {
+        
+        private var _readyToTearDown:Boolean;
+
+        private var afterClassMethods:Iterator;
+        private var afterMethods:Iterator;
+        private var beforeClassMethods:Iterator;
+        private var beforeMethods:Iterator;
+        private var beforeMethodRanLastCycle:Boolean;
+        private var ignoredMethods:Iterator;
+        private var testMethodNameReceived:Boolean;
+        private var setUpHasRunThisCycle:Boolean;
+        private var testMethodHasRunThisCycle:Boolean;
+        private var testMethods:Iterator;
+        
+        public function TestIterator(test:Object, testMethodName:String = "") {
+            if(test is Class) throw new ArgumentError("test argument cannot be a Class");
+            
+            var testMethodsArray:Array = getTestMethods(test);
+            if(!testMethodsArray.length) {
+                setUpNullIterators();
+                return;
+            }
+            
+            if(testMethodName) {
+                testMethodNameReceived = true;
+                testMethodsArray = testMethodsArray.filter(
+                    function(item:Object, index:int, array:Array):Boolean {
+                        return (item.name == testMethodName);
+                    }
+                );
+                if(testMethodsArray.length == 0) {
+                    var message:String = "Provided test method name (" + testMethodName + ") not found on provided class (" + Reflection.create(test).name + ")";
+                    throw new UsageError(message);
+                }
+            }
+            
+            testMethods = new ArrayIterator(testMethodsArray);
+            setUpIterators(test);
+        }
+
+        public function get readyToSetUp():Boolean {
+            return !setUpHasRunThisCycle || (!afterMethods.hasNext() && testMethodHasRunThisCycle && testMethods.hasNext());
+        }
+
+        public function get readyToTearDown():Boolean {
+            return _readyToTearDown;
+        }
+
+        protected function setUpNullIterators():void {
+            // Set up null iterators for access to length
+            // and other properties...
+            testMethods        = new ArrayIterator();
+            beforeClassMethods = new ArrayIterator();
+            beforeMethods      = new ArrayIterator();
+            afterMethods       = new ArrayIterator();
+            afterClassMethods  = new ArrayIterator();
+            ignoredMethods     = new ArrayIterator();
+        }
+
+        protected function setUpIterators(test:Object):void {
+            if(!testMethodNameReceived) {
+                afterClassMethods   = new ArrayIterator(getAfterClassMethods(test));
+                afterMethods        = new ArrayIterator(getAfterMethods(test));
+            }
+            else {
+                afterClassMethods = new ArrayIterator([]);
+                afterMethods      = new ArrayIterator([]);
+            }
+            beforeClassMethods  = new ArrayIterator(getBeforeClassMethods(test));
+            beforeMethods       = new ArrayIterator(getBeforeMethods(test));
+            ignoredMethods      = new ArrayIterator(getIgnoredMethods(test));
+        }
+
+        public function get beforeClassIterator():Iterator {
+            return beforeClassMethods;
+        }
+
+        public function get beforeIterator():Iterator {
+            return beforeMethods;
+        }
+
+        public function get testMethodsIterator():Iterator {
+            return testMethods;
+        }
+
+        public function get afterIterator():Iterator {
+            return afterMethods;
+        }
+
+        public function get afterClassIterator():Iterator {
+            return afterClassMethods;
+        }
+
+        public function get ignoredIterator():Iterator {
+            return ignoredMethods;
+        }
+
+        /**
+         *
+         * @param   test    An instance of a class with methods that have [Before] metadata.
+         * @return  An array of Method instances.
+         */
+        protected function getBeforeClassMethods(test:Object):Array {
+            return getMethodsWithMetadata(test["constructor"], "BeforeClass", true);
+        }
+        
+        /**
+         *
+         * @param   test    An instance of a class with methods that have [Before] metadata.
+         * @return  An array of Method instances.
+         */
+        protected function getBeforeMethods(test:Object):Array {
+            return getMethodsWithMetadata(test, "Before");
+        }
+        
+        /**
+         *
+         * @param   test    An instance of a class with methods that have [Test] metadata,
+         *                  or have a methods that begin with 'test'.
+         * @return  An array of Method instances.
+         */
+        protected function getTestMethods(test:Object):Array {
+            return getMethodsWithMetadata(test, "Test");
+        }
+        
+        /**
+         *
+         * @param   test    An instance of a class with methods that have [After] metadata.
+         * @return  An array of Method instances.
+         */
+        protected function getAfterMethods(test:Object):Array {
+            return getMethodsWithMetadata(test, "After");
+        }
+        
+        /**
+         *
+         * @param   test    An instance of a class with methods that have [After] metadata.
+         * @return  An array of Method instances.
+         */
+        protected function getIgnoredMethods(test:Object):Array {
+            return getMethodsWithMetadata(test, "Ignore");
+        }
+        
+        /**
+         *
+         * @param   test    An instance of a class with methods that have [Before] metadata.
+         * @return  An array of Method instances.
+         */
+        protected function getAfterClassMethods(test:Object):Array {
+            return getMethodsWithMetadata(test["constructor"], "AfterClass", true);
+        }
+
+        protected function getMethodsWithMetadata(instance:Object, metaDataName:String, useStatic:Boolean = false):Array {
+            var reflection:Reflection = Reflection.create(instance);
+            var methodReflections:Array = reflection.getMembersByMetaData(metaDataName);
+
+            var methods:Array = [];
+            var methodReflection:ReflectionMethod;
+            for each(methodReflection in methodReflections) {
+                methods.push( new Method(instance, methodReflection) );
+            }
+            methods.sortOn('name');
+            methods.sortOn('order');
+            return methods;
+        }
+        
+        protected function countTestMethods(test:Object):uint {
+            return getTestMethods(test).length;
+        }
+        
+        public function hasNext():Boolean {
+            if(!testMethods) return false;
+            return testMethods.hasNext()
+                || beforeMethods.hasNext()
+                || afterMethods.hasNext()
+                || beforeClassMethods.hasNext()
+                || afterClassMethods.hasNext();
+       }
+
+        public function get length():uint {
+            var testMethodCount:int = testMethods.length - ignoredMethods.length;
+            var classHelperCount:int = beforeClassMethods.length + afterClassMethods.length;
+            var methodHelperCount:int = beforeMethods.length + afterMethods.length;
+                                       
+            if(methodHelperCount > 0) {
+                return (testMethodCount * methodHelperCount) + testMethodCount + classHelperCount;
+            }
+            else {
+                return testMethodCount + classHelperCount;
+            }
+        }
+
+        public function next():* {
+            if(!testMethods) return null;
+
+            var value:*;
+
+            _readyToTearDown         = false;
+            beforeMethodRanLastCycle = false;
+            setUpHasRunThisCycle     = true;
+
+            if(beforeClassMethods.hasNext()) {
+                value = beforeClassMethods.next();
+                //updateReadyToSetUp();
+                return value;
+            }
+
+
+            if(beforeMethods.hasNext()) {
+                value = beforeMethods.next();
+                beforeMethodRanLastCycle = true;
+                //updateReadyToSetUp();
+                return value;
+            }
+            
+            //updateReadyToSetUp();
+
+            if(!testMethodHasRunThisCycle && testMethods.hasNext()) {
+                testMethodHasRunThisCycle = true;
+                value = testMethods.next();
+                updateReadyToTearDown();
+                return value;
+            }
+            
+            if(afterMethods.hasNext()) {
+                value = afterMethods.next();
+                //updateReadyToSetUp();
+                updateReadyToTearDown();
+                return value;
+            }
+
+            if(!testMethods.hasNext()) {
+                if(afterClassMethods.hasNext()) {
+                    return afterClassMethods.next();
+                }
+                return null;
+            }
+            
+            beforeMethods.reset();
+            afterMethods.reset();
+            testMethodHasRunThisCycle = false;
+            setUpHasRunThisCycle = false;
+            return next();
+        }
+
+        protected function updateReadyToTearDown():void {
+            // Used by TestRunner to remove visual
+            // entities:
+            if(!beforeClassMethods.hasNext() &&
+               !beforeMethods.hasNext() &&
+               testMethodHasRunThisCycle &&
+               !afterMethods.hasNext()) {
+                _readyToTearDown = true;
+            }
+        }
+
+        public function reset():void {
+            if(!testMethods) return;
+            
+            beforeClassMethods.reset();
+            beforeMethods.reset();
+            testMethods.reset();
+            afterMethods.reset();
+            afterClassMethods.reset();
+
+            _readyToTearDown          = false;
+            setUpHasRunThisCycle      = false;
+            testMethodHasRunThisCycle = false;
+        }
+    }
+}
+

data/src/asunit/framework/TestObserver.as

@@ -0,0 +1,12 @@
+package asunit.framework {
+
+    /**
+     * TestObserver is a marker interface that usually
+     * indicates that a given class will have at least
+     * one [Inject] annotation above a public instance
+     * variable that implements MessageBridge.
+     */
+    public interface TestObserver {
+    }
+}
+

data/src/asunit/framework/TestSuccess.as

@@ -0,0 +1,38 @@
+package asunit.framework {
+	import flash.utils.getQualifiedClassName;
+
+    /**
+     * @see Result
+     */
+    public class TestSuccess implements ITestSuccess {
+        protected var _test:Object;
+        protected var _method:String;
+
+        /**
+         * Constructs a TestFailure with the given test and exception.
+         */
+        public function TestSuccess(test:Object, method:String) {
+            _test = test;
+            _method = method;
+        }
+
+        public function get feature():String {
+            return getQualifiedClassName(_test) + '.' + _method;
+        }
+
+        public function get test():Object {
+            return _test;
+        }
+		
+        public function get method():String {
+            return _method;
+        }
+
+        /**
+         * Returns a short description of the success.
+         */
+        public function toString():String {
+            return "[TestSuccess " + method + "]";
+        }
+    }
+}

data/src/asunit/framework/TestWarning.as

@@ -0,0 +1,40 @@
+package asunit.framework {
+
+    public class TestWarning implements ITestWarning {
+
+        private var _message:String;
+        private var _method:Method;
+
+        public function TestWarning(message:String, method:Method=null) {
+            _message = message;
+            _method = method;
+        }
+
+        public function set message(message:String):void {
+            _message = message;
+        }
+
+        public function get message():String {
+            return _message;
+        }
+
+        public function set method(method:Method):void {
+            _method = method;
+        }
+
+        public function get method():Method {
+            return _method;
+        }
+
+        public function toString():String {
+            if(method) {
+                return "[WARNING] " + method + " : " + message;
+            }
+            else {
+                return "[WARNING] " + message;
+            }
+        }
+    }
+}
+
+

data/src/asunit/framework/TimeoutCommand.as

@@ -0,0 +1,103 @@
+package asunit.framework {
+
+    import asunit.framework.Command;
+    import asunit.events.TimeoutCommandEvent;
+
+    import flash.events.Event;
+    import flash.events.EventDispatcher;
+    import flash.events.TimerEvent;
+    import flash.utils.Timer;
+
+    [Event(name="called",   type="flash.events.TimeoutCommandEvent")]
+    [Event(name="timedOut", type="flash.events.TimeoutCommandEvent")]
+    public class TimeoutCommand extends EventDispatcher implements Command {
+
+        public var scope:Object;
+        public var handler:Function;
+        public var duration:Number;
+        
+        protected var params:Array;
+        protected var timeout:Timer;
+        protected var failureHandler:Function;
+
+        public function TimeoutCommand(scope:Object, handler:Function=null, duration:int=0, failureHandler:Function=null) {
+            this.scope = scope;
+            this.handler = handler || function(...args):* {};
+            this.duration = duration;
+            this.failureHandler = failureHandler;
+            
+            //if (duration < 0) return;
+            timeout = new Timer(duration, 1);
+            timeout.addEventListener(TimerEvent.TIMER_COMPLETE, onTimeoutComplete);
+            timeout.start();
+        }
+       
+        /**
+         * Called by TestRunner when the TimeoutCommandEvent.CALLED event is thrown.
+         *
+         * This needs to be triggered from the Runner so that the runner can handle
+         * any exceptions or errors appropriately.
+         *
+         * This should NOT actually call the provided handler if the timeout has
+         * already been exceeded.
+         */
+        public function execute():* {
+            return handler.apply(scope, params);
+        }
+        
+        /**
+         * Return the function handler that will be called when the Asynchronous
+         * feature works properly.
+         */
+        public function getCallback():Function {
+            return wrapHandlerWithCorrectNumberOfArgs();
+        }
+        
+        /**
+         * Stop waiting for the timeout event, and don't call anything.
+         */
+        public function cancel():void {
+            if (timeout) timeout.stop();
+        }
+        
+        /**
+         * Called by the returned closure, and dispatches the CALLED event so that
+         * a client (TestRunner) can call execute().
+         */
+        protected function callback(...args):* {
+            if (timeout) timeout.stop();
+            this.params = args;
+            var event:Event = new TimeoutCommandEvent(TimeoutCommandEvent.CALLED, this);
+            dispatchEvent(event);
+        }
+        
+        protected function onTimeoutComplete(timerEvent:TimerEvent):void {
+            // Clobber handler so that original can no longer be called:
+            handler = function(...args):void {};
+            // Notify subscribers of the timeout:
+            var event:TimeoutCommandEvent = new TimeoutCommandEvent(TimeoutCommandEvent.TIMED_OUT, this);
+            dispatchEvent(event);
+            if (failureHandler != null) failureHandler(event);
+        }
+
+        protected function wrapHandlerWithCorrectNumberOfArgs():Function {
+            switch (handler.length) {
+                case 0: return function():* { return callback(); };
+                case 1: return function(a:*=null):* { return callback(a); };
+                case 2: return function(a:*=null, b:*=null):* { return callback(a, b); };
+                case 3: return function(a:*=null, b:*=null, c:*=null):* { return callback(a, b, c); };
+                case 4: return function(a:*=null, b:*=null, c:*=null, d:*=null):* { return callback(a, b, c, d); };
+                case 5: return function(a:*=null, b:*=null, c:*=null, d:*=null, e:*=null):* { return callback(a, b, c, d, e); };
+                case 6: return function(a:*=null, b:*=null, c:*=null, d:*=null, e:*=null, f:*=null):* { return callback(a, b, c, d, e, f); };
+                case 7: return function(a:*=null, b:*=null, c:*=null, d:*=null, e:*=null, f:*=null, g:*=null):* { return callback(a, b, c, d, e, f, g); };
+                case 8: return function(a:*=null, b:*=null, c:*=null, d:*=null, e:*=null, f:*=null, g:*=null, h:*=null):* { return callback(a, b, c, d, e, f, g, h); };
+                case 9: return function(a:*=null, b:*=null, c:*=null, d:*=null, e:*=null, f:*=null, g:*=null, h:*=null, i:*=null):* { return callback(a, b, c, d, e, f, g, h, i); };
+            }
+            return callback;
+        }
+        
+        override public function toString():String {
+            return '[TimeoutCommand scope=' + scope + ']';;
+        }
+    }
+}

data/src/asunit/printers/FlashBuilderPrinter.as

@@ -0,0 +1,134 @@
+package asunit.printers {
+	import asunit.framework.ITestFailure;
+	import asunit.framework.ITestWarning;
+
+	import asunit.framework.IResult;
+	import asunit.framework.IRunListener;
+	import asunit.framework.ITestSuccess;
+	import asunit.framework.Method;
+	import asunit.framework.TestObserver;
+
+	import flash.events.Event;
+	import flash.events.IOErrorEvent;
+	import flash.events.SecurityErrorEvent;
+	import flash.net.XMLSocket;
+	import flash.utils.getQualifiedClassName;
+
+	public class FlashBuilderPrinter implements IRunListener, TestObserver {
+		protected var projectName:String;
+		protected var contextName:String;
+		protected var messageQueue:Array;
+		protected var socket:XMLSocket;
+		
+		public function FlashBuilderPrinter(projectName:String = '', contextName:String = '') {
+			this.projectName = projectName;
+			this.contextName = contextName;
+			messageQueue = [];
+			socket = new XMLSocket();
+	      	socket.addEventListener(Event.CONNECT, onConnect);
+			socket.addEventListener(IOErrorEvent.IO_ERROR, onErrorEvent);
+			socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onErrorEvent);
+   	   		socket.addEventListener(Event.CLOSE, onErrorEvent);
+			connect();
+		}
+		
+		public function onRunStarted():void {
+			sendMessage("<startTestRun totalTestCount='0' projectName='" + projectName
+				+ "' contextName='" + contextName +"' />");
+		}
+		
+		public function onTestStarted(test:Object):void {
+		}
+		
+		public function onTestCompleted(test:Object):void {
+        }
+		
+		// works for both errors and failures
+		public function onTestFailure(failure:ITestFailure):void {
+			sendMessage(getFailureMessage(failure));
+		}
+		
+		public function onTestSuccess(success:ITestSuccess):void {
+			var xmlMessageSuccess:String = "<testCase name='" + success.method
+				+ "' testSuite='" + getQualifiedClassName(success.test) + "' status='success'/>";
+			sendMessage(xmlMessageSuccess);
+		}
+		
+		public function onTestIgnored(method:Method):void {
+			var xmlMessageIgnore:String = "<testCase name='" + method.name
+				+ "' testSuite='" + getQualifiedClassName(method.scope) + "' status='ignore'/>";
+			sendMessage(xmlMessageIgnore);
+		}
+		
+		public function onWarning(warning:ITestWarning):void {
+			//TODO: is there any way to send a warning to Flash Builder?
+		}
+		
+		public function onRunCompleted(result:IResult):void {
+			sendMessage('<endOfTestRun/>');
+			socket.close();
+		}
+		
+		protected function connect(ip:String = '127.0.0.1', port:uint = 8765):void {
+   	   		try {
+   	   			socket.connect(ip, port);
+   	   		}
+			catch (e:Error) {
+   	   			trace('## Error connecting to Flash Builder socket: ' + e.message);
+   	   		}
+		}
+		
+		protected function onConnect(event:Event):void {
+			sendQueuedMessages();
+		}
+		
+		protected function sendQueuedMessages():void {
+			while (messageQueue.length) {
+				sendMessage(messageQueue.shift());
+			}
+		}
+		
+		protected function sendMessage(message:String):void {
+			if (!socket.connected) {
+				messageQueue.push(message);
+				return;
+			}
+			socket.send(message);
+			//trace('+++++++++ sendMessage() - \n' + message + '\n');
+		}
+		
+		protected function getFailureMessage(failure:ITestFailure):String {
+			var status:String = failure.isFailure ? 'failure' : 'error';
+			var xml:String =
+				"<testCase name='" + failure.failedMethod
+				+ "' testSuite='" + getQualifiedClassName(failure.failedTest)
+				+ "' status='" + status + "'>"
+					+ "<failure type='" + getQualifiedClassName(failure.thrownException) + "' >"
+					
+						+ "<messageInfo>" + xmlEscapeMessage(failure.exceptionMessage)
+						+ "</messageInfo>"
+						
+						+ "<stackTraceInfo>" + xmlEscapeMessage(failure.thrownException.getStackTrace())
+						+ "</stackTraceInfo>"
+						
+					+ "</failure>"
+				+ "</testCase>";
+
+			return xml;
+		}
+		
+		protected function onErrorEvent(event:Event):void {
+			trace('FlashBuilderPrinter::onErrorEvent() - event: ' + event);
+			//throw new Error('FlashBuilderPrinter::onErrorEvent() - event: ' + event);
+		}
+		
+		protected static function xmlEscapeMessage(message:String):String {
+			if (!message) return '';
+			
+			var escape:XML = <escape/>;
+			escape.setChildren( message );
+			return escape.children()[0].toXMLString();
+		}
+		
+	}
+}

data/src/asunit/printers/FlashDevelopPrinter.as

@@ -0,0 +1,81 @@
+package asunit.printers {
+
+    import asunit.framework.ITestFailure;
+    import asunit.framework.ITestWarning;
+    import asunit.framework.IResult;
+    import asunit.framework.IRunListener;
+    import asunit.framework.ITestSuccess;
+    import asunit.framework.Method;
+    import asunit.framework.TestObserver;
+
+    public class FlashDevelopPrinter implements IRunListener, TestObserver {
+        protected static const localPathPattern:RegExp =
+            /([A-Z]:\\[^\/:\*\?<>\|]+\.\w{2,6})|(\\{2}[^\/:\*\?<>\|]+\.\w{2,6})/g;
+        
+        protected static const lineNumberPattern:RegExp = /:[0-9]*\]/;
+        
+        public function FlashDevelopPrinter() {
+        }
+        
+        public function onRunStarted():void {
+        }
+        
+        public function onTestStarted(test:Object):void {
+        }
+        
+        public function onTestCompleted(test:Object):void {
+        }
+        
+        // works for both errors and failures
+        public function onTestFailure(failure:ITestFailure):void {
+            sendMessage(getFailureMessage(failure));
+        }
+        
+        public function onTestSuccess(success:ITestSuccess):void {
+            // don't send success to FlashDevelop Panel
+        }
+        
+        public function onTestIgnored(method:Method):void {
+            // don't send ignored test to FlashDevelop Panel
+        }
+
+        public function onWarning(warning:ITestWarning):void {
+            //TODO: send warning to FlashDevelop Panel?
+        }
+        
+        public function onRunCompleted(result:IResult):void {
+        }
+                
+        protected function sendMessage(message:String):void {
+            trace(message);
+        }
+        
+        protected function getFailureMessage(failure:ITestFailure):String {
+            var status:String = (failure.isFailure) ? 'F' : 'E';
+            var stack:String = failure.thrownException.getStackTrace();
+            var lines:Array = stack.split('\n');
+            var methodPattern:RegExp = new RegExp(failure.failedMethod);
+            
+            var lineWithMethod:String = '';
+            for each (var line:String in lines) {
+                if (line.match(methodPattern)) {
+                    lineWithMethod = line;
+                    break;
+                }
+            }
+            //trace('\n' + lineWithMethod + '\n');
+                        
+            var filePath:String = String(lineWithMethod.match(localPathPattern)[0]);
+            // Find the line number between : and ], e.g. :25].
+            var matches:Array = lineWithMethod.match(lineNumberPattern);
+            var lineNumberRaw:String = matches ? matches[0] : '';
+            // Take off the colon and bracket (I need to get better at regex).
+            var lineNumber:String = lineNumberRaw.slice(1, -1);
+            
+            var message:String = filePath + ':'+lineNumber+': ' + status + ' '
+                + (failure.failedMethod + '(): ' + failure.exceptionMessage);
+                
+            return message;
+        }
+    }
+}