asunit4 4.2.1.pre

data/test/asunit/framework/AssertEqualsArraysIgnoringOrderTest.as

@@ -0,0 +1,88 @@
+package asunit.framework
+{
+    import asunit.errors.AssertionFailedError;
+    import asunit.framework.TestCase;
+    import asunit.framework.Assert;
+    
+    /**
+     * Tests assertEqualsArraysIgnoringOrder
+     * 
+     * @author Bastian Krol
+     */
+    public class AssertEqualsArraysIgnoringOrderTest extends TestCase {
+        
+        public function AssertEqualsArraysIgnoringOrderTest(testMethod:String = null) {
+            super(testMethod);
+        }
+        
+        public function testNullEqualsNull():void {
+            assertEqualsArraysIgnoringOrder(Assert.assertEqualsArraysIgnoringOrder, null, null);
+        }
+
+        public function testNullDoesNotEqualNotNull():void {
+            assertAssertionFailed(Assert.assertEqualsArraysIgnoringOrder, null, []);
+        }
+
+        public function testNotNullDoesNotEqualNull():void {
+            assertAssertionFailed(Assert.assertEqualsArraysIgnoringOrder, [], null);
+        }
+    
+        public function testEmptyArrayEqualsEmptyArray():void {
+            assertEqualsArraysIgnoringOrder([], []);
+        }
+
+        public function testArrayWithOneStringEquals():void {
+            assertEqualsArraysIgnoringOrder(["abcdefg"], ["abcdefg"]);
+        }
+        
+        public function testArrayWithOneStringNotEquals():void {
+            assertAssertionFailed(Assert.assertEqualsArraysIgnoringOrder, ["abcdefg"], ["12345"]);
+        }
+
+        public function testArrayWithOneFunctionEquals():void {
+            assertEqualsArraysIgnoringOrder([tearDown], [tearDown]);
+        }
+        
+        public function testArrayWithOneFunctionNotEquals():void {
+            assertAssertionFailed(Assert.assertEqualsArraysIgnoringOrder, [setUp], [tearDown]);
+        }
+        
+        public function testArrayWithOneNullMemberEquals():void {
+            assertEqualsArraysIgnoringOrder([null], [null]);
+        }
+
+        public function testArrayWithOneNullMemberNotEquals1():void {
+            assertAssertionFailed(Assert.assertEqualsArraysIgnoringOrder, ["..."], [null]);
+        }
+
+        public function testArrayWithOneNullMemberNotEquals2():void {
+            assertAssertionFailed(Assert.assertEqualsArraysIgnoringOrder, [null], ["..."]);
+        }
+
+        public function testArrayEqualsSameOrder():void {
+            assertEqualsArraysIgnoringOrder(["abc", "def", "ghi"], ["abc", "def", "ghi"]);
+        }
+
+        public function testArrayNotEquals():void {
+            assertAssertionFailed(Assert.assertEqualsArraysIgnoringOrder, ["abc", "def", "ghi"], ["abc", "xyz", "ghi"]);
+        }
+        
+        public function testArrayEqualsDifferentOrder1():void {
+            assertEqualsArraysIgnoringOrder(["abc", "def", "ghi"], ["def", "abc", "ghi"]);
+        }
+
+        public function testArrayEqualsDifferentTypes():void {
+            assertAssertionFailed(Assert.assertEqualsArraysIgnoringOrder,
+                ["abc", "def", "ghi"], 
+                ["abc", setUp, "ghi"]);
+        }
+
+        public function testArrayDifferentLength1():void {
+            assertAssertionFailed(Assert.assertEqualsArraysIgnoringOrder, ["abc", "def", "ghi"], ["abc", "def"]);
+        }
+
+        public function testArrayDifferentLength2():void {
+            assertAssertionFailed(Assert.assertEqualsArraysIgnoringOrder, ["abc", "def"], ["abc", "def", "ghi"]);
+        }
+    }
+}

data/test/asunit/framework/AssertEqualsArraysTest.as

