asproject 0.1.21

data/templates/asproject/asunit25/project/lib/asunit/asunit/framework/TestFailure.as

@@ -0,0 +1,47 @@
+//import flash.util.StringBuilder;
+import asunit.errors.AssertionFailedError;
+import asunit.framework.Test;
+
+/**
+ * A <code>TestFailure</code> collects a failed test together with
+ * the caught exception.
+ * @see TestResult
+ */
+class asunit.framework.TestFailure {
+	private var fFailedTest:String;
+	private var fThrownException:Error;
+	
+	/**
+	 * Constructs a TestFailure with the given test and exception.
+	 */
+	public function TestFailure(failedTest:Test, thrownException:Error) {
+		fFailedTest = failedTest.toString();
+		fThrownException = thrownException;
+	}
+	/**
+	 * Gets the failed test.
+	 */
+	public function failedTest():String {
+	    return fFailedTest;
+	}
+	/**
+	 * Gets the thrown exception.
+	 */
+	public function thrownException():Error {
+	    return fThrownException;
+	}
+	/**
+	 * Returns a short description of the failure.
+	 */
+	public function toString():String {
+		return "";
+	}
+
+	public function exceptionMessage():String {
+		return thrownException().message;
+	}
+
+	public function isFailure():Boolean {
+		return thrownException() instanceof AssertionFailedError;
+	}
+}

data/templates/asproject/asunit25/project/lib/asunit/asunit/framework/TestResult.as

@@ -0,0 +1,168 @@
+import asunit.errors.AssertionFailedError;
+import asunit.errors.InstanceNotFoundError;
+import asunit.framework.Test;
+import asunit.framework.TestCase;
+import asunit.framework.TestFailure;
+import asunit.framework.ITestListener;
+
+/**
+ * A <code>TestResult</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
+ */
+class asunit.framework.TestResult {
+	private var fFailures:Array;
+	private var fErrors:Array;
+	private var fListeners:Array;
+	private var fRunTests:Number;
+	private var fStop:Boolean;
+
+	public function TestResult() {
+		fFailures  = new Array();
+		fErrors	   = new Array();
+		fListeners = new Array();
+		fRunTests  = 0;
+		fStop	   = false;
+	}
+	/**
+	 * Adds an error to the list of errors. The passed in exception
+	 * caused the error.
+	 */
+	public function addError(test:Test, t:Error):Void {
+		fErrors.push(new TestFailure(test, t));
+		var len:Number = fListeners.length;
+		var item:ITestListener;
+		for(var i:Number = 0; i < len; i++) {
+			item = ITestListener(fListeners[i]);
+			item.addError(test, t);
+		}
+	}
+	/**
+	 * Adds a failure to the list of failures. The passed in exception
+	 * caused the failure.
+	 */
+	public function addFailure(test:Test, t:AssertionFailedError):Void {
+		fFailures.push(new TestFailure(test, t));
+		var len:Number = fListeners.length;
+		var item:ITestListener;
+		for(var i:Number = 0; i < len; i++) {
+			item = ITestListener(fListeners[i]);
+			item.addFailure(test, t);
+		}
+	}
+	/**
+	 * Registers a ITestListener
+	 */
+	public function addListener(listener:ITestListener):Void {
+		fListeners.push(listener);
+	}
+	/**
+	 * Unregisters a ITestListener
+	 */
+	public function removeListener(listener:ITestListener):Void {
+		var len:Number = fListeners.length;
+		for(var i:Number = 0; i < len; i++) {
+			if(fListeners[i] == listener) {
+				fListeners.splice(i, 1);
+				return;
+			}
+		}
+		throw new InstanceNotFoundError("removeListener called without listener in list");
+	}
+	/**
+	 * Gets the number of detected errors.
+	 */
+	public function errorCount():Number {
+		return fErrors.length;
+	}
+	/**
+	 * Returns an Enumeration for the errors
+	 */
+	public function errors():Array {
+		return fErrors;
+	}
+	/**
+	 * Gets the number of detected failures.
+	 */
+	public function failureCount():Number {
+		return fFailures.length;
+	}
+	/**
+	 * Returns an Enumeration for the failures
+	 */
+	public function failures():Array {
+		return fFailures;
+	}
+
+	/**
+	 * Runs a TestCase.
+	 */
+	public function run(test:TestCase):Void {
+		startTest(test);
+		try {
+			test.runBare();
+		}
+		catch(afe:AssertionFailedError) {
+			addFailure(test, afe);
+		}
+		catch(e:Error) {
+			addError(test, e);
+		}
+		finally {
+			endTest(test);
+		}
+	}
+	/**
+	 * Gets the number of run tests.
+	 */
+	public function runCount():Number {
+		return fRunTests;
+	}
+	/**
+	 * Checks whether the test run should stop
+	 */
+	public function shouldStop():Boolean {
+		return fStop;
+	}
+	/**
+	 * Informs the result that a test will be started.
+	 */
+	public function startTest(test:Test):Void {
+		var count:Number = test.countTestCases();
+		fRunTests += count;
+
+		var len:Number = fListeners.length;
+		var item:ITestListener;
+		for(var i:Number = 0; i < len; i++) {
+			item = ITestListener(fListeners[i]);
+			item.startTest(test);
+		}
+	}
+	/**
+	 * Informs the result that a test was completed.
+	 */
+	public function endTest(test:Test):Void {
+		var len:Number = fListeners.length;
+		var item:ITestListener;
+		for(var i:Number = 0; i < len; i++) {
+			item = ITestListener(fListeners[i]);
+			item.endTest(test);
+		}
+	}
+	/**
+	 * Marks that the test run should stop.
+	 */
+	public function stop():Void {
+		fStop = true;
+	}
+	/**
+	 * Returns whether the entire test was successful or not.
+	 */
+	public function wasSuccessful():Boolean {
+		return (failureCount() == 0 && errorCount() == 0);
+	}
+}

