asunit4 4.2.1.pre

data/test/asunit/runners/TestRunnerErrorMethodTest.as

@@ -0,0 +1,56 @@
+package asunit.runners {
+
+	import asunit.framework.TestCase;
+
+	import asunit.framework.IResult;
+	import asunit.framework.Result;
+	import asunit.framework.TestFailure;
+	import asunit.support.ErrorInMethod;
+
+	import flash.events.Event;
+
+	public class TestRunnerErrorMethodTest extends TestCase {
+
+		private var runner:TestRunner;
+		private var testWithError:ErrorInMethod;
+
+		public function TestRunnerErrorMethodTest(testMethod:String = null) {
+			super(testMethod);
+		}
+
+		protected override function setUp():void {
+            super.setUp();
+			runner        = new TestRunner();
+			testWithError = new ErrorInMethod();
+		}
+
+		protected override function tearDown():void {
+            super.tearDown();
+			runner        = null;
+			testWithError = null;
+		}
+
+		public function testInstantiated():void {
+			assertTrue("TestRunner instantiated", runner is TestRunner);
+		}
+		
+		public function test_run_with_errors():void {
+			runner.addEventListener(Event.COMPLETE, addAsync(check_Result_has_one_error, 100));
+			runner.run(ErrorInMethod);
+		}
+		
+		private function check_Result_has_one_error(e:Event):void {
+            var runnerResult:IResult = runner.bridge;
+			assertFalse('runnerResult.wasSuccessful', runnerResult.wasSuccessful);
+			
+			assertEquals('one error in testResult',   1, runnerResult.errorCount);
+			assertEquals('no failures in testResult', 0, runnerResult.failureCount);
+			
+			var failure0:TestFailure = runnerResult.errors[0] as TestFailure;
+			assertTrue('thrownException is correct type', failure0.thrownException is ArgumentError);
+			assertTrue('failedTest is an instance of the test class', failure0.failedTest is ErrorInMethod);
+			assertSame('failedMethod name', 'throw_ArgumentError', failure0.failedMethod);
+		}
+	}
+}
+

data/test/asunit/runners/TestRunnerExpectsErrorTest.as

