asunit4 4.2.2.pre → 4.2.3.pre

data/test/AllTests.as

@@ -11,12 +11,12 @@ package {
     import asunit.framework.AssertEqualsArraysTest;
     import asunit.framework.AssertTest;
     import asunit.framework.AssertThrowsTest;
+    import asunit.framework.AssertThrowsWithMessageTest;
     import asunit.framework.AsyncMethodTest;
     import asunit.framework.AsyncTest;
-    import asunit.framework.CallbackBridgeTest;
-    import asunit.framework.InjectionDelegateTest;
     import asunit.framework.NestedSuiteIteratorTest;
     import asunit.framework.ProceedOnEventTest;
+    import asunit.framework.ResultObserverTest;
     import asunit.framework.ResultTest;
     import asunit.framework.RunnerFactoryTest;
     import asunit.framework.SuiteIteratorTest;
@@ -27,11 +27,14 @@ package {
     import asunit.framework.TestIteratorSingleMethodTest;
     import asunit.framework.VisualTestCaseTest;
     import asunit.printers.TextPrinterTest;
+    import asunit.printers.XMLPrinterTest;
+    import asunit.printers.FlashBuilderPrinterTest;
     import asunit.runners.LegacyRunnerTest;
     import asunit.runners.SuiteRunnerTest;
     import asunit.runners.TestRunnerAsyncMethodTest;
     import asunit.runners.TestRunnerErrorMethodTest;
     import asunit.runners.TestRunnerExpectsErrorTest;
+    import asunit.runners.TestRunnerExpectsErrorWithMessageTest;
     import asunit.runners.TestRunnerIgnoredMethodTest;
     import asunit.runners.TestRunnerTest;
     import asunit.util.ArrayIteratorTest;
@@ -43,13 +46,13 @@ package {
         public var asunit_framework_AssertEqualsArraysIgnoringOrderTest:asunit.framework.AssertEqualsArraysIgnoringOrderTest;
         public var asunit_framework_AssertEqualsArraysTest:asunit.framework.AssertEqualsArraysTest;
         public var asunit_framework_AssertTest:asunit.framework.AssertTest;
+        public var asunit_framework_AssertThrowsWithMessageTest:asunit.framework.AssertThrowsWithMessageTest;
         public var asunit_framework_AssertThrowsTest:asunit.framework.AssertThrowsTest;
         public var asunit_framework_AsyncMethodTest:asunit.framework.AsyncMethodTest;
         public var asunit_framework_AsyncTest:asunit.framework.AsyncTest;
-        public var asunit_framework_CallbackBridgeTest:asunit.framework.CallbackBridgeTest;
-        public var asunit_framework_InjectionDelegateTest:asunit.framework.InjectionDelegateTest;
         public var asunit_framework_NestedSuiteIteratorTest:asunit.framework.NestedSuiteIteratorTest;
         public var asunit_framework_ProceedOnEventTest:asunit.framework.ProceedOnEventTest;
+        public var asunit_framework_ResultObserverTest:asunit.framework.ResultObserverTest;
         public var asunit_framework_ResultTest:asunit.framework.ResultTest;
         public var asunit_framework_RunnerFactoryTest:asunit.framework.RunnerFactoryTest;
         public var asunit_framework_SuiteIteratorTest:asunit.framework.SuiteIteratorTest;
@@ -60,11 +63,13 @@ package {
         public var asunit_framework_TestIteratorSingleMethodTest:asunit.framework.TestIteratorSingleMethodTest;
         public var asunit_framework_VisualTestCaseTest:asunit.framework.VisualTestCaseTest;
         public var asunit_printers_TextPrinterTest:asunit.printers.TextPrinterTest;
+        public var asunit_printers_FlashBuilderPrinterTest:asunit.printers.FlashBuilderPrinterTest;
         public var asunit_runners_LegacyRunnerTest:asunit.runners.LegacyRunnerTest;
         public var asunit_runners_SuiteRunnerTest:asunit.runners.SuiteRunnerTest;
         public var asunit_runners_TestRunnerAsyncMethodTest:asunit.runners.TestRunnerAsyncMethodTest;
         public var asunit_runners_TestRunnerErrorMethodTest:asunit.runners.TestRunnerErrorMethodTest;
         public var asunit_runners_TestRunnerExpectsErrorTest:asunit.runners.TestRunnerExpectsErrorTest;
+        public var asunit_runners_TestRunnerExpectsErrorWithMessageTest:asunit.runners.TestRunnerExpectsErrorWithMessageTest;
         public var asunit_runners_TestRunnerIgnoredMethodTest:asunit.runners.TestRunnerIgnoredMethodTest;
         public var asunit_runners_TestRunnerTest:asunit.runners.TestRunnerTest;
         public var asunit_util_ArrayIteratorTest:asunit.util.ArrayIteratorTest;

data/test/AsUnitCIRunner.as

@@ -0,0 +1,18 @@
+package {
+
+	import asunit.core.FlexUnitCICore;
+	import asunit.core.TextCore;
+
+	import flash.display.MovieClip;
+
+	[SWF(width="1024", height="640", backgroundColor="#000000", frameRate="61")]
+	public class AsUnitCIRunner extends MovieClip {
+	    
+        private var core:TextCore;
+
+        public function AsUnitCIRunner() {
+            core = new FlexUnitCICore();
+            core.start(AllTests, null, this);
+        }
+    }
+}

data/test/AsUnitRunner.as

@@ -3,12 +3,14 @@ package {
     import asunit.core.TextCore;
     import flash.display.MovieClip;
 
+	[SWF(width="1024", height="640", backgroundColor="#000000", frameRate="61")]
 	public class AsUnitRunner extends MovieClip {
 	    
         private var core:TextCore;
 
         public function AsUnitRunner() {
             core = new TextCore();
+			core.textPrinter.hideLocalPaths = true;
             core.start(AllTests, null, this);
         }
     }

data/test/asunit/core/AsUnitCoreTest.as

@@ -1,12 +1,11 @@
 package asunit.core {
     
     import asunit.asserts.*;
-    import asunit.framework.CallbackBridge;
     import asunit.framework.IAsync;
     import asunit.framework.IResult;
     import asunit.framework.Result;
     import asunit.printers.TextPrinter;
-    import asunit.support.CustomTestRunner;
+    import asunit.support.CustomSuiteRunner;
     import asunit.support.SuiteWithCustomRunner;
     import asunit.support.SuiteWithOneCustomChildSuite;
     import asunit.support.SucceedAssertTrue;
@@ -19,15 +18,16 @@ package asunit.core {
         [Inject]
         public var async:IAsync;
 
-        [Inject]
-        public var core:AsUnitCore;
+		private var core:AsUnitCore;
 
-        [Inject]
-        public var context:Sprite;
+		[Before]
+		public function setUp():void {
+			core = new AsUnitCore();
+		}
 
         [After]
         public function cleanUpStatics():void {
-            CustomTestRunner.runCalledCount = 0;
+            CustomSuiteRunner.runCalledCount = 0;
         }
 
         [Test]
@@ -39,18 +39,36 @@ package asunit.core {
         public function startShouldWork():void {
             core.start(SucceedAssertTrue);
         }
+		
+		[Test]
+		public function shouldDispatchSelfAsCurrentTarget():void {
+			var handlerCalled:Boolean = false;
+			var handler:Function = function(event:Event):void {
+				assertSame("currentTarget should be the core", core, event.currentTarget);
+				handlerCalled = true;
+				core.removeEventListener(event.type, arguments.callee);
+			}
+
+			var eventType:String = "foo";
+			core.addEventListener(eventType, handler);
+			// when
+			core.dispatchEvent(new Event(eventType));
+			// then
+			assertTrue("handler called", handlerCalled);
+		}		
 
         [Test]
         public function setVisualContextShouldWork():void {
+			var context:Sprite = new Sprite();
             core.visualContext = context;
-            assertEquals(context, core.visualContext);
+            assertSame(context, core.visualContext);
         }
 
         [Test]
         public function textPrinterShouldWork():void {
             var printer:TextPrinter = new TextPrinter();
             printer.traceOnComplete = false;
-            core.addObserver(printer);
+            core.addListener(printer);
 
             // Wait for the complete event:
             var handler:Function = function(event:Event):void {
@@ -66,11 +84,11 @@ package asunit.core {
         private function verifyRunWithOnASuite(Suite:Class, testCaseCount:int, testMethodCount:int):void {
 
             var handler:Function = function(event:Event):void {
-                var message:String = "CustomRunner.run was NOT called with correct count";
+                var message:String = "CustomSuiteRunner.run was NOT called with correct count";
                 // This is the number of Tests that will used the custom Runner:
-                assertEquals(message, testCaseCount, CustomTestRunner.runCalledCount);
+                assertEquals(message, testCaseCount, CustomSuiteRunner.runCalledCount);
                 // This is the number of test methods:
-                assertEquals("Total Test Count", testMethodCount, core.bridge.runCount);
+                assertEquals("Total Test Count", testMethodCount, core.result.runCount);
             }
 
             core.addEventListener(Event.COMPLETE, async.add(handler, 200));
@@ -78,9 +96,9 @@ package asunit.core {
         }
 
         [Test]
-        public function shouldAssignRunWithUsingOuterSuite():void {
-            // This will work b/c the RunWith is on the outer Suite:
-            var testCaseCount:int = 2;
+        public function shouldUseRunWithOnlyOnItsSuiteNotChildren():void {
+            // TheRunWith is on the outer Suite:
+            var testCaseCount:int = 1;
             var testMethodCount:int = 4;
             verifyRunWithOnASuite(SuiteWithCustomRunner, testCaseCount, testMethodCount);
         }

data/test/asunit/framework/AssertEqualsArraysIgnoringOrderTest.as

@@ -3,6 +3,7 @@
     import asunit.errors.AssertionFailedError;
     import asunit.framework.TestCase;
     import asunit.framework.Assert;
+    import flash.display.Sprite;
     
     /**
      * Tests assertEqualsArraysIgnoringOrder
@@ -84,5 +85,18 @@
         public function testArrayDifferentLength2():void {
             assertAssertionFailed(Assert.assertEqualsArraysIgnoringOrder, ["abc", "def"], ["abc", "def", "ghi"]);
         }
+
+		public function testArrayWithRepeatedItems():void {
+			var spr1:Sprite = new Sprite();
+			var spr2:Sprite = new Sprite();
+			var spr3:Sprite = new Sprite();
+			
+			var controlArray:Array = [spr1, spr2, spr3, spr1];
+			var matchingArray:Array = [spr1, spr2, spr1, spr3];
+			var nonMatchingArray:Array = [spr1, spr2, spr3, spr2];
+			
+			assertEqualsArraysIgnoringOrder('these arrays should match', controlArray, matchingArray);
+			assertAssertionFailed(Assert.assertEqualsArraysIgnoringOrder, controlArray, nonMatchingArray);
+		}
     }
 }

data/test/asunit/framework/AssertThrowsWithMessageTest.as

@@ -0,0 +1,50 @@
+package asunit.framework {
+
+    import asunit.asserts.*;
+	import asunit.errors.AssertionFailedError;
+
+    public class AssertThrowsWithMessageTest {
+
+        [Test]
+		public function throwingExpectedErrorShouldPass():void {
+			assertThrowsWithMessage(ArgumentError, "foo", function():void { throw new ArgumentError("foo"); } );
+		}
+		
+        [Test]
+		public function throwingUnexpectedErrorShouldFail():void {
+			try {
+				assertThrowsWithMessage(ArgumentError, "wrong error type", function():void { throw new Error("wrong error type"); } );
+			}
+			catch (e:AssertionFailedError) {
+				assertEquals("expected error type:<ArgumentError> but was:<Error>", e.message)
+				return;
+			}
+			fail('failed assertThrowsWithMessage() should have thrown AssertionFailedError');
+		}
+		
+        [Test]
+		public function throwingNoErrorShouldFailWithMessage():void {
+			try {
+				assertThrowsWithMessage(ArgumentError, "foo", function():void { } );
+			}
+			catch (e:AssertionFailedError) {
+				assertEquals("expected error type:<ArgumentError> with message:<foo> but none was thrown.", e.message)
+				return;
+			}
+			fail('failed assertThrowsWithMessage() should have thrown AssertionFailedError');
+		}
+
+        [Test]
+		public function throwingErrorWithUnexpectedMessageShouldFail():void {
+			try {
+				assertThrowsWithMessage(Error, "foo", function():void { throw new Error("bar"); } );
+			}
+			catch (e:AssertionFailedError) {
+				assertEquals("expected error message:<foo> but was:<bar>", e.message)
+				return;
+			}
+			fail('failed assertThrowsWithMessage() should have thrown AssertionFailedError');
+		}
+	}
+}
+

data/test/asunit/framework/AsyncTest.as

@@ -7,7 +7,6 @@
     import asunit.framework.TestCase;
 
     import flash.events.Event;
-    import flash.events.EventDispatcher;
     import flash.utils.setTimeout;
 
     public class AsyncTest {
@@ -15,9 +14,6 @@
         [Inject]
         public var async:IAsync;
 
-        [Inject]
-        public var dispatcher:EventDispatcher;
-
         private var orphanAsync:IAsync;
         private var command:TimeoutCommand;
 

data/test/asunit/framework/ProceedOnEventTest.as

@@ -15,8 +15,6 @@ package asunit.framework {
 
         [Inject]
         public var async:IAsync;
-
-        [Inject]
         public var dispatcher:EventDispatcher;
 
         private var orphanAsync:IAsync;
@@ -26,6 +24,7 @@ package asunit.framework {
         [Before]
         public function setUp():void {
             orphanAsync = new Async();
+			dispatcher = new EventDispatcher();
         }
 
         [After]

data/test/asunit/framework/ResultObserverTest.as

@@ -0,0 +1,61 @@
+package asunit.framework {
+
+    import asunit.asserts.*;
+    import asunit.support.FakeObserver;
+    import asunit.framework.Result;
+
+	public class ResultObserverTest {
+
+        private var result:Result;
+
+        private var listener:FakeObserver;
+
+        [Before]
+        public function createObserver():void {
+            listener = new FakeObserver();
+			result = new Result();
+            result.addListener(listener);
+        }
+
+        [After]
+        public function destroyObserver():void {
+            listener = null;
+        }
+
+        [Test]
+		public function canInstantiate():void {
+			assertTrue("instance is Result", result is Result);
+		}
+
+        [Test]
+        public function addedListenerReceivesOnRunStarted():void {
+            result.onRunStarted();
+            assertTrue(listener.onRunStartedCalled);
+        }
+
+        [Test]
+        public function addedListenerReceivesOnTestStarted():void {
+            result.onTestStarted(null);
+            assertTrue(listener.onTestStartedCalled);
+        }
+
+		[Test]
+		public function shouldHaveDefaultRunCount():void
+		{
+			assertEquals(0, result.runCount);
+		}
+		
+		[Test]
+		public function shouldHaveCumulativeRunCount():void
+		{
+			result.onTestStarted(null);
+			result.onTestSuccess(null);
+			result.onTestCompleted(null);
+			result.onTestStarted(null);
+			result.onTestSuccess(null);
+			result.onTestCompleted(null);
+			assertEquals(2, result.runCount);
+		}
+		
+	}
+}

data/test/asunit/framework/RunnerFactoryTest.as

@@ -14,9 +14,13 @@ package asunit.framework {
 
 	public class RunnerFactoryTest {
 
-        [Inject]
-        public var factory:RunnerFactory;
-
+        private var factory:IRunnerFactory;
+	
+		[Before]
+		public function before():void {
+			factory = new RunnerFactory();
+		}
+		
         [Test]
         public function shouldCreateDefaultRunner():void {
             var result:IRunner = factory.runnerFor(SucceedAssertTrue);
@@ -29,12 +33,6 @@ package asunit.framework {
             assertTrue(result is SuiteRunner);
         }
 
-        [Test]
-        public function shouldAssignFactoryOnCreation():void {
-            var result:IRunner = factory.runnerFor(SingleSuccessSuite);
-            assertSame(factory, result.factory);
-        }
-
         [Test(expects="asunit.errors.UsageError")]
 		public function shouldFailWhenGivenANonTestOrSuite():void {
             factory.runnerFor(Sprite);

data/test/asunit/framework/VisualTestCaseTest.as

@@ -7,37 +7,13 @@ package asunit.framework {
     public class VisualTestCaseTest {
 
         [Inject]
-        public var sprite:Sprite;
+        public var context:Sprite;
 
         [Test]
         public function instantiated():void {
-            assertTrue(sprite is Sprite);
-        }
-        
-        [Test]
-        public function testSize():void {
-            assertTrue(sprite.width == 0);
-            assertTrue(sprite.height == 0);
+            assertTrue(context is Sprite);
         }
 
-        [Test]
-        public function testDrawnSize():void {
-            sprite.x = 110;
-            sprite.y = 115;
-            sprite.graphics.beginFill(0xFF0000);
-            sprite.graphics.drawRect(0, 0, 100, 200);
-            
-            assertEquals(100, sprite.width);
-            assertEquals(200, sprite.height);
-            assertEquals(110, sprite.x);
-            assertEquals(115, sprite.y);
-        }
-
-        [Test]
-        public function testSecondSize():void {
-            assertTrue(sprite.width == 0);
-            assertTrue(sprite.height == 0);
-        }
     }
 }
 

data/test/asunit/printers/FlashBuilderPrinterTest.as

@@ -0,0 +1,18 @@
+
+package asunit.printers {
+    
+    import asunit.asserts.*;
+    import asunit.framework.TestCase;
+
+    public class FlashBuilderPrinterTest extends TestCase {
+
+        public function FlashBuilderPrinterTest(method:String=null) {
+            super(method);
+        }
+
+        private function testInstantiable():void {
+            var printer:FlashBuilderPrinter = new FlashBuilderPrinter();
+        }
+    }
+}
+