@@ -0,0 +1,102 @@
+package asunit.framework {
+
+    import asunit.asserts.*;
+    import asunit.errors.AssertionFailedError;
+    import asunit.framework.Assert;
+    import asunit.framework.TestCase;
+    
+    /**
+     * Tests assertEqualsArrays
+     * 
+     * @author Bastian Krol
+     */
+    public class AssertEqualsArraysTest {
+
+        [Test]
+        public function testNullEqualsNull():void {
+            assertEqualsArrays(null, null);
+        }
+
+        [Test]
+        public function testNullDoesNotEqualNotNull():void {
+            assertAssertionFailed(Assert.assertEqualsArrays, null, []);
+        }
+
+        [Test]
+        public function testNotNullDoesNotEqualNull():void {
+            assertAssertionFailed(Assert.assertEqualsArrays, [], null);
+        }
+    
+        [Test]
+        public function testEmptyArrayEqualsEmptyArray():void {
+            assertEqualsArrays([], []);
+        }
+
+        [Test]
+        public function testArrayWithOneStringEquals():void {
+            assertEqualsArrays(["abcdefg"], ["abcdefg"]);
+        }
+        
+        [Test]
+        public function testArrayWithOneStringNotEquals():void {
+            assertAssertionFailed(Assert.assertEqualsArrays, ["abcdefg"], ["12345"]);
+        }
+
+        [Test]
+        public function testArrayWithOneFunctionEquals():void {
+            assertEqualsArrays([functionReference2], [functionReference2]);
+        }
+        
+        [Test]
+        public function testArrayWithOneFunctionNotEquals():void {
+            assertAssertionFailed(Assert.assertEqualsArrays, [functionReference1], [functionReference2]);
+        }
+        
+        [Test]
+        public function testArrayWithOneNullMemberEquals():void {
+            assertEqualsArrays([null], [null]);
+        }
+
+        [Test]
+        public function testArrayWithOneNullMemberNotEquals1():void {
+            assertAssertionFailed(Assert.assertEqualsArrays, ["..."], [null]);
+        }
+
+        [Test]
+        public function testArrayWithOneNullMemberNotEquals2():void {
+            assertAssertionFailed(Assert.assertEqualsArrays, [null], ["..."]);
+        }
+
+        [Test]
+        public function testArrayEquals():void {
+            assertEqualsArrays(["abc", "def", "ghi"], ["abc", "def", "ghi"]);
+        }
+
+        [Test]
+        public function testArrayNotEquals():void {
+            assertAssertionFailed(Assert.assertEqualsArrays, ["abc", "def", "ghi"], ["abc", "xyz", "ghi"]);
+        }
+        
+        [Test]
+        public function testArrayDifferentLength1():void {
+            assertAssertionFailed(Assert.assertEqualsArrays, ["abc", "def", "ghi"], ["abc", "def"]);
+        }
+
+        [Test]
+        public function testArrayDifferentLength2():void {
+            assertAssertionFailed(Assert.assertEqualsArrays, ["abc", "def"], ["abc", "def", "ghi"]);
+        }
+
+        [Test]
+        public function testArrayEqualsWhatever():void {
+            assertAssertionFailed(Assert.assertEqualsArrays, ["abc", "def", "", "jkl"], ["abc", "def", null, "jkl"]);
+        }
+
+        private function functionReference1():void {
+        }
+
+        private function functionReference2():void {
+        }
+    }
+}
+

data/test/asunit/framework/AssertTest.as

