asunit4 4.2.1.pre

data/test/asunit/framework/InjectionDelegateTest.as

@@ -0,0 +1,79 @@
+package asunit.framework {
+
+	import asunit.asserts.*;
+	
+	public class InjectionDelegateTest  {
+		
+		[Inject]
+		public var injector:InjectionDelegate;
+		
+		[Test]
+		public function testInstantiated():void {
+			assertTrue("instance is InjectionDelegate", injector is InjectionDelegate);
+		}
+
+		[Test]
+		public function testUpdateInjectionPoints():void {
+			var addict:Addict = new Addict();
+			injector.updateInjectionPoints(addict);
+			assertNotNull(addict.array);
+		}
+		
+		[Test]
+		public function injectedInstancesShouldBeCached():void {			
+			var addict:Addict = new Addict();			
+			var addict2:Addict = new Addict();
+			
+			injector.updateInjectionPoints(addict);			
+			injector.updateInjectionPoints(addict2);			
+			
+			assertSame(addict.array, addict2.array);
+			
+		}
+		
+		[Test(expects="asunit.errors.UsageError")]
+		public function shouldThrowUsageErrorOnInvalidAddict():void
+		{
+			var invalidAddict:AddictWithNoInjections = new AddictWithNoInjections();
+			injector.updateInjectionPoints(invalidAddict, InjectionDelegate.THROW_ERROR_ON_MISSING_INJECTION_POINT);
+		}
+		
+		[Test(expects="asunit.errors.UsageError")]
+		public function shouldThrowUsageErrorIfNoVariableInjectionsFound():void
+		{
+			var invalidAddict:AddictWithOnlyMethodInjection = new AddictWithOnlyMethodInjection();
+			injector.updateInjectionPoints(invalidAddict, InjectionDelegate.THROW_ERROR_ON_MISSING_INJECTION_POINT);
+		}
+		
+		[Test]
+		public function shouldNotThrowUsageErrorOnInvalidAddict():void
+		{
+			var invalidAddict:AddictWithNoInjections = new AddictWithNoInjections();
+			injector.updateInjectionPoints(invalidAddict);
+		}
+		
+		[Test]
+		public function shouldNotThrowUsageErrorIfNoVariableInjectionsFound():void
+		{
+			var invalidAddict:AddictWithOnlyMethodInjection = new AddictWithOnlyMethodInjection();
+			injector.updateInjectionPoints(invalidAddict);
+		}
+			
+	}
+}
+
+//An addict that has no inject annotations
+class AddictWithNoInjections {}
+
+class AddictWithOnlyMethodInjection {
+	[Inject]
+	public function pleaseInjectMe(array:Array):void{};
+}
+
+class Addict {
+	[Inject]
+	public var array:Array;
+	
+	[Inject]
+	public function pleaseInjectMe(array:Array):void{};
+}

data/test/asunit/framework/MockData.xml

@@ -0,0 +1,8 @@
+<books>
+    <book publisher="Addison-Wesley" name="Design Patterns" />
+    <book publisher="Addison-Wesley" name="The Pragmatic Programmer" />
+    <book publisher="Addison-Wesley" name="Test Driven Development" />
+    <book publisher="Addison-Wesley" name="Refactoring to Patterns" />
+    <book publisher="O'Reilly Media" name="The Cathedral &amp; the Bazaar" />
+    <book publisher="O'Reilly Media" name="Unit Test Frameworks" />
+</books>

data/test/asunit/framework/NestedSuiteIteratorTest.as