@@ -0,0 +1,98 @@
+package asunit.runners {
+
+	import asunit.errors.AssertionFailedError;
+	import asunit.framework.TestCase;
+
+	import asunit.framework.IResult;
+	import asunit.framework.Result;
+	import asunit.framework.TestFailure;
+
+	import flash.events.Event;
+
+	public class TestRunnerExpectsErrorTest extends TestCase {
+
+		private var runner:TestRunner;
+		private var successTest:Class;
+		private var throwNothingTest:Class;
+		private var throwWrongErrorTest:Class;
+
+		public function TestRunnerExpectsErrorTest(testMethod:String = null) {
+			super(testMethod);
+		}
+
+		protected override function setUp():void {
+            super.setUp();
+			runner = new TestRunner();
+			successTest = TestExpectsArgumentErrorAndThrowsIt;
+			throwNothingTest = TestExpectsArgumentErrorButThrowsNothing;
+			throwWrongErrorTest = TestExpectsArgumentErrorButThrowsWrongError;
+		}
+
+		protected override function tearDown():void {
+            super.tearDown();
+			runner              = null;
+			successTest         = null;
+			throwNothingTest    = null;
+			throwWrongErrorTest = null;
+		}
+
+		public function test_method_expects_specific_error_and_throws_it_yields_successful_test_result():void {
+			runner.addEventListener(Event.COMPLETE, addAsync(check_Result_has_no_errors, 100));
+			runner.run(successTest);
+		}
+		
+		private function check_Result_has_no_errors(e:Event):void {
+            var runnerResult:IResult = runner.bridge;
+			assertEquals('no errors in testResult',   0, runnerResult.errorCount);
+			assertEquals('no failures in testResult', 0, runnerResult.failureCount);
+		}
+		
+		public function test_method_expects_specific_error_but_nothing_thrown_yields_assertion_failure():void {
+			runner.addEventListener(Event.COMPLETE, addAsync(check_Result_has_one_assertion_failure, 100));
+			runner.run(throwNothingTest);
+		}
+		
+		private function check_Result_has_one_assertion_failure(e:Event):void {
+            var runnerResult:IResult = runner.bridge;
+			assertFalse(runnerResult.wasSuccessful);
+			
+			assertEquals('one failure in testResult', 1, runnerResult.failureCount);
+			assertEquals('no errors in testResult',   0, runnerResult.errorCount);
+			
+			var failure0:TestFailure = runnerResult.failures[0] as TestFailure;
+			assertTrue('thrownException is correct type', failure0.thrownException is AssertionFailedError);
+			assertTrue('failedTest is instance of the test class', failure0.failedTest is throwNothingTest);
+			assertSame('failedMethod name', 'fail_by_throwing_nothing', failure0.failedMethod);
+		}
+		
+		public function test_method_expects_specific_error_but_wrong_one_thrown_yields_assertion_failure():void {
+			runner.addEventListener(Event.COMPLETE, addAsync(check_Result_has_one_assertion_failure, 100));
+			runner.run(throwNothingTest);
+		}
+	}
+}
+
+class TestExpectsArgumentErrorAndThrowsIt {
+	
+	[Test(expects="ArgumentError")]
+	public function throwArgumentError():void {
+		throw new ArgumentError('generated by TestExpectsArgumentError');
+	}
+}
+
+class TestExpectsArgumentErrorButThrowsNothing {
+	
+	[Test(expects="ArgumentError")]
+	public function fail_by_throwing_nothing():void {
+		
+	}
+}
+
+class TestExpectsArgumentErrorButThrowsWrongError {
+	
+	[Test(expects="ArgumentError")]
+	public function fail_by_throwing_wrong_error():void {
+		throw new Error('generated by TestExpectsArgumentErrorButThrowsWrongError');
+	}
+}
+

data/test/asunit/runners/TestRunnerIgnoredMethodTest.as

@@ -0,0 +1,42 @@
+package asunit.runners {
+
+    import asunit.framework.TestCase;
+
+    import asunit.framework.Result;
+    import asunit.support.IgnoredMethod;
+
+    import flash.events.Event;
+
+    public class TestRunnerIgnoredMethodTest extends TestCase {
+
+        private var ignoredTest:Class;
+        private var runner:TestRunner;
+        
+        public function TestRunnerIgnoredMethodTest(testMethod:String = null) {
+            super(testMethod);
+        }
+
+        protected override function setUp():void {
+            super.setUp();
+            ignoredTest  = IgnoredMethod;
+            runner       = new TestRunner();
+        }
+
+        protected override function tearDown():void {
+            super.tearDown();
+            ignoredTest  = null;
+            runner       = null;
+        }
+
+        public function testRunWithIgnoredMethod():void {
+            runner.addEventListener(Event.COMPLETE, addAsync(checkResultHasOneIgnoredMethod, 100));
+            runner.run(ignoredTest);
+        }
+        
+        private function checkResultHasOneIgnoredMethod(e:Event):void {
+            assertFalse('runnerResult.failureEncountered', runner.bridge.failureEncountered);
+            assertEquals('one ignored test in result', 1, runner.bridge.ignoredTests.length);
+        }
+    }
+}
+

data/test/asunit/runners/TestRunnerTest.as

