asproject 0.1.21

data/templates/asproject/asunit3/project/lib/asunit/asunit/textui/FlexRunner.as

@@ -0,0 +1,19 @@
+package asunit.textui {
+	import asunit.framework.TestResult;
+	
+	import mx.core.Application;
+	
+	public class FlexRunner extends Application {
+		protected var runner:TestRunner;
+
+		override protected function createChildren():void {
+			super.createChildren();
+			runner = new FlexTestRunner();
+			rawChildren.addChild(runner);
+		}
+		
+		public function start(testCase:Class, testMethod:String = null, showTrace:Boolean = false):TestResult {
+			return runner.start(testCase, testMethod, showTrace);
+		}
+	}
+}

data/templates/asproject/asunit3/project/lib/asunit/asunit/textui/FlexTestRunner.as

@@ -0,0 +1,55 @@
+package asunit.textui {
+    import flash.display.DisplayObject;
+    import flash.events.Event;
+    import mx.core.IUIComponent;
+    import asunit.textui.TestRunner;
+
+    public class FlexTestRunner extends TestRunner {
+
+		public function FlexTestRunner() {
+			setPrinter(new ResultPrinter());
+		}
+	
+		protected override function addedHandler(event:Event):void {
+		    if(event.target === this) {
+				parent.addEventListener(Event.RESIZE, resizeHandler);
+				resizeHandler(new Event(Event.RESIZE));
+		    }
+		    else {
+				event.stopPropagation();
+			}
+		}
+	
+		public override function set width(w:Number):void {
+		    fPrinter.width = w;
+		}
+	
+		public override function set height(h:Number):void {
+		    fPrinter.height = h;
+		}
+	
+		public function resizeHandler(event:Event):void {
+		    width = parent.width;
+		    height = parent.height;
+		}
+	
+		public override function addChild(child:DisplayObject):DisplayObject {
+		    if(parent && child is IUIComponent) {
+				// AND check for 'is' UIUComponent...
+				return parent.addChild(child);
+		    }
+		    else {
+				return super.addChild(child);
+		    }
+		}
+	
+		public override function removeChild(child:DisplayObject):DisplayObject {
+		    if(child is IUIComponent) {
+				return parent.removeChild(child);
+		    }
+		    else {
+				return super.removeChild(child);
+		    }
+		}
+    }
+}

data/templates/asproject/asunit3/project/lib/asunit/asunit/textui/ResultPrinter.as