data/templates/asproject/asunit25/project/lib/asunit/asunit/framework/TestSuite.as

@@ -0,0 +1,102 @@
+import asunit.framework.TestCase;
+import asunit.framework.Test;
+import asunit.framework.TestResult;
+import asunit.util.Iterator;
+import asunit.util.ArrayIterator;
+
+class asunit.framework.TestSuite extends TestCase {
+	private var fTests:Array = new Array();
+
+	 public function TestSuite() {
+	 	super();
+	 	fTests = new Array();
+	}
+
+	private function getTestMethods():Array {
+		return new Array();
+	}
+	
+	public function testsComplete():Boolean {
+		var completed:Boolean;
+		var len:Number = fTests.length;
+		for(var i:Number = 0; i < len; i++) {
+			if(!fTests[i].testsComplete()) {
+				return false;
+			}
+		}
+		return true;
+	}
+	
+	/**
+	 * Adds a test to the suite.
+	 */
+	public function addTest(test:Test):Void {
+		fTests.push(test);
+	}
+	
+	/**
+	 * Counts the number of tests that will be run by this Suite.
+	 */
+	public function countTestCases():Number {
+		var count:Number;
+		var len:Number = fTests.length;
+		for(var i:Number = 0; i < len; i++) {
+			count = count + fTests[i].countTestCases();
+		}
+		return count;
+	}
+	
+	/**
+	 * Runs the tests and collects their result in a TestResult.
+	 */
+	public function run():Void {
+		var result:TestResult = getResult();
+		runTests(fTests, result);
+ 	}
+	
+	public function runTests(tests:Array, result:TestResult):Void {
+		var itr:Iterator = new ArrayIterator(tests);
+		var test:TestCase;
+		if(itr.hasNext()) {
+			test = TestCase(itr.next());
+			runTest(itr, test, result);
+		}
+	}
+	
+	public function runTest(itr:Iterator, test:TestCase, result:TestResult):Void {
+		test.setResult(result);
+		test.run();
+		if(itr.hasNext()) {
+			_global.setTimeout(this, "runTest", 10, itr, itr.next(), result);
+		}
+	}
+
+	/**
+	 * Returns the number of tests in this suite
+	 */
+	public function testCount():Number {
+		return fTests.length;
+	}
+	
+	public function toString():String {
+		return getName();
+	}
+	
+	public function getIsComplete():Boolean {
+		var len:Number = fTests.length;
+		for(var i:Number = 0; i < len; i++) {
+			if(!fTests[i].getIsComplete()) {
+				return false;
+			}
+		}
+		return true;
+	}
+	
+	public function setContext(context:MovieClip):Void {
+		super.setContext(context);
+		var len:Number = fTests.length;
+		for(var i:Number = 0; i < len; i++) {
+			fTests[i].setContext(context);
+		}
+	}
+}