@@ -0,0 +1,171 @@
+package asunit.runners {
+
+    import asunit.asserts.*;
+    import asunit.framework.Async;
+    import asunit.framework.IAsync;
+    import asunit.framework.IRunner;
+    import asunit.framework.ITestFailure;
+    import asunit.framework.Result;
+    import asunit.framework.TestCase;
+    import asunit.framework.TestFailure;
+    import asunit.support.AnnotatedSubClass;
+    import asunit.support.InjectTimeoutOnAsync;
+    import asunit.support.InjectionFailure;
+    import asunit.support.InjectionVerification;
+    import asunit.support.MultiMethod;
+
+    import flash.events.Event;
+    import flash.display.Sprite;
+
+    public class TestRunnerTest {
+
+        [Inject]
+        public var async:IAsync;
+
+        [Inject]
+        public var context:Sprite;
+
+        private var runner:TestRunner;
+        private var test:Class;
+
+        [Before]
+        public function setUp():void {
+            runner = new TestRunner();
+
+            // Yes, statics are ugly, but we're testing 
+            // that static methods are called, e.g. [BeforeClass].
+            MultiMethod.methodsCalled = [];
+            test = MultiMethod;
+        }
+
+        [After]
+        public function tearDown():void {
+            runner = null;
+            MultiMethod.methodsCalled = null;
+        }
+
+        [Test]
+        public function runnerInstantiated():void {
+            assertTrue("TestRunner instantiated", runner is IRunner);
+        }
+        
+        [Test]
+        public function testShouldNotExtendTestCase():void {
+            assertFalse(test is TestCase);
+        }
+
+        [Test]
+        public function shouldRunMethodsAlphabetically():void {
+            runner.addEventListener(Event.COMPLETE, async.add(checkMethodsCalledAfterRunningTestInstance, 500));
+            runner.run(test);
+        }
+        
+        private function checkMethodsCalledAfterRunningTestInstance(e:Event):void {
+            var i:uint = 0;
+            
+            assertSame(MultiMethod.runBeforeClass1,         MultiMethod.methodsCalled[i++]);
+            assertSame(MultiMethod.runBeforeClass2,         MultiMethod.methodsCalled[i++]);
+            
+            assertSame(runner.currentTest.runBefore1,                       MultiMethod.methodsCalled[i++]);
+            assertSame(runner.currentTest.runBefore2,                       MultiMethod.methodsCalled[i++]);
+            assertSame(runner.currentTest.fail_assertEquals,                MultiMethod.methodsCalled[i++]);
+            assertSame(runner.currentTest.runAfter1,                        MultiMethod.methodsCalled[i++]);
+            assertSame(runner.currentTest.runAfter2,                        MultiMethod.methodsCalled[i++]);
+
+            assertSame(runner.currentTest.runBefore1,                       MultiMethod.methodsCalled[i++]);
+            assertSame(runner.currentTest.runBefore2,                       MultiMethod.methodsCalled[i++]);
+            assertSame(runner.currentTest.numChildren_is_0_by_default,      MultiMethod.methodsCalled[i++]);
+            assertSame(runner.currentTest.runAfter1,                        MultiMethod.methodsCalled[i++]);
+            assertSame(runner.currentTest.runAfter2,                        MultiMethod.methodsCalled[i++]);
+            
+            assertSame(runner.currentTest.runBefore1,                       MultiMethod.methodsCalled[i++]);
+            assertSame(runner.currentTest.runBefore2,                       MultiMethod.methodsCalled[i++]);
+            assertSame(runner.currentTest.stage_is_null_by_default,         MultiMethod.methodsCalled[i++]);
+            assertSame(runner.currentTest.runAfter1,                        MultiMethod.methodsCalled[i++]);
+            assertSame(runner.currentTest.runAfter2,                        MultiMethod.methodsCalled[i++]);
+            
+            assertSame(MultiMethod.runAfterClass1,          MultiMethod.methodsCalled[i++]);
+            assertSame(MultiMethod.runAfterClass2,          MultiMethod.methodsCalled[i++]);
+            
+            assertEquals('checked all methodsCalled', MultiMethod.methodsCalled.length, i);
+        }
+
+        [Test]
+        public function runShouldTriggerResultEvent():void {
+            runner.addEventListener(Event.COMPLETE, async.add(checkResultWasNotSuccessful, 500));
+            runner.run(test);
+        }
+        
+        private function checkResultWasNotSuccessful(e:Event):void {
+            assertTrue(runner.bridge.failureEncountered);
+            assertFalse(runner.bridge.wasSuccessful);
+            
+            var failures:Array = runner.bridge.failures;
+            assertEquals('one failure in testResult', 1, failures.length);
+            
+            var failure0:ITestFailure = failures[0] as TestFailure;
+            assertTrue("failedTest is instance of test class", failure0.failedTest is test);
+        }
+
+        [Test]
+        public function runMethodByNameShouldExecuteExpectedSequence():void {
+            var delegate:Function = async.add(checkMethodsCalledAfterRunningTestMethodByName, 500);
+            runner.addEventListener(Event.COMPLETE, delegate);
+            
+            var testMethodName:String = 'stage_is_null_by_default';
+            runner.runMethodByName(test, testMethodName);
+        }
+
+        private function checkMethodsCalledAfterRunningTestMethodByName(e:Event):void {
+            var i:uint = 0;
+            
+            assertSame(MultiMethod.runBeforeClass1,                 MultiMethod.methodsCalled[i++]);
+            assertSame(MultiMethod.runBeforeClass2,                 MultiMethod.methodsCalled[i++]);
+            
+            assertSame(runner.currentTest.runBefore1,               MultiMethod.methodsCalled[i++]);
+            assertSame(runner.currentTest.runBefore2,               MultiMethod.methodsCalled[i++]);
+            assertSame(runner.currentTest.stage_is_null_by_default, MultiMethod.methodsCalled[i++]);
+
+            // NOTE: The following assertions are no longer applicable.
+            // if the testMethod is provided, tearDown does not occur...
+            //assertSame(runner.currentTest.runAfter1,              MultiMethod.methodsCalled[i++]);
+            //assertSame(runner.currentTest.runAfter2,              MultiMethod.methodsCalled[i++]);
+            
+            //assertSame(MultiMethod.runAfterClass1,                    MultiMethod.methodsCalled[i++]);
+            //assertSame(MultiMethod.runAfterClass2,                    MultiMethod.methodsCalled[i++]);
+            
+            assertEquals('checked all methodsCalled',               MultiMethod.methodsCalled.length, i);
+        }
+
+        // This an interesting hack in that an AsUnit 4 Test Case is being instantiated
+        // and executed, but in this environment, we're simply checking to see if it passed,
+        // and outputing any failures to the message...
+        [Test]
+        public function shouldInjectTypes():void {
+            runner.run(InjectionVerification, null, context);
+            assertFalse("Should not have encountered failures: " + runner.bridge.failures.join("\n\n"), runner.bridge.failureEncountered);
+        }
+
+        [Test]
+        public function shouldInjectWithUnknownAttribute():void {
+            runner.run(InjectionFailure);
+            var warnings:Array = runner.bridge.warnings;
+            assertEquals(1, warnings.length);
+        }
+
+        [Test]
+        public function shouldInjectAsyncTimeout():void {
+            var async:IAsync = runner.async;
+            assertEquals(Async.DEFAULT_TIMEOUT, async.timeout);
+            runner.run(InjectTimeoutOnAsync);
+            assertEquals(5, async.timeout);
+        }
+
+        [Test]
+        public function annotationsOnSuperClassShouldBeRespected():void {
+            runner.run(AnnotatedSubClass);
+            assertFalse("Should not have failures: " + runner.bridge.failures.join("\n\n"), runner.bridge.failureEncountered);
+        }
+    }
+}
+