@@ -0,0 +1,245 @@
+package asunit.textui {
+	import asunit.errors.AssertionFailedError;
+	import asunit.framework.Test;
+	import asunit.framework.TestFailure;
+	import asunit.framework.TestListener;
+	import asunit.framework.TestResult;
+	import asunit.runner.BaseTestRunner;
+	import asunit.runner.Version;
+
+	import flash.display.Shape;
+	import flash.display.Sprite;
+	import flash.display.Stage;
+	import flash.display.StageAlign;
+	import flash.display.StageScaleMode;
+	import flash.events.*;
+	import flash.text.TextField;
+	import flash.text.TextFormat;
+	import flash.ui.Keyboard;
+	import flash.utils.setTimeout;
+
+	public class ResultPrinter extends Sprite implements TestListener {
+		private var fColumn:int = 0;
+		private var textArea:TextField;
+		private var gutter:uint = 0;
+		private var backgroundColor:uint = 0x333333;
+		private var bar:SuccessBar;
+		private var barHeight:Number = 3;
+		private var showTrace:Boolean;
+
+		public function ResultPrinter(showTrace:Boolean = false) {
+			this.showTrace = showTrace;
+			configureAssets();
+			println();
+		}
+
+		private function configureAssets():void {
+			textArea = new TextField();
+			textArea.background = true;
+			textArea.backgroundColor = backgroundColor;
+			textArea.border = true;
+			textArea.wordWrap = true;
+			var format:TextFormat = new TextFormat();
+			format.font = "Verdana";
+			format.size = 10;
+			format.color = 0xFFFFFF;
+			textArea.defaultTextFormat = format;
+			addChild(textArea);
+			println("AsUnit " + Version.id() + " by Luke Bayes and Ali Mills");
+
+			bar = new SuccessBar();
+			addChild(bar);
+		}
+
+		public function setShowTrace(showTrace:Boolean):void {
+			this.showTrace = showTrace;
+		}
+		
+		public override function set width(w:Number):void {
+			textArea.x = gutter;
+			textArea.width = w - gutter*2;
+			bar.x = gutter;
+			bar.width = textArea.width;
+		}
+
+		public override function set height(h:Number):void {
+			textArea.height = h - ((gutter*2) + barHeight);
+			textArea.y = gutter;
+			bar.y = h - (gutter + barHeight);
+			bar.height = barHeight;
+		}
+
+		public function println(...args:Array):void {
+			textArea.appendText(args.toString() + "\n");
+		}
+
+		public function print(...args:Array):void {
+			textArea.appendText(args.toString());
+		}
+		/* API for use by textui.TestRunner
+		 */
+
+		public function printResult(result:TestResult, runTime:Number):void {
+			printHeader(runTime);
+		    printErrors(result);
+		    printFailures(result);
+		    printFooter(result);
+
+   		    bar.setSuccess(result.wasSuccessful());
+   		    if(showTrace) {
+			    trace(textArea.text);
+   		    }
+		}
+
+		/* Internal methods
+		 */
+		protected function printHeader(runTime:Number):void {
+			println();
+			println();
+			println("Time: " + elapsedTimeAsString(runTime));
+		}
+
+		protected function printErrors(result:TestResult):void {
+			printDefects(result.errors(), result.errorCount(), "error");
+		}
+
+		protected function printFailures(result:TestResult):void {
+			printDefects(result.failures(), result.failureCount(), "failure");
+		}
+
+		protected function printDefects(booBoos:Object, count:int, type:String):void {
+			if (count == 0) {
+				return;
+			}
+			if (count == 1) {
+				println("There was " + count + " " + type + ":");
+			}
+			else {
+				println("There were " + count + " " + type + "s:");
+			}
+			var i:uint;
+			for each (var item:TestFailure in booBoos) {
+				printDefect(TestFailure(item), i);
+				i++;
+			}
+		}
+
+		public function printDefect(booBoo:TestFailure, count:int ):void { // only public for testing purposes
+			printDefectHeader(booBoo, count);
+			printDefectTrace(booBoo);
+		}
+
+		protected function printDefectHeader(booBoo:TestFailure, count:int):void {
+			// I feel like making this a println, then adding a line giving the throwable a chance to print something
+			// before we get to the stack trace.
+			var startIndex:uint = textArea.text.length;
+			println(count + ") " + booBoo.failedTest());
+			var endIndex:uint = textArea.text.length;
+
+			var format:TextFormat = textArea.getTextFormat();
+			format.bold = true;
+
+			// GROSS HACK because of bug in flash player - TextField isn't accepting formats...
+			setTimeout(onFormatTimeout, 1, format, startIndex, endIndex);
+		}
+
+		public function onFormatTimeout(format:TextFormat, startIndex:uint, endIndex:uint):void {
+			textArea.setTextFormat(format, startIndex, endIndex);
+		}
+
+		protected function printDefectTrace(booBoo:TestFailure):void {
+			println(BaseTestRunner.getFilteredTrace(booBoo.thrownException().getStackTrace()));
+		}
+
+		protected function printFooter(result:TestResult):void {
+			println();
+			if (result.wasSuccessful()) {
+				print("OK");
+				println (" (" + result.runCount() + " test" + (result.runCount() == 1 ? "": "s") + ")");
+			} else {
+				println("FAILURES!!!");
+				println("Tests run: " + result.runCount()+
+					         ",  Failures: "+result.failureCount()+
+					         ",  Errors: "+result.errorCount());
+			}
+		    println();
+		}
+
+		/**
+		 * Returns the formatted string of the elapsed time.
+		 * Duplicated from BaseTestRunner. Fix it.
+		 */
+		protected function elapsedTimeAsString(runTime:Number):String {
+			return Number(runTime/1000).toString();
+		}
+
+		/**
+		 * @see junit.framework.TestListener#addError(Test, Throwable)
+		 */
+		public function addError(test:Test, t:Error):void {
+			print("E");
+		}
+
+		/**
+		 * @see junit.framework.TestListener#addFailure(Test, AssertionFailedError)
+		 */
+		public function addFailure(test:Test, t:AssertionFailedError):void {
+			print("F");
+		}
+
+		/**
+		 * @see junit.framework.TestListener#endTest(Test)
+		 */
+		public function endTest(test:Test):void {
+		}
+
+		/**
+		 * @see junit.framework.TestListener#startTest(Test)
+		 */
+		public function startTest(test:Test):void {
+			var count:uint = test.countTestCases();
+			for(var i:uint; i < count; i++) {
+				print(".");
+				if (fColumn++ >= 80) {
+					println();
+					fColumn = 0;
+				}
+			}
+		}
+	}
+}
+
+import flash.display.Sprite;
+
+class SuccessBar extends Sprite {
+	private var myWidth:uint;
+	private var myHeight:uint;
+	private var bgColor:uint;
+	private var passingColor:uint = 0x00FF00;
+	private var failingColor:uint = 0xFD0000;
+
+	public function SuccessBar() {
+	}
+
+	public function setSuccess(success:Boolean):void {
+		bgColor = (success) ? passingColor : failingColor;
+		draw();
+	}
+
+	public override function set width(num:Number):void {
+		myWidth = num;
+		draw();
+	}
+
+	public override function set height(num:Number):void {
+		myHeight = num;
+		draw();
+	}
+
+	private function draw():void {
+		graphics.clear();
+		graphics.beginFill(bgColor);
+		graphics.drawRect(0, 0, myWidth, myHeight);
+		graphics.endFill();
+	}
+}