@@ -0,0 +1,59 @@
+package asunit.framework {
+
+	import asunit.framework.TestCase;
+
+	import asunit.support.FailAssertEquals;
+	import asunit.support.FailAssertTrue;
+	import asunit.support.SucceedAssertTrue;
+	import asunit.support.SuiteOfTwoSuites;
+
+	public class NestedSuiteIteratorTest extends TestCase {
+		private var iterator:SuiteIterator;
+		private var suiteClass:Class;
+		
+		public function NestedSuiteIteratorTest(testMethod:String = null) {
+			super(testMethod);
+		}
+
+		protected override function setUp():void {
+			suiteClass = SuiteOfTwoSuites;
+		}
+
+		protected override function tearDown():void {
+			iterator = null;
+		}
+
+		public function test_length_from_SuiteIterator():void {
+            var iterator:SuiteIterator = new SuiteIterator(suiteClass);
+			assertEquals(3, iterator.length);
+		}
+
+		public function test_isSuite_false_with_test_class():void {
+            var iterator:SuiteIterator = new SuiteIterator(SucceedAssertTrue);
+			assertEquals(1, iterator.length);
+		}
+		
+		public function test_getTestClasses_of_suite_class():void {
+            var iterator:SuiteIterator = new SuiteIterator(suiteClass);
+			assertEquals(3, iterator.length);
+            assertSame(FailAssertEquals, iterator.next());
+            assertSame(FailAssertTrue, iterator.next());
+            assertSame(SucceedAssertTrue, iterator.next());
+		}
+		
+		public function test_iterator_for_suite_class_with_2_nested_suites_hasNext():void {
+			iterator = new SuiteIterator(suiteClass);
+			assertTrue(iterator.hasNext());
+		}
+		
+		public function test_iterator_next():void {
+			iterator = new SuiteIterator(suiteClass);
+			
+			assertSame(FailAssertEquals,	iterator.next());
+			assertSame(FailAssertTrue, 		iterator.next());
+			assertSame(SucceedAssertTrue,	iterator.next());
+			
+			assertFalse('no methods left in iterator', iterator.hasNext());
+		}
+	}
+}

data/test/asunit/framework/ProceedOnEventTest.as

@@ -0,0 +1,109 @@
+package asunit.framework {
+
+    import asunit.asserts.*;
+    import asunit.events.TimeoutCommandEvent;
+    import asunit.framework.ErrorEvent;
+    import asunit.framework.TestCase;
+
+    import flash.events.Event;
+    import flash.events.EventDispatcher;
+    import flash.events.IEventDispatcher;
+    import flash.utils.clearTimeout;
+    import flash.utils.setTimeout;
+
+    public class ProceedOnEventTest {
+
+        [Inject]
+        public var async:IAsync;
+
+        [Inject]
+        public var dispatcher:EventDispatcher;
+
+        private var orphanAsync:IAsync;
+        private var command:TimeoutCommand;
+        private var timeoutID:int = -1;
+
+        [Before]
+        public function setUp():void {
+            orphanAsync = new Async();
+        }
+
+        [After]
+        public function tearDown():void {
+            command     = null;
+            orphanAsync = null;
+            timeoutID   = -1;
+        }
+
+        protected function foo():void { }
+        
+        [Test]
+        public function proceedOnEventShouldDispatchCorrectEventAndClearPendingCommands():void {
+            orphanAsync.proceedOnEvent(dispatcher, Event.COMPLETE, 10);
+            
+            var commands:Array = orphanAsync.getPending();
+            assertEquals("one pending command for test after proceedOnEvent()", 1, commands.length);
+            
+            // send the correct event synchronously
+            dispatchCompleteEvent();
+            
+            var message:String = "No pending commands for test after correct Event dispatched.";
+            assertEquals(message, 0, orphanAsync.getPending().length);
+        }
+        
+        protected function dispatchCompleteEvent():void {
+            dispatcher.dispatchEvent(new Event(Event.COMPLETE));
+        }
+        
+        [Test]
+        public function proceedOnEventShouldTimeoutAppropriately():void {
+
+            // Grab a reference to the Dispatcher so that we still have
+            // it after the test run (Fixing uncaught RTE null pointer exception)
+            var source:IEventDispatcher = dispatcher;
+
+            // This is the initial setup, we want test execution to pause
+            // for 1ms OR until the COMPLETE event fires:
+            orphanAsync.proceedOnEvent(source, Event.COMPLETE, 1);
+            
+            // Get the Command so that we can just wait for the TIMED_OUT event:
+            var commands:Array = orphanAsync.getPending();
+            var command:TimeoutCommand = commands[0];
+            command.addEventListener(TimeoutCommandEvent.TIMED_OUT, async.add(onAsyncMethodFailed, 500));
+            
+            // send the correct event too slowly
+            timeoutID = setTimeout(function():void {
+                source.dispatchEvent(new Event(Event.COMPLETE));
+            }, 10);
+        }
+        
+        protected function onAsyncMethodFailed(event:TimeoutCommandEvent):void {
+            assertEquals("event type", TimeoutCommandEvent.TIMED_OUT, event.type);
+            clearTimeout(timeoutID);
+        }
+        
+        [Test]
+        public function proceedOnEventShouldSendCALLEDEventAsExpected():void {
+            orphanAsync.proceedOnEvent(dispatcher, Event.COMPLETE, 10);
+            
+            command = orphanAsync.getPending()[0];
+            
+            // Use AsUnit 3's orphanAsync.add() to verify onAsyncMethodCalled is called.
+            command.addEventListener(TimeoutCommandEvent.CALLED, async.add(onAsyncMethodCalled));
+            
+            // If all goes well, the ErrorEvent won't be dispatched.
+            command.addEventListener(ErrorEvent.ERROR, failIfCalled);
+            
+            // send the correct event faster than orphanAsync.proceedOnEvent duration
+            setTimeout(dispatchCompleteEvent, 0);
+        }
+        
+        protected function onAsyncMethodCalled(e:Event):void {
+            assertEquals("event type", TimeoutCommandEvent.CALLED, e.type);
+        }
+        
+        protected function failIfCalled(e:Event = null):void {
+            fail("ProceedOnEventTest: This function should not have been called");
+        }
+    }
+}