data/test/asunit/support/AnnotatedSubClass.as

@@ -0,0 +1,18 @@
+package asunit.support {
+
+    import asunit.asserts.*;
+
+    public class AnnotatedSubClass extends AnnotatedSuperClass {
+
+        [Test]
+        public function verifyDictionary():void {
+            assertNotNull(dictionary);
+        }
+
+        [Test]
+        public function verifyAsync():void {
+            assertNotNull(async);
+        }
+    }
+}
+

data/test/asunit/support/AnnotatedSuperClass.as

@@ -0,0 +1,15 @@
+package asunit.support {
+
+    import asunit.asserts.*;
+    import asunit.framework.IAsync;
+    import flash.utils.Dictionary;
+
+    public class AnnotatedSuperClass {
+
+        [Inject]
+        public var async:IAsync;
+
+        [Inject]
+        public var dictionary:Dictionary;
+    }
+}

data/test/asunit/support/CustomParameters.as

@@ -0,0 +1,13 @@
+package asunit.support {
+
+    public class CustomParameters {
+
+        public var someArray:Array;
+        public var someBoolean:Boolean;
+        public var someInt:int;
+        public var someNumber:Number;
+        public var someString:String;
+        public var someUInt:uint;
+    }
+}
+

data/test/asunit/support/CustomTestRunner.as