data/templates/asproject/asunit3/project/lib/asunit/asunit/textui/TestRunner.as

@@ -0,0 +1,121 @@
+package asunit.textui {
+	import asunit.errors.AbstractMemberCalledError;
+	import asunit.framework.Test;
+	import asunit.framework.TestResult;
+
+	import flash.display.Sprite;
+	import flash.display.StageAlign;
+	import flash.display.StageScaleMode;
+	import flash.events.Event;
+	import flash.system.fscommand;
+	import flash.utils.clearInterval;
+	import flash.utils.describeType;
+	import flash.utils.getTimer;
+	import flash.utils.setInterval;
+	import flash.utils.Timer;
+	import flash.events.TimerEvent;
+
+	/**
+	 * A command line based tool to run tests.
+	 * <pre>
+	 * java junit.textui.TestRunner TestCaseClass
+	 * </pre>
+	 * TestRunner expects the name of a TestCase class as argument.
+	 * If this class defines a static <code>suite</code> method it
+	 * will be invoked and the returned test is run. Otherwise all
+	 * the methods starting with "test" having no arguments are run.
+	 * <p>
+	 * TestRunner prints a trace as the tests are executed followed by a
+	 * summary at the end.
+	 */
+	public class TestRunner extends Sprite {
+		public static const SUCCESS_EXIT:int   = 0;
+		public static const FAILURE_EXIT:int   = 1;
+		public static const EXCEPTION_EXIT:int = 2;
+		public static const SHOW_TRACE:Boolean = true;
+		protected var fPrinter:ResultPrinter;
+		protected var startTime:Number;
+		protected var result:TestResult;
+
+		public function TestRunner() {
+			configureListeners();
+		}
+
+		private function configureListeners():void {
+			addEventListener(Event.ADDED, addedHandler);
+		}
+
+		protected function addedHandler(event:Event):void {
+			if(event.target === fPrinter) {
+				stage.align = StageAlign.TOP_LEFT;
+				stage.scaleMode = StageScaleMode.NO_SCALE;
+				stage.addEventListener(Event.RESIZE, resizeHandler);
+				resizeHandler(new Event("resize"));
+			}
+		}
+
+		private function resizeHandler(event:Event):void {
+			fPrinter.width = stage.stageWidth;
+			fPrinter.height = stage.stageHeight;
+		}
+
+		/**
+		 * Starts a test run based on the TestCase/TestSuite provided
+		 * Create a new custom class that extends TestRunner
+		 * and call start(TestCaseClass) from within the
+		 * constructor.
+		 */
+		public function start(testCase:Class, testMethod:String = null, showTrace:Boolean = false):TestResult {
+//			fscommand("showmenu", "false");
+
+			try {
+				var instance:Test;
+				if(testMethod != null) {
+					instance = new testCase(testMethod);
+				}
+				else {
+					instance = new testCase();
+				}
+				return doRun(instance, showTrace);
+			}
+			catch(e:Error) {
+				throw new Error("Could not create and run test suite: " + e.getStackTrace());
+			}
+			return null;
+		}
+
+		public function doRun(test:Test, showTrace:Boolean = false):TestResult {
+			result = new TestResult();
+			if(fPrinter == null) {
+				setPrinter(new ResultPrinter(showTrace));
+			}
+			else {
+				fPrinter.setShowTrace(showTrace);
+			}
+			result.addListener(getPrinter());
+			startTime = getTimer();
+			test.setResult(result);
+			test.setContext(this);
+			test.addEventListener(Event.COMPLETE, testCompleteHandler);
+			test.run();
+			return result;
+		}
+		
+		private function testCompleteHandler(event:Event):void {
+			var endTime:Number = getTimer();
+			var runTime:Number = endTime - startTime;
+			getPrinter().printResult(result, runTime);
+		}
+
+		public function setPrinter(printer:ResultPrinter):void {
+			if(fPrinter == null) {
+				fPrinter = printer;
+				addChild(fPrinter);
+			}
+		}
+
+		public function getPrinter():ResultPrinter {
+			return fPrinter;
+		}
+	}
+}

data/templates/asproject/asunit3/project/lib/asunit/asunit/util/ArrayIterator.as

@@ -0,0 +1,26 @@
+package asunit.util {
+
+	import asunit.util.Iterator;
+
+	[ExcludeClass]
+	public class ArrayIterator implements Iterator {
+		private var list:Array;
+		private var index:Number = 0;
+
+		public function ArrayIterator(list:Array) {
+			this.list = list;
+		}
+
+		public function hasNext():Boolean {
+			return list[index] != null;
+		}
+
+		public function next():Object {
+			return list[index++];
+		}
+
+		public function reset():void {
+			index = 0;
+		}
+	}
+}