data/test/asunit/framework/ResultTest.as

@@ -0,0 +1,92 @@
+package asunit.framework {
+
+    import asunit.framework.TestCase;
+    import asunit.framework.ITestSuccess;
+    import asunit.framework.TestSuccess;
+    import asunit.framework.ITestFailure;
+    import asunit.framework.TestFailure;
+    import asunit.framework.IResult;
+    import asunit.framework.Result;
+
+	public class ResultTest extends TestCase {
+
+        private var test:*;
+        private var success:ITestSuccess;
+        private var failure:ITestFailure;
+        private var testResult:IResult;
+
+		public function ResultTest(methodName:String=null) {
+			super(methodName)
+		}
+
+		override protected function setUp():void {
+			super.setUp();
+            failure    = new TestFailure(test, 'testSomethingThatFails', new Error('Fake Failure'));
+            success    = new TestSuccess(test, 'testSomethingThatSucceeds');
+            test       = new TestCase();
+            testResult = new Result();
+		}
+
+		override protected function tearDown():void {
+			super.tearDown();
+            failure    = null;
+            success    = null;
+            test       = null;
+            testResult = null;
+		}
+
+        private function runSingleSuccess():void {
+            testResult.onRunStarted();
+            testResult.onTestStarted(test);
+            testResult.onTestSuccess(success);
+            testResult.onTestCompleted(test);
+            testResult.onRunCompleted(null);
+        }
+
+        private function runSingleFailure():void {
+            testResult.onRunStarted();
+            testResult.onTestStarted(test);
+            testResult.onTestFailure(failure);
+            testResult.onTestCompleted(test);
+            testResult.onRunCompleted(testResult);
+        }
+
+        private function runSingleIgnore():void {
+            testResult.onRunStarted();
+            testResult.onTestStarted(test);
+            testResult.onTestIgnored(null);
+            testResult.onTestCompleted(test);
+            testResult.onRunCompleted(testResult);
+        }
+
+		public function testRunWithSingleSuccess():void {
+            assertFalse("before test run", testResult.wasSuccessful);
+            runSingleSuccess();
+            assertFalse("failure encountered", testResult.failureEncountered);
+            assertTrue("after test complete", testResult.wasSuccessful);
+			assertEquals(1, testResult.runCount);
+		}
+
+        public function testRunWithSingleFailure():void {
+            runSingleFailure();
+            assertTrue("failure encountered", testResult.failureEncountered);
+            assertFalse("after test complete", testResult.wasSuccessful);
+			assertEquals(1, testResult.runCount);
+        }
+
+        public function testRunWithSingleError():void {
+            runSingleFailure();
+            assertTrue("failure encountered", testResult.failureEncountered);
+            assertFalse("after test complete", testResult.wasSuccessful);
+			assertEquals(1, testResult.runCount);
+        }
+
+        public function testRunCountWithSingleIgnore():void {
+            runSingleIgnore();
+            assertFalse("failure encountered", testResult.failureEncountered);
+            assertTrue("after test complete", testResult.wasSuccessful);
+			assertEquals(0, testResult.runCount);
+        }
+	}
+}
+

data/test/asunit/framework/RunnerFactoryTest.as

