asproject 0.1.21

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

@@ -0,0 +1,41 @@
+
+class asunit.textui.SuccessBar extends MovieClip {
+	public static var linkageId:String = "__Packages.asunit.textui.SuccessBar";
+	public static var classRef:Function = SuccessBar;
+	
+	private var myWidth:Number = 0;
+	private var myHeight:Number = 0;
+	private var bgColor:Number;
+	private var passingColor:Number = 0x00FF00;
+	private var failingColor:Number = 0xFD0000;
+	
+	public function SuccessBar() {
+	}
+	
+	public function setSuccess(success:Boolean):Void {
+		bgColor = (success) ? passingColor : failingColor;
+		draw();
+	}
+
+	public function set width(num:Number):Void {
+		myWidth = num;
+		draw();
+	}
+
+	public function set height(num:Number):Void {
+		myHeight = num;
+		draw();
+	}
+
+	private function draw():Void {
+		clear();
+		beginFill(bgColor);
+		lineTo(myWidth, 0);
+		lineTo(myWidth, myHeight);
+		lineTo(0, myHeight);
+		lineTo(0, 0);
+		endFill();
+	}
+	
+	public static var serializable:Boolean = Object.registerClass(linkageId, classRef);
+}

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

@@ -0,0 +1,17 @@
+import asunit.runner.BaseTestRunner;
+import asunit.textui.ResultPrinter;
+
+/*
+ * This concrete TestRunner is simply created in order
+ * to choose a concrete ResultPrinter... This was
+ * set up so that we can easily output results
+ * to any target desired - this should include
+ * XMLSocket, LocalConnection, trace window, 
+ * file system, etc.
+ */
+class asunit.textui.TestRunner extends BaseTestRunner {
+	
+	public function TestRunner() {
+		super(ResultPrinter);
+	}
+}

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

@@ -0,0 +1,24 @@
+
+import asunit.util.Iterator;
+import asunit.errors.IllegalOperationError;
+
+class asunit.util.ArrayIterator implements Iterator {
+
+	private var list:Array;
+	private var index:Number = 0;
+
+	public function ArrayIterator(list:Array) {
+		if(list == null) {
+			throw new IllegalOperationError("ArrayIterator needs an array in it's constructor");
+		}
+		this.list = list;
+	}
+
+	public function hasNext():Boolean {
+		return (list[index] != null);
+	}
+
+	public function next():Object {
+		return list[index++];
+	}
+}

data/templates/asproject/asunit25/project/lib/asunit/asunit/util/ArrayIteratorTest.as

@@ -0,0 +1,52 @@
+
+import asunit.util.ArrayIterator;
+import asunit.framework.TestCase;
+
+class asunit.util.ArrayIteratorTest extends TestCase {
+	private var className:String = "asunit.util.ArrayIteratorTest";
+	private var instance:ArrayIterator;
+
+	public function ArrayIteratorTest(testMethod:String) {
+		super(testMethod);
+	}
+
+	public function setUp():Void {
+		var arr:Array = new Array("one", "two", "three", "four", "five");
+		instance = new ArrayIterator(arr);
+	}
+
+	public function tearDown():Void {
+		delete instance;
+	}
+
+	public function testInstantiated():Void {
+		assertTrue("ArrayIterator instantiated", instance instanceof ArrayIterator);
+	}
+
+	public function testIterate():Void {
+		assertTrue("1", instance.hasNext());
+		assertEquals("2", "one", instance.next());
+		assertTrue("3", instance.hasNext());
+		assertEquals("4", "two", instance.next());
+		assertTrue("5", instance.hasNext());
+		assertEquals("6", "three", instance.next());
+		assertTrue("7", instance.hasNext());
+		assertEquals("8", "four", instance.next());
+		assertTrue("9", instance.hasNext());
+		assertEquals("10", "five", instance.next());
+		assertFalse("11", instance.hasNext());
+	}
+	
+	public function testEmpty():Void {
+		var itr:ArrayIterator = new ArrayIterator(new Array());
+		assertFalse("1", itr.hasNext());
+	}
+	
+	public function testSingleItem():Void {
+		var itr:ArrayIterator = new ArrayIterator(new Array("one"));
+		assertTrue(itr.hasNext());
+		assertEquals("2", "one", itr.next());
+		assertFalse("3", itr.hasNext());
+		
+	}
+}

data/templates/asproject/asunit25/project/lib/asunit/asunit/util/Iterator.as

@@ -0,0 +1,5 @@
+
+interface asunit.util.Iterator {
+	public function hasNext():Boolean;
+	public function next():Object;
+}