data/templates/asproject/asunit25/project/lib/asunit/asunit/runner/BaseTestRunner.as

@@ -0,0 +1,101 @@
+import asunit.runner.IResultPrinter;
+import asunit.framework.Test;
+import asunit.framework.TestResult;
+import asunit.framework.Assert;
+import asunit.textui.ResultPrinter;
+
+class asunit.runner.BaseTestRunner {
+	private static var instance:BaseTestRunner;
+	private static var clipContext:MovieClip;
+	private var printer:IResultPrinter;
+	private var intervalId:Number;
+	
+	public function BaseTestRunner(printerReference:Function) {
+		if(printerReference == undefined) {
+			throw new Error("BaseTestRunner instantiated without a ResultPrinter");
+		}
+		Stage.scaleMode = "noscale";
+		Stage.align = "TL";
+		instance = this;
+		setClipContext(_root);
+		setPrinter(createResultPrinter(printerReference));
+	}
+
+	public static function getFilteredTrace(stack:String):String {
+		return stack;
+	}
+	
+	public function start(testCase:Function, testMethod:String, showTrace:Boolean):TestResult {
+		try {
+			var suite:Test = Test(new testCase(testMethod));
+			return doRun(suite, showTrace);
+		}
+		catch(e:Error) {
+			trace("ERROR: Failed to create and run test suite with: \n" + e.toString());
+		}
+	}
+	
+	public function doRun(suite:Test, showTrace:Boolean):TestResult {
+		try {
+			var result:TestResult = new TestResult();
+			result.addListener(getPrinter());
+			var startTime:Number = getTimer();
+			suite.setResult(result);
+			suite.setContext(getClipContext());
+			suite.run();
+			clearInterval(intervalId);
+			intervalId = setInterval(this, "completionHandler", 1, suite, result, startTime);
+			return result;
+		}
+		catch(e:Error) {
+			trace(e.toString());
+		}
+	}
+	
+	private function completionHandler(suite:Test, result:TestResult, startTime:Number):Void {
+		if(suite.testsComplete()) {
+			clearInterval(intervalId);
+			getPrinter().printResult(result, (getTimer() - startTime));
+		}
+	}
+	
+	public static function trace(msg:String):Void {
+		getInstance().getPrinter().trace(msg);
+	}
+	
+	public static function getInstance():BaseTestRunner {
+		if(instance == undefined) {
+			return instance = new BaseTestRunner(ResultPrinter);
+		}
+		return instance;
+	}
+	
+	public function setPrinter(printer:IResultPrinter):Void {
+		this.printer = printer;
+	}
+	
+	public function getPrinter():IResultPrinter {
+		return IResultPrinter(printer);
+	}
+
+	public function setClipContext(context:MovieClip):Void {
+		BaseTestRunner.clipContext = context;
+	}
+	/*
+	 * This function should return a reference to the
+	 * MovieClip that all test cases will attach items
+	 * to. This MovieClip should probably *not* be _root.
+	 */	
+	public function getClipContext():MovieClip {
+		return BaseTestRunner.clipContext;
+	}
+	
+	private static function createResultPrinter(reference:Function):IResultPrinter {
+		var printer:IResultPrinter;
+		if(printer == undefined) {
+			var context:MovieClip = BaseTestRunner.clipContext;
+			printer = IResultPrinter(context.attachMovie(reference.linkageId, "asUnitResultPrinter_" + 9000, Assert.nextDepth()));
+		}
+		return printer;
+	}
+}