@@ -0,0 +1,54 @@
+package asunit.framework {
+
+	import asunit.asserts.*;
+    import asunit.errors.UsageError;
+    import asunit.framework.IRunner;
+    import asunit.runners.TestRunner;
+    import asunit.runners.SuiteRunner;
+    import asunit.support.RunWithButNoType;
+    import asunit.support.RunWithSuiteButNoType;
+    import asunit.support.SingleSuccessSuite;
+    import asunit.support.SucceedAssertTrue;
+
+    import flash.display.Sprite;
+
+	public class RunnerFactoryTest {
+
+        [Inject]
+        public var factory:RunnerFactory;
+
+        [Test]
+        public function shouldCreateDefaultRunner():void {
+            var result:IRunner = factory.runnerFor(SucceedAssertTrue);
+            assertTrue(result is TestRunner);
+        }
+
+        [Test]
+        public function shouldCreateSuiteRunner():void {
+            var result:IRunner = factory.runnerFor(SingleSuccessSuite);
+            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);
+		}
+
+        [Test(expects="asunit.errors.UsageError")]
+        public function runWithOnTestWithNoTypeDeclaration():void {
+            factory.runnerFor(RunWithButNoType);
+        }
+
+        [Test(expects="asunit.errors.UsageError")]
+        public function runWithOnSuiteWithNoTypeDeclaration():void {
+            factory.runnerFor(RunWithSuiteButNoType);
+        }
+	}
+}
+

data/test/asunit/framework/SuiteIteratorTest.as

@@ -0,0 +1,67 @@
+package asunit.framework {
+
+	import asunit.framework.TestCase;
+    import asunit.util.Iterator;
+
+	import asunit.support.DoubleFailSuite;
+	import asunit.support.FailAssertEquals;
+	import asunit.support.FailAssertTrue;
+
+	public class SuiteIteratorTest extends TestCase {
+
+		public function SuiteIteratorTest(testMethod:String = null) {
+			super(testMethod);
+		}
+
+		public function test_countTestClasses_of_suite_class():void {
+            var iterator:Iterator = new SuiteIterator(DoubleFailSuite);
+			assertEquals(2, iterator.length);
+		}
+		
+		public function test_accepts_non_suite_class():void {
+            var iterator:Iterator = new SuiteIterator(Date);
+			assertEquals(0, iterator.length);
+		}
+		
+		public function test_accepts_test_class():void {
+            var iterator:Iterator = new SuiteIterator(FailAssertEquals);
+			assertEquals(1, iterator.length);
+		}
+		
+		public function test_getTestClasses_of_suite_class():void {
+            var iterator:Iterator = new SuiteIterator(DoubleFailSuite);
+			
+			assertEquals(2, iterator.length);
+			// In case the ordering is random, check that the array contains the class somewhere.
+            assertSame(FailAssertEquals, iterator.next());
+            assertSame(FailAssertTrue, iterator.next());
+		}
+		
+		public function test_getTestClasses_on_test_class_should_return_array_with_test():void {
+            var iterator:Iterator = new SuiteIterator(FailAssertTrue);
+			
+			assertEquals(1, iterator.length);
+			assertSame(FailAssertTrue, iterator.next());
+		}
+		
+		public function test_iterator_for_non_suite_class_yields_hasNext_false():void {
+			var iterator:Iterator = new SuiteIterator(Date);
+			assertFalse(iterator.hasNext());
+		}
+		
+		public function test_iterator_for_suite_class_with_2_tests_hasNext():void {
+			var iterator:Iterator = new SuiteIterator(DoubleFailSuite);
+			assertTrue(iterator.hasNext());
+		}
+		
+		public function test_iterator_next():void {
+			var iterator:Iterator = new SuiteIterator(DoubleFailSuite);
+			
+			assertSame(FailAssertEquals,	iterator.next());
+			assertSame(FailAssertTrue, 		iterator.next());
+			
+			assertFalse('no methods left in iterator', iterator.hasNext());
+		}
+	}
+}
+

data/test/asunit/framework/TestCaseMock.as