@@ -0,0 +1,184 @@
+package asunit.framework {
+
+    public class AssertTest extends TestCase {
+
+        public function AssertTest(testMethod:String = null) {
+            super(testMethod);
+        }
+
+        public function testAssertTrue():void {
+            assertTrue(true);
+        }
+
+        public function testAssertFalse():void {
+            assertFalse(false);
+        }
+
+        public function testAssertFalseWithMessage():void {
+            assertFalse("message", false);
+        }
+
+        public function testAssertTrueWithMessage():void {
+            assertTrue("message", true);
+        }
+
+        public function testAssertTrueFailure():void {
+            try {
+                assertTrue(false);
+            }
+            catch(e:Error) {
+                return;
+            }
+            assertTrue("assertTrue(false) should have failed but didn't", false);
+        }
+
+        public function testAssertTrueMessage():void {
+            assertTrue("asertTrue with message", true);
+        }
+
+        public function testAssertTrueMessageFailure():void {
+            try {
+                assertTrue("trueMessage", false);
+            }
+            catch(e:Error) {
+                return;
+            }
+            assertTrue("assertTrue('message', false) should have failed but didn't", false);
+        }
+
+        public function testFail():void {
+            try {
+                Assert.fail("this shouldn't be caught");
+            }
+            catch(e:Error) {
+                assertTrue("passed", true);
+                return;
+            }
+            fail("failure should be thrown");
+        }
+
+        public function testAssertEqualsSimple():void {
+            var obj1:Object = new Object();
+            assertEquals(obj1, obj1);
+        }
+
+        public function testEqualsMethod():void {
+            var obj1:Object = new Object();
+            obj1.equals = function():Boolean {
+                return true;
+            };
+
+            var obj2:Object = new Object();
+            obj2.equals = function():Boolean {
+                return true;
+            };
+            assertEquals(obj1, obj2);
+        }
+
+        public function testEqualsSimpleMessage():void {
+            var obj1:Object = new Object();
+            assertEquals("message", obj1, obj1);
+        }
+
+        public function testEqualsFailure():void {
+            var obj1:Object = new Object();
+            var obj2:Object = new Object();
+            try {
+                assertEquals(obj1, obj2);
+            }
+            catch(e:Error) {
+                return;
+            }
+            fail("obj1 does not equal obj2");
+        }
+
+        public function testEqualsSimpleMessageFailure():void {
+            try {
+                var obj1:Object = new Object();
+                var obj2:Object = new Object();
+                assertEquals("message", obj1, obj2);
+            }
+            catch(e:Error) {
+                return;
+            }
+            fail("obj1 does not equal obj2 with message");
+        }
+
+        public function testNull():void {
+            assertNull(null);
+        }
+
+        public function testNullMessage():void {
+            assertNull("message", null);
+        }
+
+        public function testNullFailure():void {
+            var obj:Object = new Object();
+            try {
+                assertNull("message", obj);
+            }
+            catch(e:Error) {
+                return;
+            }
+            fail("null failure");
+        }
+
+        public function testNotNull():void {
+            var obj:Object = new Object();
+            assertNotNull(obj);
+        }
+
+        public function testNotNullFailure():void {
+            try {
+                assertNotNull(null);
+            }
+            catch(e:Error) {
+                return;
+            }
+            fail("not null failed");
+        }
+
+        public function testNotNullMessage():void {
+            var obj:Object = new Object();
+            assertNotNull("not null", obj);
+        }
+
+        public function testSame():void {
+            var obj:Object = new Object();
+            assertSame(obj, obj);
+        }
+
+        public function testSameFailure():void {
+            try {
+                assertSame(new Object(), new Object());
+            }
+            catch(e:Error) {
+                return;
+            }
+            fail("same failure");
+        }
+
+        public function testNotSame():void {
+            var obj1:Object = new Object();
+            var obj2:Object = new Object();
+            assertNotSame(obj1, obj2);
+        }
+
+        public function testNotSameFailure():void {
+            var obj1:Object = new Object();
+            try {
+                assertNotSame(obj1, obj1);
+            }
+            catch(e:Error) {
+                return;
+            }
+            fail("not same failure");
+        }
+
+        public function testNotSameMessage():void {
+            var obj1:Object = new Object();
+            var obj2:Object = new Object();
+            assertNotSame("not same message", obj1, obj2);
+        }
+    }
+}

data/test/asunit/framework/AssertThrowsTest.as

@@ -0,0 +1,42 @@
+package asunit.framework {
+
+    import asunit.asserts.*;
+	import asunit.errors.AssertionFailedError;
+
+    public class AssertThrowsTest {
+
+        [Test]
+		public function throwingExpectedErrorShouldPass():void {
+			assertThrows(ArgumentError, function():void { throw new ArgumentError(); } );
+		}
+		
+        [Test]
+		public function throwingUnexpectedErrorShouldFailWithMessage():void {
+			try {
+				assertThrows(ArgumentError, function():void { throw new Error("wrong error type"); } );
+			}
+			catch (e:AssertionFailedError) {
+				assertEquals("expected error type:<ArgumentError> but was:<Error>", e.message)
+				return;
+			}
+			fail('failed assertThrows() should have thrown AssertionFailedError');
+		}
+		
+		/**
+		 * Captures a bug in original assertThrows implementation
+		 * where the message when nothing was thrown said "but was:<AssertionFailedError>".
+		 */
+        [Test]
+		public function throwingNoErrorShouldFailWithMessage():void {
+			try {
+				assertThrows(ArgumentError, function():void { } );
+			}
+			catch (e:AssertionFailedError) {
+				assertEquals("expected error type:<ArgumentError> but none was thrown.", e.message)
+				return;
+			}
+			fail('failed assertThrows() should have thrown AssertionFailedError');
+		}
+	}
+}
+