@@ -0,0 +1,22 @@
+package asunit.support {
+
+    import asunit.framework.CallbackBridge;
+    import asunit.framework.IResult;
+    import asunit.runners.TestRunner;
+
+    import flash.display.DisplayObjectContainer;
+
+    public class CustomTestRunner extends TestRunner {
+
+        // Used so that test cases can 
+        // verify that this custom runner
+        // worked.
+        public static var runCalledCount:int;
+
+        override public function run(testClass:Class, testMethod:String=null, visualContext:DisplayObjectContainer=null):void {
+            runCalledCount++;
+            super.run(testClass, testMethod, visualContext);
+        }
+    }
+}
+

data/test/asunit/support/DoubleFailSuite.as

@@ -0,0 +1,8 @@
+package asunit.support {
+		
+	[Suite]
+	public class DoubleFailSuite {
+		public var failAssertTrueTest:FailAssertTrue;
+		public var failAssertEqualsTest:FailAssertEquals;
+	}
+}

data/test/asunit/support/DoubleNestedSuite.as

@@ -0,0 +1,14 @@
+package asunit.support {
+		
+	[Suite]
+	public class DoubleNestedSuite {
+		// contains two suites
+		public var suiteOfTwoSuites:SuiteOfTwoSuites;
+		
+		// contains a single test
+		public var singleErrorSuite:SingleErrorSuite;
+		
+		// a single test not in a suite
+		public var ignoredMethodTest:IgnoredMethod;
+	}
+}

data/test/asunit/support/ErrorInMethod.as

@@ -0,0 +1,11 @@
+package asunit.support {
+
+	public class ErrorInMethod {
+		
+		[Test]
+		public function throw_ArgumentError():void {
+			throw new ArgumentError('generated by ErrorInMethod');
+		}
+		
+	}
+}

data/test/asunit/support/FailAssertEquals.as

@@ -0,0 +1,29 @@
+package asunit.support {
+
+	import asunit.asserts.*;
+	
+	public class FailAssertEquals {
+
+		public var methodsCalled:Array;
+		
+		public function FailAssertEquals() {
+			methodsCalled = [];
+		}
+		
+		[Before]
+		public function runBefore():void {
+			methodsCalled.push(arguments.callee);
+		}
+		
+		[After]
+		public function runAfter():void {
+			methodsCalled.push(arguments.callee);
+		}
+		
+		[Test]
+		public function fail_assertEquals():void {
+			methodsCalled.push(arguments.callee);
+			assertEquals('Words should be equal', 'right', 'wrong');
+		}
+	}
+}

data/test/asunit/support/FailAssertTrue.as

@@ -0,0 +1,28 @@
+package asunit.support {
+
+	import asunit.asserts.*;
+
+	public class FailAssertTrue {
+		
+		public var methodsCalled:Array;
+		
+		[Before]
+		public function runBefore():void {
+			methodsCalled = [];
+			methodsCalled.push(arguments.callee);
+		}
+		
+		[After]
+		public function runAfter():void {
+			methodsCalled.push(arguments.callee);
+		}
+		
+		[Test]
+		public function fail_assertTrue():void {
+			methodsCalled.push(arguments.callee);
+			assertTrue('Law of non-contradiction', false);
+		}
+		
+	}
+
+}