@@ -0,0 +1,24 @@
+package asunit.framework {
+
+    public class TestCaseMock extends TestCase {
+        public var testMethod1Run:Boolean;
+        public var testMethod2Run:Boolean;
+        public var testMethod3Run:Boolean;
+        
+        public function TestCaseMock(methodName:String = null) {
+            super(methodName);
+        }
+        
+        public function testMethod1():void {
+            testMethod1Run = true;
+        }
+        
+        public function testMethod2():void {
+            testMethod2Run = true;
+        }
+        
+        public function testMethod3():void {
+            testMethod3Run = true;
+        }
+    }
+}

data/test/asunit/framework/TestIteratorIgnoredMethodTest.as

@@ -0,0 +1,62 @@
+package asunit.framework {
+
+	import asunit.framework.TestCase;
+    import asunit.util.Iterator;
+
+	import asunit.support.IgnoredMethod;
+
+	public class TestIteratorIgnoredMethodTest extends TestCase {
+
+		private var ignoredTest:IgnoredMethod;
+		private var iterator:Iterator;
+
+		public function TestIteratorIgnoredMethodTest(testMethod:String = null) {
+			super(testMethod);
+		}
+
+		protected override function setUp():void {
+            super.setUp();
+			ignoredTest = new IgnoredMethod();
+		}
+
+		protected override function tearDown():void {
+            super.tearDown();
+			iterator = null;
+		}
+
+		public function test_iterator_for_test_with_one_ignored_test_method_hasNext_true():void {
+			iterator = new TestIterator(ignoredTest);
+			assertTrue(iterator.hasNext());
+		}
+
+        public function test_getTestMethods_should_not_include_ignored_test():void {
+            var iterator:Iterator = new TestIterator(ignoredTest);
+            assertEquals(3, iterator.length);
+        }
+		
+		public function test_getTestMethods_should_return_ignored_test():void {
+			var iterator:Iterator = new TestIterator(ignoredTest).ignoredIterator;
+			
+			assertEquals(1, iterator.length);
+            var method:Method = iterator.next();
+			assertEquals('should_be_ignored', method.name);
+			assertTrue('method.ignore', method.ignore);
+		}
+	}
+}
+
+/*
+<factory type="asunit.support::IgnoredMethod">
+  <extendsClass type="Object"/>
+  <method name="runAfter" declaredBy="asunit.support::IgnoredMethod" returnType="void">
+    <metadata name="After"/>
+  </method>
+  <method name="should_be_ignored" declaredBy="asunit.support::IgnoredMethod" returnType="void">
+    <metadata name="Test"/>
+    <metadata name="Ignore"/>
+  </method>
+  <method name="runBefore" declaredBy="asunit.support::IgnoredMethod" returnType="void">
+    <metadata name="Before"/>
+  </method>
+</factory>
+*/

data/test/asunit/framework/TestIteratorMethodByNameTest.as

@@ -0,0 +1,50 @@
+package asunit.framework {
+
+	import asunit.framework.TestCase;
+
+	import asunit.support.MultiMethod;
+
+	public class TestIteratorMethodByNameTest extends TestCase {
+
+		private var iterator:TestIterator;
+		private var multiTest:MultiMethod;
+
+		public function TestIteratorMethodByNameTest(testMethod:String = null) {
+			super(testMethod);
+		}
+
+		protected override function setUp():void {
+			multiTest = new MultiMethod();
+		}
+
+		protected override function tearDown():void {
+			iterator = null;
+			multiTest = null;
+		}
+		
+		public function test_iterator_next_with_test_method_by_name():void {
+			iterator = new TestIterator(multiTest, 'stage_is_null_by_default');
+			checkAllNextCalls(iterator);
+		}
+		
+		private function checkAllNextCalls(iterator:TestIterator):void {
+			assertSame('runBeforeClass1', 				iterator.next().name);
+			assertSame('runBeforeClass2', 				iterator.next().name);
+			
+			assertSame('runBefore1', 					iterator.next().name);
+			assertSame('runBefore2', 					iterator.next().name);
+			assertSame('stage_is_null_by_default', 		iterator.next().name);
+
+            // NOTE: When a method name is provided, the teardown should
+            // not occur.
+			//assertSame('runAfter1', 					iterator.next().name);
+			//assertSame('runAfter2', 					iterator.next().name);
+			
+			//assertSame('runAfterClass1', 				iterator.next().name);
+			//assertSame('runAfterClass2', 				iterator.next().name);
+			
+			assertFalse('no methods left in iterator',	iterator.hasNext());
+		}
+		
+	}
+}