asunit4 4.2.2.pre → 4.2.3.pre

data/src/asunit/framework/SuiteIterator.as

@@ -1,26 +1,22 @@
-package asunit.framework {
-
-    import asunit.util.Iterator;
-
-	import flash.utils.getDefinitionByName;
-
-    import p2.reflect.Reflection;
-    import p2.reflect.ReflectionVariable;
-    import p2.reflect.ReflectionMetaData;
+package asunit.framework {
+	import asunit.util.Iterator;
+
+	import p2.reflect.Reflection;
+	import p2.reflect.ReflectionVariable;
+
+	import flash.utils.getDefinitionByName;
 
 	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);
+		public function SuiteIterator(Suite:Class) {
+			list = getTestClasses(Suite);
 		}
 		
-        private function getTestClasses(Suite:Class, bridge:CallbackBridge=null):Array {
-			if(bridge == null) bridge = new CallbackBridge();
-			
-            var reflection:Reflection = Reflection.create(Suite);
+        private function getTestClasses(Suite:Class):Array {
+           var reflection:Reflection = Reflection.create(Suite);
 
             if(!isSuite(reflection) && isTest(reflection)) {
                 return [Suite];
@@ -31,16 +27,24 @@ package asunit.framework {
             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);
+                if(isSuite(Reflection.create(TestConstructor))) {
+					var testClasses:Array = getTestClasses(TestConstructor);
+					for each(var testClass:Class in testClasses) {
+						pushIfNotInArray(testClass, response);
+					}
+ 				}
+				else { 
+                    pushIfNotInArray(TestConstructor, response)
                 }
             }
             response.sort();
             return response;
-        }
+        }
+        
+        private function pushIfNotInArray(item:Object, array:Array):void {
+        	if (array.indexOf(item) >= 0) return;
+        	array[array.length] = item;
+        }
 
         public function get length():uint {
             return list.length;
@@ -58,7 +62,9 @@ package asunit.framework {
             return list[index] != null;
         }
 
-        // Returns a Class reference:
+        /**
+         * Returns a test Class.
+         */
         public function next():* {
             return list[index++];
         }

data/src/asunit/framework/TestCase.as

@@ -44,8 +44,7 @@ package asunit.framework {
         }
 
         protected function addChild(child:DisplayObject):DisplayObject {
-            context.addChild(child);
-            return child;
+            return context.addChild(child);
         }
 
         protected function removeChild(child:DisplayObject):DisplayObject {
@@ -71,6 +70,12 @@ package asunit.framework {
             Assert.assertThrows(errorType, block);
         }
 
+        protected function assertThrowsWithMessage(errorType:Class,
+												   errorMessage:String,
+												   block:Function):void {
+            Assert.assertThrowsWithMessage(errorType, errorMessage, block);
+        }
+
         protected function assertEquals(...args:Array):void {
             Assert.assertEquals.apply(null, args);
         }
@@ -92,7 +97,7 @@ package asunit.framework {
         }
 
         protected function assertEqualsFloat(...args:Array):void {
-            Assert.assertEquals.apply(null, args);
+            Assert.assertEqualsFloat.apply(null, args);
         }
 
         protected function assertEqualsArrays(...args:Array):void {

data/src/asunit/printers/FlashBuilderPrinter.as

@@ -1,29 +1,34 @@
 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;
+    import flash.net.XMLSocket;
 
-	public class FlashBuilderPrinter implements IRunListener, TestObserver {
-		protected var projectName:String;
-		protected var contextName:String;
-		protected var messageQueue:Array;
+    /**
+     * FlashBuilderPrinter should connect to the running Flash Builder test result
+     * view over an XMLSocket and send it test results as they accumulate.
+     */
+    public class FlashBuilderPrinter extends XMLPrinter {
+        
 		protected var socket:XMLSocket;
-		
+
 		public function FlashBuilderPrinter(projectName:String = '', contextName:String = '') {
-			this.projectName = projectName;
-			this.contextName = contextName;
-			messageQueue = [];
+            testPrefix = null;
+            testSuffix = null;
+            traceResults = false;
+            super(projectName, contextName);
+            connectToSocket();
+        }
+
+        protected function connectToSocket():void {
 			socket = new XMLSocket();
 	      	socket.addEventListener(Event.CONNECT, onConnect);
 			socket.addEventListener(IOErrorEvent.IO_ERROR, onErrorEvent);
@@ -32,41 +37,8 @@ package asunit.printers {
 			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 onErrorEvent(event:Event):void {
+			trace('FlashBuilderPrinter::onErrorEvent() - event: ' + event);
 		}
 		
 		protected function connect(ip:String = '127.0.0.1', port:uint = 8765):void {
@@ -77,6 +49,11 @@ package asunit.printers {
    	   			trace('## Error connecting to Flash Builder socket: ' + e.message);
    	   		}
 		}
+
+        override public function onRunCompleted(result:IResult):void {
+            super.onRunCompleted(result);
+			socket.close();
+        }
 		
 		protected function onConnect(event:Event):void {
 			sendQueuedMessages();
@@ -88,47 +65,12 @@ package asunit.printers {
 			}
 		}
 		
-		protected function sendMessage(message:String):void {
+		override 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

@@ -6,9 +6,8 @@ package asunit.printers {
     import asunit.framework.IRunListener;
     import asunit.framework.ITestSuccess;
     import asunit.framework.Method;
-    import asunit.framework.TestObserver;
 
-    public class FlashDevelopPrinter implements IRunListener, TestObserver {
+    public class FlashDevelopPrinter implements IRunListener {
         protected static const localPathPattern:RegExp =
             /([A-Z]:\\[^\/:\*\?<>\|]+\.\w{2,6})|(\\{2}[^\/:\*\?<>\|]+\.\w{2,6})/g;
         

data/src/asunit/printers/FlexUnitCIPrinter.as

@@ -0,0 +1,181 @@
+package asunit.printers {
+	import asunit.framework.IResult;
+	import asunit.framework.IRunListener;
+	import asunit.framework.ITestFailure;
+	import asunit.framework.ITestSuccess;
+	import asunit.framework.ITestWarning;
+	import asunit.framework.Method;
+
+	import flash.events.DataEvent;
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	import flash.events.IOErrorEvent;
+	import flash.events.SecurityErrorEvent;
+	import flash.events.TimerEvent;
+	import flash.net.XMLSocket;
+	import flash.system.fscommand;
+	import flash.utils.Timer;
+	import flash.utils.getQualifiedClassName;
+	import flash.utils.getTimer;
+	
+	public class FlexUnitCIPrinter extends EventDispatcher implements IRunListener
+	{
+		protected static const DEFAULT_SERVER:String = "127.0.0.1";
+		protected static const DEFAULT_PORT:uint = 1024;
+
+		public var port:uint;
+		public var server:String; //this is local host. same machine
+
+		private static const SUCCESS:String = "success";
+		private static const ERROR:String = "error";
+		private static const FAILURE:String = "failure";
+		private static const IGNORE:String = "ignore";
+		
+		private static const START_OF_TEST_RUN_ACK : String = "<startOfTestRunAck/>";
+		private static const END_OF_TEST_ACK : String ="<endOfTestRunAck/>";
+		private static const END_OF_TEST_RUN : String = "<endOfTestRun/>";
+		
+		private var socket:XMLSocket;		
+		private var connectTimeout:Timer;
+		
+		protected var messageQueue:Array;
+		
+		private var startTime : int;
+		
+		public function FlexUnitCIPrinter() 
+		{
+			this.port = port;
+			this.server = server;
+			messageQueue = [];
+			
+			socket = new XMLSocket();
+			socket.addEventListener(Event.CONNECT, onConnect);
+			socket.addEventListener(DataEvent.DATA, onData);
+			socket.addEventListener(IOErrorEvent.IO_ERROR, onErrorEvent);
+			socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onErrorEvent);
+   	   		socket.addEventListener(Event.CLOSE, onErrorEvent);
+			
+			connectTimeout = new Timer(5000, 1);
+			connectTimeout.addEventListener(TimerEvent.TIMER_COMPLETE, onConnectTimeout);
+			connectTimeout.start();
+
+			connect();
+		}
+	
+		protected function connect(ip:String = DEFAULT_SERVER, port:uint = DEFAULT_PORT):void {
+   	   		try {
+   	   			socket.connect(ip, port);
+   	   		}
+			catch (e:Error) {
+   	   			trace('## Error connecting to socket: ' + e.message);
+   	   		}
+		}	
+		
+		private function onConnectTimeout(event:TimerEvent):void {
+			throw new Error('Timed out waiting to connect to socket.');
+		}
+		
+		public function onTestIgnored(method:Method):void {
+			var xmlMessageIgnore:String = "<testcase classname='" + getQualifiedClassName(method.scope)
+				+ "' name='" + method.name + "' status='"+IGNORE+"'>"
+				+ "<skipped />"
+				+ "</testcase>";
+			sendMessage(xmlMessageIgnore);
+		}
+		
+		protected static function xmlEscapeMessage(message:String):String {
+			if (!message) return '';
+			
+			var escape:XML = <escape/>;
+			escape.setChildren( message );
+			return escape.children()[0].toXMLString();
+		}			
+		
+		public function onTestFailure(failure:ITestFailure):void {
+			sendMessage(getFailureMessage(failure));
+		}
+
+		protected function getFailureMessage(failure:ITestFailure):String {
+			var status:String = failure.isFailure ? FAILURE : ERROR;
+//			var stackTrace:String = xmlEscapeMessage(failure.thrownException.getStackTrace());
+			var stackTrace:String = failure.thrownException.getStackTrace();
+			var xml:String =
+				"<testcase classname='" + getQualifiedClassName(failure.failedTest)
+				+ "' name='" + failure.failedMethod
+				+ "' time='0.000' status='" + status + "'>"
+				
+					+ "<error message='" + xmlEscapeMessage(failure.exceptionMessage) 
+					+ "' type='"+ getQualifiedClassName(failure.thrownException) +"' >"
+						+ "<![CDATA[" + stackTrace + "]]>"
+					+ "</error>"				
+						
+				+ "</testcase>";
+
+			return xml;
+		}		
+				
+		protected function sendMessage(message:String):void {
+			if (!socket.connected) {
+				messageQueue.push(message);
+				return;
+			}
+			socket.send(message);
+		}
+	
+		protected function onConnect(event:Event):void {
+			connectTimeout.stop();
+			sendQueuedMessages();
+		}
+		
+		protected function sendQueuedMessages():void {
+			while (messageQueue.length) {
+				sendMessage(messageQueue.shift());
+			}
+		}		
+
+		private function onData( event : DataEvent ) : void
+		{
+			if (event.data == END_OF_TEST_ACK) {
+				exit();
+			}
+		}
+
+		protected function onErrorEvent(event:Event):void {
+			trace('FlexUnitCIPrinter::onErrorEvent() - event: ' + event);
+			//throw new Error('FlashBuilderPrinter::onErrorEvent() - event: ' + event);
+		}
+		
+		public function onRunStarted():void {
+		}
+		
+        public function onTestStarted(test:Object):void {
+            startTime = getTimer();
+        }
+        
+        public function onTestCompleted(test:Object):void {
+//            testTimes.push({test:test, duration:duration});
+        }
+        
+		public function onTestSuccess(success:ITestSuccess):void 
+		{
+			//TODO: move test time into ITestSuccess
+            var duration:Number = (getTimer() - startTime) / 1000;
+			var xmlMessageSuccess:String = "<testcase classname='" + getQualifiedClassName(success.test) 
+				+ "' name='" + success.method + "' time='0.000' status='"+SUCCESS+"'/>";
+			sendMessage(xmlMessageSuccess);			
+		}
+				
+		public function onRunCompleted(result:IResult):void {
+			sendMessage(END_OF_TEST_RUN);
+		}		
+		
+		protected function exit():void
+		{
+			socket.close();
+			fscommand("quit");
+		}
+
+		public function onWarning(warning:ITestWarning) : void {
+		}
+	}
+}