asunit4 4.2.1.pre

data/src/asunit/core/FlashDevelopCore.as

@@ -0,0 +1,21 @@
+package asunit.core {
+
+    import asunit.printers.FlashDevelopPrinter;
+
+    import flash.system.fscommand;
+
+    public class FlashDevelopCore extends TextCore {
+
+        override protected function initializeObservers():void {
+            super.initializeObservers();
+            addObserver(new FlashDevelopPrinter());
+        }
+
+		override protected function onRunCompleted():void {
+            super.onRunCompleted();
+			fscommand('quit'); // fails silently if not in debug player
+			//System.exit(0); // generates SecurityError if not in debug player
+		}
+    }
+}
+

data/src/asunit/core/TextCore.as

@@ -0,0 +1,54 @@
+package asunit.core {
+
+    import asunit.printers.TextPrinter;
+
+    import flash.display.DisplayObjectContainer;
+
+    /**
+     * TextCore is just a simple helper class that
+     * configures the base class AsUnitCore to use the 
+     * standard TextPrinter.
+     *
+     * The main idea is that you may want a completely
+     * different text output without the default TextPrinter,
+     * and if that's the case, you can go ahead and 
+     * instantiate AsUnitCore and configure it however you
+     * wish.
+     */
+    public class TextCore extends AsUnitCore {
+
+        private var textPrinter:TextPrinter;
+
+        override protected function initializeObservers():void {
+            super.initializeObservers();
+
+            textPrinter = new TextPrinter();
+            addObserver(textPrinter);
+        }
+
+        /* Delegate some configuration to the TextPrinter */
+        public function set displayPerformanceDetails(show:Boolean):void {
+            textPrinter.displayPerformanceDetails = show;
+        }
+
+        public function get displayPerformanceDetails():Boolean {
+            return textPrinter.displayPerformanceDetails;
+        }
+
+        public function set traceOnComplete(should:Boolean):void {
+            textPrinter.traceOnComplete = should;
+        }
+
+        public function get traceOnComplete():Boolean {
+            return textPrinter.traceOnComplete;
+        }
+        
+
+        override public function set visualContext(context:DisplayObjectContainer):void {
+            super.visualContext = context;
+            // Add the TextPrinter to the Display List:
+            visualContext.addChild(textPrinter);
+        }
+    }
+}
+

data/src/asunit/errors/AbstractError.as

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

data/src/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/src/asunit/errors/ClassNotFoundError.as

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

data/src/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/src/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/src/asunit/errors/UsageError.as

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

data/src/asunit/events/TimeoutCommandEvent.as

@@ -0,0 +1,27 @@
+package asunit.events {
+
+	import asunit.framework.TimeoutCommand;
+
+	import flash.events.Event;
+
+	public class TimeoutCommandEvent extends Event {
+        public static const ADDED:String     = 'added';
+		public static const CALLED:String    = 'called';
+		public static const TIMED_OUT:String = 'timedOut';
+		
+		public var command:TimeoutCommand;
+		
+		public function TimeoutCommandEvent(type:String, command:TimeoutCommand, bubbles:Boolean=false, cancelable:Boolean=false) {
+			super(type, bubbles, cancelable);
+			this.command = command;
+		}
+		
+		public override function clone():Event {
+			return new TimeoutCommandEvent(type, command, bubbles, cancelable);
+		}
+		
+		public override function toString():String {
+			return formatToString("TimeoutCommandEvent", "command", "type", "bubbles", "cancelable", "eventPhase");
+		}
+	}
+}

data/src/asunit/framework/Assert.as