data/templates/asproject/asunit25/project/lib/asunit/asunit/runner/IResultPrinter.as

@@ -0,0 +1,8 @@
+import asunit.framework.ITestListener;
+import asunit.framework.TestResult;
+
+interface asunit.runner.IResultPrinter extends ITestListener {
+	
+	public function printResult(result:TestResult, runTime:Number):Void;
+	public function trace():Void;
+}

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

@@ -0,0 +1,254 @@
+import asunit.runner.IResultPrinter;
+import asunit.errors.AssertionFailedError;
+import asunit.framework.Test;
+import asunit.framework.TestResult;
+import asunit.framework.TestFailure;
+import asunit.runner.BaseTestRunner;
+import asunit.textui.SuccessBar;
+import asunit.framework.ITestListener;
+
+class asunit.textui.ResultPrinter extends MovieClip implements IResultPrinter, ITestListener {
+	public static var linkageId:String = "__Packages.asunit.textui.ResultPrinter";
+	public static var classRef:Function = ResultPrinter;
+	private static var instance:ResultPrinter;
+	
+	private var fColumn:Number = 0;
+	private var showTrace:Boolean;
+	private var barHeight:Number = 3;
+	private var bgColor:Number = 0x333333;
+	private var fontColor:Number = 0xFFFFFF;
+	private var spacing:Number = 5;
+	private var textArea:TextField;
+	private var traceOutput:TextField;
+	private var successMeter:MovieClip;
+	private var bar:SuccessBar;
+	
+	public function ResultPrinter() {
+		init();
+		configureAssets();
+		println("AsUnit 2.5 by Luke Bayes and Ali Mills");
+		// If you can't see clips that you think should be
+		// attached... Perhaps it's behind this runner?
+		//_alpha = 50;
+	}
+	
+	private function init():Void {
+		if(instance != undefined) {
+			throw new Error("Resultprinter instantiated twice in one session, this will likely cause problems");
+		}
+		instance = this;
+		Stage.addListener(this);
+	}
+	
+	private function onLoad():Void {
+		onResize();
+	}
+	
+	private function configureAssets():Void {
+		createTextArea();
+		createOutput();
+		createSuccessBar();
+	}
+	
+	public function trace():Void {
+		traceOutput._visible = true;
+		traceOutput.text += arguments.toString() + "\n";
+		traceOutput.scroll = traceOutput.maxscroll;
+	}
+	
+	public function println():Void {
+		textArea.text += arguments.toString() + "\n";
+	}
+	
+	public function printf():Void {
+		textArea.text += arguments.toString();
+	}
+
+	public function startTest(test:Test):Void {
+		var count:Number = test.countTestCases();
+		for(var i:Number = 0; i < count; i++) {
+			printf(".");
+			if (fColumn++ >= 80) {
+				println();
+				fColumn = 0;
+			}
+		}
+	}
+	
+	public function addError(test:Test, e:Error):Void {
+		printf("E");
+	}
+	
+	public function addFailure(test:Test, e:AssertionFailedError):Void {
+		printf("F");
+	}
+	
+	public function endTest(test:Test):Void {
+	}
+	
+	private function createTextArea():Void {
+		textArea = getTextField("textArea", 2);
+	}
+	
+	private function createOutput():Void {
+		traceOutput = getTextField("output", 4);
+		traceOutput._visible = false;
+		var format:TextFormat = traceOutput.getTextFormat();
+		format.align = "right";
+		traceOutput.setNewTextFormat(format);
+	}
+
+	private function getTextField(name:String, depth:Number):TextField {
+		this.createTextField(name, depth, 0, 0, 100, 100);
+		var textField:TextField = this[name];
+		textField.wordWrap = true;
+		textField.multiline = true;
+		var format:TextFormat = new TextFormat();
+		format.font = "Verdana";
+		format.color = fontColor;
+		format.size = 11;
+		format.leftMargin = spacing/2;
+		format.rightMargin = spacing/2;
+		textField.setNewTextFormat(format);
+		return textField;
+	}
+	
+	private function createSuccessBar():Void {
+		bar = SuccessBar(attachMovie(SuccessBar.linkageId, "bar", 3));
+	}
+
+	private function onResize():Void {
+		draw();
+	}
+	
+	public function draw():Void {
+		var w:Number = Stage.width;
+		var h:Number = Stage.height;
+		drawBackground(w, h);
+		drawTextArea(w, h);
+		drawOutput(w, h);
+		drawBar(w, h);
+	}
+	
+	private function drawBackground(w:Number, h:Number):Void {
+		clear();
+		beginFill(bgColor);
+		lineTo(w, 0);
+		lineTo(w, h);
+		lineTo(0, h);
+		lineTo(0, 0);
+		endFill();
+	}
+	
+	private function drawTextArea(w:Number, h:Number):Void {
+		drawTextField(textArea, w, h);
+	}
+	
+	private function drawOutput(w:Number, h:Number):Void {
+		drawTextField(traceOutput, w, h);
+	}
+
+	private function drawTextField(ref:TextField, w:Number, h:Number):Void {
+		ref._width = w - (spacing*2);
+		ref._height = h - (barHeight + (spacing*2));
+		ref._x = spacing;
+		ref._y = spacing;
+	}
+
+	private function drawBar(w:Number, h:Number):Void {
+		bar._x = 0;
+		bar._y = h - (barHeight);
+		bar.width = w;
+		bar.height = barHeight;
+	}
+	
+	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);
+	    }
+	}
+
+	private function printHeader(runTime:Number):Void {
+		println();
+		println();
+		println("Time: " + elapsedTimeAsString(runTime));
+	}
+	
+	/**
+	 * Returns the formatted string of the elapsed time.
+	 * Duplicated from BaseTestRunner. Fix it.
+	 */
+	private function elapsedTimeAsString(runTime:Number):String {
+		return Number(runTime/1000).toString();
+	}
+
+	private function printErrors(result:TestResult):Void {
+		printDefects(result.errors(), result.errorCount(), "error");
+	}
+	
+	private function printFailures(result:TestResult):Void {
+		printDefects(result.failures(), result.failureCount(), "failure");
+	}
+	
+	private function printDefects(booBoos:Array, count:Number, type:String):Void {
+		if (count == 0) {
+			return;
+		}
+		if (count == 1) {
+			println("There was " + count + " " + type + ":");
+		}
+		else {
+			println("There were " + count + " " + type + "s:");
+		}
+		var item:TestFailure;
+		var len:Number = booBoos.length;
+		for(var i:Number = 0; i < len; i++) {
+			printDefect(TestFailure(booBoos[i]), i);
+		}
+	}
+	
+	public function printDefect(booBoo:TestFailure, count:Number ):Void { // only public for testing purposes
+		printDefectHeader(booBoo, count);
+		printDefectTrace(booBoo);
+	}
+
+	private function printDefectTrace(booBoo:TestFailure):Void {
+		println(BaseTestRunner.getFilteredTrace(booBoo.thrownException().toString()));
+	}
+
+	private function printDefectHeader(booBoo:TestFailure, count:Number):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:Number = textArea.text.length;
+		println(count + ") " + booBoo.failedTest());
+		var endIndex:Number = 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);
+	}
+
+	private function printFooter(result:TestResult):Void {
+		println();
+		if (result.wasSuccessful()) {
+			printf("OK");
+			println (" (" + result.runCount() + " test" + (result.runCount() == 1 ? "": "s") + ")");
+		} else {
+			println("FAILURES!!!");
+			println("Tests run: " + result.runCount()+ 
+				         ",  Failures: "+result.failureCount()+
+				         ",  Errors: "+result.errorCount());
+		}
+	    println();
+	}
+		
+	public static var serializable:Boolean = Object.registerClass(linkageId, classRef);
+}