asproject 0.1.21

data/templates/asproject/asunit3/project/lib/asunit/asunit/framework/TestCaseExample.as

@@ -0,0 +1,73 @@
+package asunit.framework {
+	import asunit.framework.TestCase;
+	import flash.display.Sprite;
+	import flash.events.Event;
+	import flash.events.IEventDispatcher;
+	import flash.events.EventDispatcher;
+	import flash.utils.setTimeout;
+
+	// TestCase subclasses should always end with 'Test', the example
+	// doesn't because we don't want TestSuites in this directory.
+	public class TestCaseExample extends TestCase {
+		private var date:Date;
+		private var sprite:Sprite;
+
+		// TestCase constructors must be implemented as follows
+		// so that we can execute a single method on them from
+		// the TestRunner
+		public function TestCaseExample(testMethod:String = null) {
+			super(testMethod);
+		}
+
+		// This method will be called before every test method
+		override protected function setUp():void {
+			date = new Date();
+//			sprite = new Sprite();
+//			addChild(sprite);
+		}
+
+		// This method will be called after every test method
+		// but only if we're executing the entire TestCase,
+		// the tearDown method won't be called if we're
+		// calling start(MyTestCase, "someMethod");
+		override protected function tearDown():void {
+//			removeChild(sprite);
+//			sprite = null;
+			date = null;
+		}
+
+		// This is auto-created by the XULUI and ensures that
+		// our objects are actually created as we expect.
+		public function testInstantiated():void {
+			assertTrue("Date instantiated", date is Date);
+//			assertTrue("Sprite instantiated", sprite is Sprite);
+		}
+
+		// This is an example of a typical test method
+		public function testMonthGetterSetter():void {
+			date.month = 1;
+			assertEquals(1, date.month);
+		}
+
+		// This is an asynchronous test method
+		public function testAsyncFeature():void {
+			// create a new object that dispatches events...
+			var dispatcher:IEventDispatcher = new EventDispatcher();
+			// get a TestCase async event handler reference
+			// the 2nd arg is an optional timeout in ms. (default=1000ms )
+			var handler:Function = addAsync(changeHandler, 2000);
+			// subscribe to your event dispatcher using the returned handler
+			dispatcher.addEventListener(Event.CHANGE, handler);
+			// cause the event to be dispatched.
+			// either immediately:
+			//dispatcher.dispatchEvent(new Event(Event.CHANGE));
+			// or in the future < your assigned timeout
+			setTimeout( dispatcher.dispatchEvent, 200, new Event(Event.CHANGE));
+		}
+
+		protected function changeHandler(event:Event):void {
+			// perform assertions in your handler
+			assertEquals(Event.CHANGE, event.type);
+		}
+	}
+}

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

@@ -0,0 +1,47 @@
+package asunit.framework {
+	import asunit.errors.AssertionFailedError;
+	
+	/**
+	 * A <code>TestFailure</code> collects a failed test together with
+	 * the caught exception.
+	 * @see TestResult
+	 */
+	public class TestFailure {
+		protected var fFailedTest:String;
+		protected 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() is AssertionFailedError;
+		}
+	}
+}

data/templates/asproject/asunit3/project/lib/asunit/asunit/framework/TestListener.as

@@ -0,0 +1,22 @@
+package asunit.framework {
+	import asunit.errors.AssertionFailedError;
+	
+	public interface TestListener {
+		/**
+	 	 * An error occurred.
+	 	 */
+		function addError(test:Test, t:Error):void;
+		/**
+	 	 * A failure occurred.
+	 	 */
+	 	function addFailure(test:Test, t:AssertionFailedError):void;  
+		/**
+		 * A test ended.
+		 */
+	 	function endTest(test:Test):void; 
+		/**
+		 * A test started.
+		 */
+		function startTest(test:Test):void;
+	}
+}

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