data/test/asunit/framework/AsyncMethodTest.as

@@ -0,0 +1,69 @@
+package asunit.framework {
+    
+    import asunit.asserts.*;
+    
+    import flash.display.Sprite;
+    import flash.utils.setTimeout;
+
+    public class AsyncMethodTest {
+
+        [Inject]
+        public var async:IAsync;
+
+        [Inject]
+        public var sprite:Sprite;
+
+        [Before]
+        protected function setUp():void {
+            var handler:Function = async.add(asyncSetupHandler);
+            setTimeout(handler, 0);
+        }
+
+        public function asyncSetupHandler():void{
+        }
+
+        [Test]
+        public function testInstantiated():void {
+            assertTrue("Sprite instantiated", sprite is Sprite);
+        }
+
+        [Test]
+        public function testAsyncMethod():void {
+            var handler:Function = async.add(asyncHandler);
+            setTimeout(handler, 0);
+        }
+        
+        private function asyncHandler():void {
+            assertTrue(sprite is Sprite);
+        }
+        
+        [Test]
+        public function testAsyncVisualEntity():void {
+            var handler:Function = async.add(spriteHandler);
+            setTimeout(handler, 0);
+        }
+        
+        private function spriteHandler():void {
+            assertTrue(sprite is Sprite);
+        }
+
+        [Test]
+        public function testAsyncVisualEntity2():void {
+            var handler:Function = async.add(spriteHandler);
+            setTimeout(handler, 0);
+        }
+        
+        [Test]
+        public function testMultipleAsyncMethod():void {
+            var handler1:Function = async.add(spriteHandler);
+            var handler2:Function = async.add(spriteHandler);
+            setTimeout(handler1, 0);
+            setTimeout(handler2, 0);
+        }
+        
+        [Test]
+        public function testAsyncSetup():void{
+            assertTrue(sprite is Sprite);
+        }
+    }
+}

data/test/asunit/framework/AsyncTest.as