data/templates/asproject/asunit3/project/lib/asunit/AsUnitTestRunner.as

@@ -0,0 +1,10 @@
+package {
+	import asunit.textui.TestRunner;
+	
+	public class AsUnitTestRunner extends TestRunner {
+
+		public function AsUnitTestRunner() {
+			start(AllTests, null, TestRunner.SHOW_TRACE);
+		}
+	}
+}

data/templates/asproject/asunit3/project/lib/asunit/asunit/errors/AbstractMemberCalledError.as

@@ -0,0 +1,10 @@
+package asunit.errors {
+	
+	public class AbstractMemberCalledError extends Error {
+		
+		public function AbstractMemberCalledError(message:String) {
+			super(message);
+			name = "AbstractMemberCalledError";
+		}
+	}
+}

data/templates/asproject/asunit3/project/lib/asunit/asunit/errors/AssertionFailedError.as

@@ -0,0 +1,10 @@
+package asunit.errors {
+	
+	public class AssertionFailedError extends Error {
+		
+		public function AssertionFailedError(message:String) {
+			super(message);
+			name = "AssertionFailedError";
+		}
+	}
+}

data/templates/asproject/asunit3/project/lib/asunit/asunit/errors/ClassNotFoundError.as

@@ -0,0 +1,10 @@
+package asunit.errors {
+	
+	public class ClassNotFoundError extends Error {
+		
+		public function ClassNotFoundError(message:String) {
+			super(message);
+			name = "ClassNotFoundError";
+		}	
+	}
+}

data/templates/asproject/asunit3/project/lib/asunit/asunit/errors/InstanceNotFoundError.as

@@ -0,0 +1,10 @@
+package asunit.errors {
+	
+	public class InstanceNotFoundError extends Error {
+		
+		public function InstanceNotFoundError(message:String) {
+			super(message);
+			name = "InstanceNotFoundError";
+		}
+	}
+}

data/templates/asproject/asunit3/project/lib/asunit/asunit/errors/UnimplementedFeatureError.as

@@ -0,0 +1,10 @@
+package asunit.errors {
+	
+	public class UnimplementedFeatureError extends Error {
+		
+		public function UnimplementedFeatureError(message:String) {
+			super(message);
+			name = "UnimplementedFeatureError";
+		}
+	}
+}

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