@@ -0,0 +1,158 @@
+package asunit.framework {
+	import asunit.errors.AssertionFailedError;
+	import asunit.errors.InstanceNotFoundError;
+	
+	import flash.errors.IllegalOperationError;
+	import flash.events.EventDispatcher;
+	
+	/**
+	 * 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
+	 */
+	public class TestResult {
+		protected var fFailures:Array;
+		protected var fErrors:Array;
+		protected var fListeners:Array;
+		protected var fRunTests:int;
+		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:uint = fListeners.length;
+			var item:TestListener;
+			for(var i:uint; i < len; i++) {
+				item = TestListener(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:uint = fListeners.length;
+			var item:TestListener;
+			for(var i:uint; i < len; i++) {
+				item = TestListener(fListeners[i]);
+				item.addFailure(test, t);
+			}
+		}
+		/**
+		 * Registers a TestListener
+		 */
+		public function addListener(listener:TestListener):void {
+			fListeners.push(listener);
+		}
+		/**
+		 * Unregisters a TestListener
+		 */
+		public function removeListener(listener:TestListener):void {
+			var len:uint = fListeners.length;
+			for(var i:uint; 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():int {
+			return fErrors.length;
+		}
+		/**
+		 * Returns an Enumeration for the errors
+		 */
+		public function errors():Array {
+			return fErrors;
+		}
+		/**
+		 * Gets the number of detected failures.
+		 */
+		public function failureCount():int {
+			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);
+			test.runBare();
+		}
+		/**
+		 * Gets the number of run tests.
+		 */
+		public function runCount():int {
+			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:int = test.countTestCases();
+			fRunTests += count;
+
+			var len:uint = fListeners.length;
+			var item:TestListener;
+			for(var i:uint; i < len; i++) {
+				item = TestListener(fListeners[i]);
+				item.startTest(test);
+			}
+		}
+		/**
+		 * Informs the result that a test was completed.
+		 */
+		public function endTest(test:Test):void {
+			var len:uint = fListeners.length;
+			var item:TestListener;
+			for(var i:uint; i < len; i++) {
+				item = TestListener(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/asunit3/project/lib/asunit/asunit/framework/TestSuite.as

@@ -0,0 +1,115 @@
+package asunit.framework {
+	import flash.display.DisplayObjectContainer;
+	import flash.events.Event;
+	import asunit.util.Iterator;
+	import asunit.util.ArrayIterator;
+	
+	/**
+	 * A <code>TestSuite</code> is a <code>Composite</code> of Tests.
+	 * It runs a collection of test cases. Here is an example using
+	 * the dynamic test definition.
+	 * <pre>
+	 * TestSuite suite = new TestSuite();
+	 * suite.addTest(new MathTest());
+	 * suite.addTest(new OtherTest());
+	 * </pre>
+	 * @see Test
+	 * @see TestCase
+	 */
+	public class TestSuite extends TestCase implements Test {
+		private var fTests:Array = new Array();
+		private var testsCompleteCount:Number = 0;
+		private var iterator:ArrayIterator;
+		private var isRunning:Boolean;
+
+		 public function TestSuite() {
+		 	super();
+		 	fTests = new Array();
+		}
+
+		protected override function setTestMethods(methodNodes:XMLList):void {
+			testMethods = new Array();
+		}
+		
+		/**
+		 * 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 override function countTestCases():int {
+			var count:int;
+			for each(var test:TestCase in fTests) {
+				count = count + test.countTestCases();
+			}
+			return count;
+		}
+		
+		/**
+		 * Runs the tests and collects their result in a TestResult.
+		 */
+		public override function run():void {
+			var result:TestResult = getResult();
+			var test:Test;
+			var itr:Iterator = getIterator();
+			while(itr.hasNext()) {
+				isRunning = true;
+				test = Test(itr.next());
+				test.setResult(result);
+				test.addEventListener(Event.COMPLETE, testCompleteHandler);
+				test.run();
+				if(!test.getIsComplete()) {
+					isRunning = false;
+					break;
+				}
+			}
+		}
+
+		private function getIterator():ArrayIterator {
+			if(iterator == null) {
+				iterator = new ArrayIterator(fTests);
+			}
+			return iterator;
+		}
+		
+		private function testCompleteHandler(event:Event):void {
+			if(!isRunning) {
+				run();
+			}
+			if(++testsCompleteCount >= testCount()) {
+				dispatchEvent(new Event(Event.COMPLETE));
+			}
+		}
+		
+		/**
+		 * Returns the number of tests in this suite
+		 */
+		public function testCount():int {
+			return fTests.length;
+		}
+		
+		public override function toString():String {
+			return getName();
+		}
+		
+		public override function getIsComplete():Boolean {
+			for each(var test:TestCase in fTests) {
+				if(!test.getIsComplete()) {
+					return false;
+				}
+			}
+			return true;
+		}
+		
+		public override function setContext(context:DisplayObjectContainer):void {
+			super.setContext(context);
+			for each(var test:Test in fTests) {
+				test.setContext(context);
+			}
+		}
+	}
+}

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

@@ -0,0 +1,15 @@
+package asunit.runner {
+	import flash.display.Sprite;
+	
+	/**
+	 * Base class for all test runners.
+	 * This class was born live on stage in Sardinia during XP2000.
+	 */
+	public class BaseTestRunner extends Sprite {
+
+		// Filters stack frames from internal JUnit classes
+		public static function getFilteredTrace(stack:String):String {
+			return stack;
+		}
+	}
+ }

data/templates/asproject/asunit3/project/lib/asunit/asunit/runner/TestSuiteLoader.as

@@ -0,0 +1,9 @@
+package asunit.runner {
+	
+	public interface TestSuiteLoader {
+		// throws ClassNotFoundException
+		function load(suiteClassName:String):Class;
+		// throws ClassNotFoundException
+		function reload(aClass:Class):Class;
+	}
+}

data/templates/asproject/asunit3/project/lib/asunit/asunit/runner/Version.as

@@ -0,0 +1,11 @@
+package asunit.runner {
+	
+	public class Version {
+		private static var version:String = "3.0";
+		
+		public static function id():String {
+			return version.toString();
+		}
+		
+	}
+}