@@ -0,0 +1,104 @@
+package asunit.framework {
+
+    import asunit.asserts.*;
+    import asunit.events.TimeoutCommandEvent;
+    import asunit.framework.Async;
+    import asunit.framework.IAsync;
+    import asunit.framework.TestCase;
+
+    import flash.events.Event;
+    import flash.events.EventDispatcher;
+    import flash.utils.setTimeout;
+
+    public class AsyncTest {
+
+        [Inject]
+        public var async:IAsync;
+
+        [Inject]
+        public var dispatcher:EventDispatcher;
+
+        private var orphanAsync:IAsync;
+        private var command:TimeoutCommand;
+
+        [Before]
+        public function createOrphanAsync():void {
+            orphanAsync = new Async();
+        }
+
+        [After]
+        public function destroyOrphanAsync():void {
+            orphanAsync = null;
+        }
+
+        [Test]
+        public function asyncHandlerCanBeRetrievedByTestInstance():void {
+            var cancelTimeout:Function = async.add(foo);
+            
+            var commands:Array = async.getPending();
+            assertEquals("one command for test after addAsync()", 1, commands.length);
+            
+            var command:TimeoutCommand = commands[0];
+            assertSame("handler is the same function passed to addAsync", foo, command.handler);
+            
+            cancelTimeout();
+            
+            assertEquals("no commands for test after handler called", 0, async.getPending().length);
+        }
+        
+        [Test]
+        public function addAsyncShouldSendCALLEDEventIfDelegateCalledInTime():void {
+            var cancelTimeout:Function = async.add(foo, 50);
+            
+            command = async.getPending()[0];
+            
+            // Use AsUnit 3's addAsync() to verify onAsyncMethodCalled is called.
+            command.addEventListener(TimeoutCommandEvent.CALLED, async.add(onAsyncMethodCalled));
+            
+            // If all goes well, the ErrorEvent won't be dispatched.
+            command.addEventListener(TimeoutCommandEvent.TIMED_OUT, failIfCalled);
+
+            // cancelTimeout is called faster than async.add duration
+            setTimeout(cancelTimeout, 0);
+        }
+        
+        private function onAsyncMethodCalled(e:Event):void {
+            assertEquals("event type", TimeoutCommandEvent.CALLED, e.type);
+        }
+        
+        [Ignore(description="Async failure, but I'm no longer convinced that there is any value in this test case. Do we care if the TimeoutCommand can throw events? So long as we verify our failure state from the runner?")]
+        [Test]
+        public function addAsyncShouldSendErrorEventIfDelegateNotCalledInTime():void {
+
+            // This should be called by the orphanAsync instance when the timeout is exceeded:
+            var asyncMethodFailedHandler:Function = function(event:TimeoutCommandEvent):void {
+                assertEquals("event type", TimeoutCommandEvent.TIMED_OUT, event.type);
+                command.removeEventListener(TimeoutCommandEvent.CALLED, failIfCalled);
+                command.removeEventListener(TimeoutCommandEvent.TIMED_OUT, asyncMethodFailedHandler);
+            }
+
+            var timeoutHandler:Function = orphanAsync.add(null, 1);
+            // Set a timeout on the orphanAsync, but also pass this
+            // to the actual, outer test run async - when this is called,
+            // the outer test run can continue.
+            var cancelTimeout:Function = async.add(timeoutHandler, 500);
+
+            // Add subscriptions to the timeout command:
+            command = orphanAsync.getPending()[0];
+            command.addEventListener(TimeoutCommandEvent.CALLED, failIfCalled);
+            command.addEventListener(TimeoutCommandEvent.TIMED_OUT, orphanAsync.add(asyncMethodFailedHandler));
+
+            // we should attempt to call the async handler AFTER the timeout
+            // has already expired. The handler should NOT get called...
+            setTimeout(cancelTimeout, 10);
+        }
+        
+        
+        private function failIfCalled(event:Event=null):void {
+            fail("AsyncTest: This function should not have been called");
+        }
+		//TODO: You might want to delete this since it is basically a no-op handler. You could send instead now.
+        private function foo():void {};
+    }
+}
+

data/test/asunit/framework/CallbackBridgeTest.as

@@ -0,0 +1,73 @@
+package asunit.framework {
+
+    import asunit.asserts.*;
+    import asunit.support.FakeObserver;
+    import asunit.framework.Result;
+    import asunit.framework.CallbackBridge;
+
+	public class CallbackBridgeTest {
+
+        private var bridge:CallbackBridge;
+
+        private var observer:FakeObserver;
+
+        [Before]
+        public function createObserver():void {
+            observer = new FakeObserver();
+			bridge = new CallbackBridge();
+            bridge.addListener(observer);
+        }
+
+        [After]
+        public function destroyObserver():void {
+            observer = null;
+        }
+
+        [Test]
+		public function canInstantiate():void {
+			assertTrue("instance is CallbackBridge", bridge is CallbackBridge);
+		}
+
+        [Test]
+		public function addListenerWorked():void {
+            assertEquals(1, bridge.length);
+		}
+
+        [Test]
+        public function addedListenerReceivesOnRunStarted():void {
+            bridge.onRunStarted();
+            assertTrue(observer.onRunStartedCalled);
+        }
+
+        [Test]
+        public function addedListenerReceivesOnTestStarted():void {
+            bridge.onTestStarted(null);
+            assertTrue(observer.onTestStartedCalled);
+        }
+
+		[Test]
+		public function shouldHaveDefaultRunCount():void
+		{
+			assertEquals(0, bridge.runCount);
+		}
+		
+		[Test]
+		public function shouldHaveCumulativeRunCount():void
+		{
+			/*
+				function onTestStarted(test:Object):void;
+				function onTestCompleted(test:Object):void;
+				function onTestFailure(failure:ITestFailure):void;
+				function onTestSuccess(success:ITestSuccess):void;
+			*/
+			bridge.onTestStarted(null);
+			bridge.onTestSuccess(null);
+			bridge.onTestCompleted(null);
+			bridge.onTestStarted(null);
+			bridge.onTestSuccess(null);
+			bridge.onTestCompleted(null);
+			assertEquals(2, bridge.runCount);
+		}
+		
+	}
+}