@@ -0,0 +1,271 @@
+package asunit.framework {
+	import asunit.errors.AssertionFailedError;
+	
+	import flash.errors.IllegalOperationError;
+	import flash.events.EventDispatcher;
+	import flash.utils.Proxy;
+
+	/**
+	 * A set of assert methods.  Messages are only displayed when an assert fails.
+	 */
+
+	public class Assert extends EventDispatcher {
+		/**
+		 * Protect constructor since it is a static only class
+		 */
+		public function Assert() {
+		}
+
+		/**
+		 * Asserts that a condition is true. If it isn't it throws
+		 * an AssertionFailedError with the given message.
+		 */
+		static public function assertTrue(...args:Array):void {
+			var message:String;
+			var condition:Boolean;
+
+			if(args.length == 1) {
+				message = "";
+				condition = Boolean(args[0]);
+			}
+			else if(args.length == 2) {
+				message = args[0];
+				condition = Boolean(args[1]);
+			}
+			else {
+				throw new IllegalOperationError("Invalid argument count");
+			}
+
+			if(!condition) {
+				fail(message);
+			}
+		}
+		/**
+		 * Asserts that a condition is false. If it isn't it throws
+		 * an AssertionFailedError with the given message.
+		 */
+		static public function assertFalse(...args:Array):void {
+			var message:String;
+			var condition:Boolean;
+
+			if(args.length == 1) {
+				message = "";
+				condition = Boolean(args[0]);
+			}
+			else if(args.length == 2) {
+				message = args[0];
+				condition = Boolean(args[1]);
+			}
+			else {
+				throw new IllegalOperationError("Invalid argument count");
+			}
+
+			assertTrue(message, !condition);
+		}
+		/**
+		 * Fails a test with the given message.
+		 */
+		static public function fail(message:String):void {
+			throw new AssertionFailedError(message);
+		}
+		/**
+		 * Asserts that two objects are equal. If they are not
+		 * an AssertionFailedError is thrown with the given message.
+		 */
+		static public function assertEquals(...args:Array):void {
+			var message:String;
+			var expected:Object;
+			var actual:Object;
+
+			if(args.length == 2) {
+				message = "";
+				expected = args[0];
+				actual = args[1];
+			}
+			else if(args.length == 3) {
+				message = args[0];
+				expected = args[1];
+				actual = args[2];
+			}
+			else {
+				throw new IllegalOperationError("Invalid argument count");
+			}
+
+			if(expected == null && actual == null) {
+				return;
+			}
+
+			try {
+				if(expected != null && expected.equals(actual)) {
+					return;
+				}
+			}
+			catch(e:Error) {
+				if(expected != null && expected == actual) {
+					return;
+				}
+			}
+
+			failNotEquals(message, expected, actual);
+		}
+		/**
+		 * Asserts that an object isn't null. If it is
+		 * an AssertionFailedError is thrown with the given message.
+		 */
+		static public function assertNotNull(...args:Array):void {
+			var message:String;
+			var object:Object;
+
+			if(args.length == 1) {
+				message = "";
+				object = args[0];
+			}
+			else if(args.length == 2) {
+				message = args[0];
+				object = args[1];
+			}
+			else {
+				throw new IllegalOperationError("Invalid argument count");
+			}
+
+			assertTrue(message, object != null);
+		}
+		/**
+		 * Asserts that an object is null.  If it is not
+		 * an AssertionFailedError is thrown with the given message.
+		 */
+		static public function assertNull(...args:Array):void {
+			var message:String;
+			var object:Object;
+
+			if(args.length == 1) {
+				message = "";
+				object = args[0];
+			}
+			else if(args.length == 2) {
+				message = args[0];
+				object = args[1];
+			}
+			else {
+				throw new IllegalOperationError("Invalid argument count");
+			}
+
+			assertTrue(message, object == null);
+		}
+		/**
+		 * Asserts that two objects refer to the same object. If they are not
+		 * an AssertionFailedError is thrown with the given message.
+		 */
+		static public function assertSame(...args:Array):void {
+			var message:String;
+			var expected:Object;
+			var actual:Object;
+
+			if(args.length == 2) {
+				message = "";
+				expected = args[0];
+				actual = args[1];
+			}
+			else if(args.length == 3) {
+				message = args[0];
+				expected = args[1];
+				actual = args[2];
+			}
+			else {
+				throw new IllegalOperationError("Invalid argument count");
+			}
+
+			if(expected === actual) {
+				return;
+			}
+			failNotSame(message, expected, actual);
+		}
+	 	/**
+	 	 * Asserts that two objects refer to the same object. If they are not
+	 	 * an AssertionFailedError is thrown with the given message.
+	 	 */
+		static public function assertNotSame(...args:Array):void {
+			var message:String;
+			var expected:Object;
+			var actual:Object;
+
+			if(args.length == 2) {
+				message = "";
+				expected = args[0];
+				actual = args[1];
+			}
+			else if(args.length == 3) {
+				message = args[0];
+				expected = args[1];
+				actual = args[2];
+			}
+			else {
+				throw new IllegalOperationError("Invalid argument count");
+			}
+
+			if(expected === actual)
+				failSame(message);
+		}
+
+		/**
+		 * Asserts that two numerical values are equal within a tolerance range.
+		 * If they are not an AssertionFailedError is thrown with the given message.
+		 */
+		static public function assertEqualsFloat(...args:Array):void {
+			var message:String;
+			var expected:Number;
+			var actual:Number;
+			var tolerance:Number = 0;
+
+			if(args.length == 3) {
+				message = "";
+				expected = args[0];
+				actual = args[1];
+				tolerance = args[2];
+			}
+			else if(args.length == 4) {
+				message = args[0];
+				expected = args[1];
+				actual = args[2];
+				tolerance = args[3];
+			}
+			else {
+				throw new IllegalOperationError("Invalid argument count");
+			}
+			if (isNaN(tolerance)) tolerance = 0;
+			if(Math.abs(expected - actual) <= tolerance) {
+				   return;
+			}
+			failNotEquals(message, expected, actual);
+		}
+
+
+		static private function failSame(message:String):void {
+			var formatted:String = "";
+	 		if(message != null) {
+	 			formatted = message + " ";
+	 		}
+	 		fail(formatted + "expected not same");
+		}
+
+		static private function failNotSame(message:String, expected:Object, actual:Object):void {
+			var formatted:String = "";
+			if(message != null) {
+				formatted = message + " ";
+			}
+			fail(formatted + "expected same:<" + expected + "> was not:<" + actual + ">");
+		}
+
+		static private function failNotEquals(message:String, expected:Object, actual:Object):void {
+			fail(format(message, expected, actual));
+		}
+
+		static private function format(message:String, expected:Object, actual:Object):String {
+			var formatted:String = "";
+			if(message != null) {
+				formatted = message + " ";
+			}
+			return formatted + "expected:<" + expected + "> but was:<" + actual + ">";
+		}
+	}
+}