data/test/asunit/support/FakeObserver.as

@@ -0,0 +1,42 @@
+package asunit.support {
+
+    import asunit.framework.IResult;
+    import asunit.framework.IRunListener;
+    import asunit.framework.ITestFailure;
+    import asunit.framework.ITestSuccess;
+    import asunit.framework.ITestWarning;
+    import asunit.framework.Method;
+
+    public class FakeObserver implements IRunListener {
+
+        public var onRunStartedCalled:Boolean;
+        public var onTestStartedCalled:Boolean;
+
+		public function onRunStarted():void {
+            onRunStartedCalled = true;
+        }
+
+		public function onRunCompleted(result:IResult):void {
+        }
+
+		public function onTestStarted(test:Object):void {
+            onTestStartedCalled = true;
+        }
+
+		public function onTestCompleted(test:Object):void {
+        }
+
+		public function onTestFailure(failure:ITestFailure):void {
+        }
+
+		public function onTestSuccess(success:ITestSuccess):void {
+        }
+
+		public function onTestIgnored(method:Method):void {
+        }
+
+        public function onWarning(warning:ITestWarning):void {
+        }
+    }
+}
+

data/test/asunit/support/FakeRunner.as

@@ -0,0 +1,32 @@
+package asunit.support {
+
+    import asunit.framework.IRunner;
+    import asunit.framework.IResult;
+    import asunit.framework.TestSuccess;
+    import asunit.framework.IRunnerFactory;
+
+    import flash.events.EventDispatcher;
+    import flash.display.DisplayObjectContainer;
+
+    public class FakeRunner extends EventDispatcher implements IRunner {
+
+		public function run(testOrSuite:Class, result:IResult, testMethod:String=null, visualContext:DisplayObjectContainer=null):void {
+            var currentTest:TestForFakeRunner = new testOrSuite() as TestForFakeRunner;
+
+            result.onTestStarted(currentTest);
+            result.onTestSuccess(new TestSuccess(currentTest, 'customTestMethod'));
+            result.onTestCompleted(currentTest);
+        }
+        
+        public function shouldRunTest(testClass:Class):Boolean {
+            return true;
+        }
+
+        public function set factory(factory:IRunnerFactory):void {
+        }
+
+        public function get factory():IRunnerFactory {
+        }
+    }
+}
+

data/test/asunit/support/IgnoredMethod.as

@@ -0,0 +1,26 @@
+package asunit.support {
+
+	import asunit.asserts.*;
+
+	public class IgnoredMethod {
+		
+		[Before]
+		public function runBefore():void {
+		}
+		
+		[After]
+		public function runAfter():void {
+		}
+		
+		[Ignore("because")]
+		[Test]
+		public function should_be_ignored():void {
+			fail('this test method should be ignored');
+		}
+
+		[Test]
+        public function should_not_be_ignored():void {
+        }
+		
+	}
+}

data/test/asunit/support/InjectTimeoutOnAsync.as

@@ -0,0 +1,14 @@
+package asunit.support {
+
+    import asunit.framework.IAsync;
+
+    public class InjectTimeoutOnAsync {
+
+        [Inject(timeout=5)]
+        public var async:IAsync;
+
+        [Test]
+        public function verifyNothing():void {
+        }
+    }
+}

data/test/asunit/support/InjectionFailure.as

@@ -0,0 +1,18 @@
+package asunit.support {
+
+    import asunit.asserts.*;
+    import asunit.framework.Async;
+    import asunit.framework.IAsync;
+
+    import flash.display.Sprite;
+
+    public class InjectionFailure {
+
+        [Inject(unknownValue="foo")]
+        public var custom:CustomParameters;
+
+        [Test]
+        public function unknownValueShouldExplode():void {
+        }
+    }
+}