@@ -0,0 +1,408 @@
+package asunit.framework {
+    import asunit.errors.AssertionFailedError;
+
+    import flash.utils.getQualifiedClassName;
+
+    import flash.errors.IllegalOperationError;
+    import flash.events.EventDispatcher;
+
+    /**
+     * 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 actual:Object;
+
+            if(args.length == 1) {
+                message = "";
+                actual = args[0];
+            }
+            else if(args.length == 2) {
+                message = args[0];
+                actual = args[1];
+            }
+            else {
+                throw new IllegalOperationError("Invalid argument count");
+            }
+
+            if(!actual) {
+				throw new AssertionFailedError(format(message, true, actual));
+            }
+        }
+        /**
+         * 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 actual:Object;
+
+            if(args.length == 1) {
+                message = "";
+                actual = args[0];
+            }
+            else if(args.length == 2) {
+                message = args[0];
+                actual = args[1];
+            }
+            else {
+                throw new IllegalOperationError("Invalid argument count");
+            }
+
+            if(actual) {
+				throw new AssertionFailedError(format(message, false, actual));
+            }
+        }
+        /**
+         *  Fails a test with the given message.
+         *
+         *  @example This method can be called anytime you want to break out and fail
+         *  the current test.
+         *
+         *  <listing>
+         *  public function testSomething():void {
+         *      var instance:MyClass = new MyClass();
+         *      if(instance.foo()) {
+         *          fail('The foo should not have been there');
+         *      }
+         *  }
+         *  </listing>
+         */
+        static public function fail(message:String):void {
+            throw new AssertionFailedError(message);
+        }
+
+        /**
+        *  Asserts that the provided block throws an exception that matches
+        *  the type provided.
+        *
+        *  <listing>
+        *  public function testFailingCode():void {
+        *     assertThrows(CustomError, function():void {
+        *           var instance:Sprite = new Sprite();
+        *           instance.callMethodThatThrows();
+        *     });
+        *  }
+        *  </listing>
+        **/
+        static public function assertThrows(errorType:Class, block:Function):void {
+			try {
+				block.call();
+			}
+			catch(e:Error) {
+				if(!(e is errorType)) {
+					throw new AssertionFailedError("expected error type:<" + getQualifiedClassName(errorType)
+						+"> but was:<" + getQualifiedClassName(e) + ">");
+				}
+				return;
+			}
+			throw new AssertionFailedError("expected error type:<" + getQualifiedClassName(errorType) + "> but none was thrown." );
+        }
+
+        /**
+         *  Asserts that two objects are equal. If they are not
+         *  an AssertionFailedError is thrown with the given message.
+         *
+         *  This assertion should be (by far) the one you use the most.
+         *  It automatically provides useful information about what
+         *  the failing values were.
+         *
+         *  <listing>
+         *  public function testNames():void {
+         *      var name1:String = "Federico Aubele";
+         *      var name2:String = "Frederico Aubele";
+         *
+         *      assertEquals(name1, name2);
+         *  }
+         *  </listing>
+         */
+        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;
+                }
+            }
+
+            throw new AssertionFailedError(format(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 actual:Object;
+
+            if(args.length == 1) {
+                message = "";
+                actual = args[0];
+            }
+            else if(args.length == 2) {
+                message = args[0] + " ";
+                actual = args[1];
+            }
+            else {
+                throw new IllegalOperationError("Invalid argument count");
+            }
+
+			if(actual == null) {
+				throw new AssertionFailedError(message + "expected not null but was:<" + actual + ">");
+			}
+        }
+        /**
+         * 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 actual:Object;
+
+            if(args.length == 1) {
+                message = "";
+                actual = args[0];
+            }
+            else if(args.length == 2) {
+                message = args[0];
+                actual = args[1];
+            }
+            else {
+                throw new IllegalOperationError("Invalid argument count");
+            }
+			
+			if(actual != null) {
+				throw new AssertionFailedError(format(message, null, 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 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) {
+				throw new AssertionFailedError(message + "expected same as:<" + expected + "> but was:<" + actual + ">");
+            }
+        }
+         /**
+          * Asserts that two objects do not refer to the same object. If they do,
+          * 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) {
+				throw new AssertionFailedError(message + "expected not same but both were:<" + actual + ">");
+			}
+        }
+
+        /**
+         * 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;
+            }
+            throw new AssertionFailedError(format(message, expected, actual));
+        }
+
+        /**
+         * Asserts that two arrays have the same length and contain the same
+         * objects in the same order. If the arrays are not equal by this
+         * definition an AssertionFailedError is thrown with the given message.
+         */
+        static public function assertEqualsArrays(...args:Array):void {
+            var message:String;
+            var expected:Array;
+            var actual:Array;
+
+            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;
+            }
+            if ((expected == null && actual != null) || (expected != null && actual == null)) {
+                failNotEquals(message, expected, actual);
+            }
+            // from here on: expected != null && actual != null
+            if (expected.length != actual.length) {
+                failNotEquals(message, expected, actual);
+            }
+            for (var i : int = 0; i < expected.length; i++) {
+                assertEquals(expected[i], actual[i]);
+            }
+        }
+
+        /**
+         * Asserts that two arrays have the same length and contain the same
+         * objects. The order of the objects in the arrays is ignored. If they
+         * are not equal by this definition an AssertionFailedError is thrown
+         * with the given message.
+         */
+        static public function assertEqualsArraysIgnoringOrder(...args:Array):void {
+            var message:String;
+            var expected:Array;
+            var actual:Array;
+
+            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;
+            }
+            if ((expected == null && actual != null) || (expected != null && actual == null)) {
+                failNotEquals(message, expected, actual);
+            }
+            // from here on: expected != null && actual != null
+            if (expected.length != actual.length) {
+                failNotEquals(message, expected, actual);
+            }
+            for (var i : int = 0; i < expected.length; i++) {
+                var foundMatch : Boolean = false;
+                var expectedMember : Object = expected[i];
+                for (var j : int = 0; j < actual.length; j++) {
+                    var actualMember : Object = actual[j];
+                    try {
+                        assertEquals(expectedMember, actualMember);
+                        foundMatch = true;
+                        break;
+                    }
+                    catch (e : AssertionFailedError) {
+                        //  no match, try next
+                    }
+                }
+                if (!foundMatch) {
+                    failNotEquals("Found no match for " + expectedMember + ";", expected, 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 + ">";
+        }
+    }
+}