asunit4 4.2.1.pre

data/test/asunit/framework/TestIteratorMultiMethodTest.as

@@ -0,0 +1,186 @@
+package asunit.framework {
+
+	import asunit.framework.TestCase;
+    import asunit.util.ArrayIterator;
+    import asunit.util.Iterator;
+
+	import asunit.support.MultiMethod;
+
+	public class TestIteratorMultiMethodTest extends TestCase {
+
+		private var multiTest:MultiMethod;
+
+		public function TestIteratorMultiMethodTest(testMethod:String = null) {
+			super(testMethod);
+		}
+
+		protected override function setUp():void {
+            super.setUp();
+			multiTest = new MultiMethod();
+		}
+
+		protected override function tearDown():void {
+            super.setUp();
+			multiTest = null;
+		}
+
+        private function verifyMethods(actual:Iterator, expectedItems:Array):void {
+            var expected:Iterator = new ArrayIterator(expectedItems);
+			assertEquals(expected.length, actual.length);
+            var actualMethod:Method;
+            var expectedMethod:Object;
+            for(var i:uint; i < expected.length; i++) {
+                actualMethod = actual.next();
+                expectedMethod = expected.next();
+                assertEquals(expectedMethod.name, actualMethod.name);
+                assertSame(expectedMethod.name + " with wrong value", expectedMethod.value, actualMethod.value);
+            }
+        }
+
+		public function test_get_BeforeClass_methods_of_test_instance():void {
+            var iterator:Iterator = new TestIterator(multiTest).beforeClassIterator;
+            var methods:Array = [
+                { name: 'runBeforeClass1', value: MultiMethod.runBeforeClass1 },
+                { name: 'runBeforeClass2', value: MultiMethod.runBeforeClass2 }
+            ];
+
+            verifyMethods(iterator, methods);
+		}
+		
+		public function test_get_AfterClass_methods_of_test_instance():void {
+			var iterator:Iterator = new TestIterator(multiTest).afterClassIterator;
+            var methods:Array = [
+                { name: 'runAfterClass1', value: MultiMethod.runAfterClass1 },
+                { name: 'runAfterClass2', value: MultiMethod.runAfterClass2 }
+            ];
+
+            verifyMethods(iterator, methods);
+		}
+
+		public function test_get_before_methods_of_test_instance():void {
+			var iterator:Iterator = new TestIterator(multiTest).beforeIterator;
+            var methods:Array = [
+                { name: 'runBefore1', value: multiTest.runBefore1 },
+                { name: 'runBefore2', value: multiTest.runBefore2 },
+            ];
+
+			verifyMethods(iterator, methods);
+		}
+		
+		public function test_get_test_methods_of_test_instance():void {
+			//NOTE: Avoid naming variables the same as testMethods property in asunit.framework.TestCase.
+			var iterator:Iterator = new TestIterator(multiTest).testMethodsIterator;
+            var methods:Array = [
+                { name: 'fail_assertEquals', value: multiTest.fail_assertEquals },
+                { name: 'numChildren_is_0_by_default', value: multiTest.numChildren_is_0_by_default },
+                { name: 'stage_is_null_by_default', value: multiTest.stage_is_null_by_default }
+            ];
+
+            verifyMethods(iterator, methods);
+		}
+		
+		public function test_get_after_methods_of_test_instance():void {
+			var iterator:Iterator = new TestIterator(multiTest).afterIterator;
+            var methods:Array = [
+                { name: 'runAfter1', value: multiTest.runAfter1 },
+                { name: 'runAfter2', value: multiTest.runAfter2 }
+            ];
+
+            verifyMethods(iterator, methods);
+        }
+				
+		public function testIteratorNext():void {
+			var iterator:Iterator = new TestIterator(multiTest); // Use this to ensure we use the Iterator interface
+            var testIterator:TestIterator = iterator as TestIterator; // Use this to check TestIterator interface
+
+            assertTrue('setup a',                       testIterator.readyToSetUp);
+            assertFalse('teardown a',                   testIterator.readyToTearDown);
+            assertEquals('runBeforeClass1', 			iterator.next().name);
+            assertFalse('setup b',                      testIterator.readyToSetUp);
+            assertFalse('teardown b',                   testIterator.readyToTearDown);
+			assertEquals('runBeforeClass2', 		    iterator.next().name);
+
+            assertFalse('setup c',                      testIterator.readyToSetUp);
+            assertFalse('teardown c',                   testIterator.readyToTearDown);
+			
+			assertEquals('runBefore1', 					iterator.next().name);
+            assertFalse('setup d',                      testIterator.readyToSetUp);
+            assertFalse('teardown d',                   testIterator.readyToTearDown);
+            assertFalse('setup e',                      testIterator.readyToSetUp);
+			assertEquals('runBefore2', 					iterator.next().name);
+            assertFalse('setup e',                      testIterator.readyToSetUp);
+            assertFalse('teardown e',                   testIterator.readyToTearDown);
+			assertEquals('fail_assertEquals',			iterator.next().name);
+            assertFalse('setup f',                      testIterator.readyToSetUp);
+            assertFalse('teardown f',                   testIterator.readyToTearDown);
+			assertEquals('runAfter1', 					iterator.next().name);
+            assertFalse('setup g',                      testIterator.readyToSetUp);
+            assertFalse('teardown g',                   testIterator.readyToTearDown);
+			assertEquals('runAfter2', 					iterator.next().name);
+
+            assertTrue('setup h',                       testIterator.readyToSetUp);
+            assertTrue('teardown h',                    testIterator.readyToTearDown);
+
+			assertEquals('runBefore1', 					iterator.next().name);
+            assertFalse('setup i',                      testIterator.readyToSetUp);
+            assertFalse('teardown i',                   testIterator.readyToTearDown);
+			assertEquals('runBefore2', 					iterator.next().name);
+            assertFalse('setup j',                      testIterator.readyToSetUp);
+            assertFalse('teardown j',                   testIterator.readyToTearDown);
+			assertEquals('numChildren_is_0_by_default',	iterator.next().name);
+            assertFalse('setup k',                      testIterator.readyToSetUp);
+            assertFalse('teardown k',                   testIterator.readyToTearDown);
+			assertEquals('runAfter1', 					iterator.next().name);
+            assertFalse('setup l',                      testIterator.readyToSetUp);
+            assertFalse('teardown l',                   testIterator.readyToTearDown);
+			assertEquals('runAfter2', 					iterator.next().name);
+
+            assertTrue('setup m',                       testIterator.readyToSetUp);
+            assertTrue('teardown m',                    testIterator.readyToTearDown);
+			
+			assertEquals('runBefore1', 					iterator.next().name);
+            assertFalse('setup n',                      testIterator.readyToSetUp);
+            assertFalse('teardown n',                   testIterator.readyToTearDown);
+			assertEquals('runBefore2', 					iterator.next().name);
+            assertFalse('setup o',                      testIterator.readyToSetUp);
+            assertFalse('teardown o',                   testIterator.readyToTearDown);
+			assertEquals('stage_is_null_by_default', 	iterator.next().name);
+            assertFalse('setup p',                      testIterator.readyToSetUp);
+            assertFalse('teardown p',                   testIterator.readyToTearDown);
+			assertEquals('runAfter1', 					iterator.next().name);
+            assertFalse('setup q',                      testIterator.readyToSetUp);
+            assertFalse('teardown q',                   testIterator.readyToTearDown);
+			assertEquals('runAfter2', 					iterator.next().name);
+
+            assertFalse('setup r',                      testIterator.readyToSetUp); // No more setUps remaining!
+            assertTrue('teardown r',                    testIterator.readyToTearDown);
+			
+			assertEquals('runAfterClass1', 				iterator.next().name);
+            assertFalse('setup s',                      testIterator.readyToSetUp);
+            assertFalse('teardown s',                   testIterator.readyToTearDown);
+			assertEquals('runAfterClass2', 				iterator.next().name);
+            assertFalse('setup t',                      testIterator.readyToSetUp);
+            assertFalse('teardown t',                   testIterator.readyToTearDown);
+			
+			assertFalse('no methods left in iterator',	iterator.hasNext());
+		}
+		
+		public function testIteratorExhaustedWithWhileLoopThenResetShouldHasNext():void {
+			var iterator:Iterator = new TestIterator(multiTest);
+			while(iterator.hasNext()) {
+                iterator.next();
+            }
+			iterator.reset();
+			
+			assertTrue(iterator.hasNext());
+		}
+
+        public function testIteratorLength():void {
+            // TestIterator.length reflects all methods that will be called...
+            // not just test methods and not all non-test methods * test methods.
+            var iterator:TestIterator = new TestIterator(multiTest);
+            assertEquals(19, iterator.length);
+        }
+	}
+}
+

data/test/asunit/framework/TestIteratorOrderedTestMethodTest.as

@@ -0,0 +1,57 @@
+package asunit.framework {
+
+	import asunit.framework.TestCase;
+    import asunit.util.Iterator;
+
+	import asunit.support.OrderedTestMethod;
+
+	public class TestIteratorOrderedTestMethodTest extends TestCase {
+
+		private var iterator:Iterator;
+		private var orderedTest:OrderedTestMethod;
+
+		public function TestIteratorOrderedTestMethodTest(testMethod:String = null) {
+			super(testMethod);
+		}
+
+		protected override function setUp():void {
+            super.setUp();
+			orderedTest = new OrderedTestMethod();
+		}
+
+		protected override function tearDown():void {
+            super.tearDown();
+			iterator    = null;
+			orderedTest = null;
+		}
+
+		public function test_countTestMethods_of_test():void {
+            iterator = new TestIterator(orderedTest);
+			assertEquals(4, iterator.length);
+		}
+		
+		public function test_get_test_methods_of_test_instance():void {
+			//NOTE: Avoid naming variables the same as testMethods property in asunit.framework.TestCase.
+            var iterator:Iterator = new TestIterator(orderedTest);
+			
+			assertEquals(4, iterator.length);
+            var first:Method = iterator.next();
+            var second:Method = iterator.next();
+            var third:Method = iterator.next();
+            var fourth:Method = iterator.next();
+
+            assertFalse("Should be out of items", iterator.next());
+
+			assertEquals(first.name,  'negativeOrderIsAllowed');
+			assertEquals(second.name, 'zeroIsDefaultOrder');
+			assertEquals(third.name,  'two');
+			assertEquals(fourth.name, 'three');
+			
+			assertEquals(orderedTest.negativeOrderIsAllowed, 	first.value);
+			assertEquals(orderedTest.zeroIsDefaultOrder,		second.value);
+			assertEquals(orderedTest.two, 						third.value);
+			assertEquals(orderedTest.three, 					fourth.value);
+		}
+	}
+}
+

data/test/asunit/framework/TestIteratorSingleMethodTest.as

@@ -0,0 +1,56 @@
+package asunit.framework {
+
+	import asunit.framework.TestCase;
+    import asunit.util.Iterator;
+
+	import asunit.support.FailAssertTrue;
+
+	public class TestIteratorSingleMethodTest extends TestCase {
+
+		private var iterator:Iterator;
+		private var singleTest:FailAssertTrue;
+
+		public function TestIteratorSingleMethodTest(testMethod:String = null) {
+			super(testMethod);
+		}
+
+		protected override function setUp():void {
+            super.setUp();
+			singleTest = new FailAssertTrue();
+		}
+
+		protected override function tearDown():void {
+            super.tearDown();
+			iterator   = null;
+            singleTest = null;
+		}
+
+		public function test_iterator_for_null_yields_hasNext_false():void {
+			iterator = new TestIterator(null);
+			assertFalse(iterator.hasNext());
+		}
+		
+		public function test_iterator_for_non_test_yields_hasNext_false():void {
+			iterator = new TestIterator(new Date());
+			assertFalse(iterator.hasNext());
+		}
+		
+		public function test_iterator_for_test_with_one_test_method_hasNext():void {
+			iterator = new TestIterator(singleTest);
+			assertTrue(iterator.hasNext());
+		}
+		
+		public function test_iterator_next():void {
+			iterator = new TestIterator(singleTest);
+			
+            assertTrue('a', iterator.hasNext());
+			assertEquals('runBefore', 		iterator.next().toString());
+            assertTrue('b', iterator.hasNext());
+			assertEquals('fail_assertTrue',	iterator.next().toString());
+            assertTrue('c', iterator.hasNext());
+			assertEquals('runAfter',		iterator.next().toString());
+			assertFalse('no methods left in iterator', iterator.hasNext());
+		}
+	}
+}
+

data/test/asunit/framework/VisualTestCaseTest.as

@@ -0,0 +1,43 @@
+package asunit.framework {
+
+    import asunit.asserts.*;
+
+    import flash.display.Sprite;
+    
+    public class VisualTestCaseTest {
+
+        [Inject]
+        public var sprite:Sprite;
+
+        [Test]
+        public function instantiated():void {
+            assertTrue(sprite is Sprite);
+        }
+        
+        [Test]
+        public function testSize():void {
+            assertTrue(sprite.width == 0);
+            assertTrue(sprite.height == 0);
+        }
+
+        [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/framework/assertAssertionFailed.as

@@ -0,0 +1,19 @@
+package asunit.framework
+{
+    import asunit.errors.AssertionFailedError;
+    import asunit.framework.Assert;
+
+    internal function assertAssertionFailed(assertFunction:Function, expected:Object, actual:Object):void {
+        var succeeded:Boolean = false;
+        try {
+            assertFunction.apply(null, [expected, actual]);
+            succeeded = true;
+        }
+        catch (e:AssertionFailedError) {
+            // expected
+        }
+        if (succeeded) {
+            Assert.fail("expected AssertionFailedError");
+        }
+    }
+}

data/test/asunit/printers/TextPrinterTest.as

@@ -0,0 +1,122 @@
+package asunit.printers {
+    
+    import asunit.framework.ITestFailure;
+    import asunit.framework.TestCase;
+
+    import asunit.framework.IResult;
+    import asunit.framework.ITestSuccess;
+    import asunit.framework.ITestWarning;
+    import asunit.framework.Result;
+    import asunit.framework.TestFailure;
+    import asunit.framework.TestSuccess;
+    import asunit.framework.TestWarning;
+
+    public class TextPrinterTest extends TestCase {
+
+        private var printer:FakeTextPrinter;
+        private var test:*;
+        private var success:ITestSuccess;
+        private var failure:ITestFailure;
+        private var testResult:IResult;
+
+        public function TextPrinterTest(method:String=null) {
+            super(method);
+        }
+
+        override protected function setUp():void {
+            super.setUp();
+            printer    = new FakeTextPrinter();
+            printer.backgroundColor = 0xffcc00;
+            printer.textColor = 0x000000;
+
+            testResult = new Result();
+            test       = new TestCase();
+            failure    = new TestFailure(test, 'testSomethingThatFails', new Error('Fake Failure'));
+            success    = new TestSuccess(test, 'testSomethingThatSucceeds');
+            testResult.addListener(printer);
+        }
+
+        override protected function tearDown():void {
+            super.tearDown();
+            removeChild(printer);
+            failure    = null;
+            printer    = null;
+            testResult = null;
+            success    = null;
+            test       = null;
+        }
+
+        private function executeASucceedingTest():void {
+            testResult.onRunStarted();
+            testResult.onTestStarted(test);
+            testResult.onTestSuccess(success);
+            testResult.onTestCompleted(test);
+            testResult.onRunCompleted(null);
+        }
+
+        private function executeASucceedingTestWithWarning(warning:ITestWarning):void {
+            testResult.onRunStarted();
+            testResult.onTestStarted(test);
+            testResult.onWarning(warning);
+            testResult.onTestSuccess(success);
+            testResult.onTestCompleted(test);
+            testResult.onRunCompleted(null);
+        }
+
+        private function executeAFailingTest():void {
+            testResult.onRunStarted();
+            testResult.onTestStarted(test);
+            testResult.onTestFailure(failure);
+            testResult.onTestCompleted(test);
+            testResult.onRunCompleted(null);
+        }
+
+        public function testPrinterOnTestSuccess():void {
+            executeASucceedingTest();
+            var actual:String = printer.toString();
+            assertTrue("Printer should print OK", actual.indexOf('OK') > -1);
+            assertTrue("Printer should include Test count: ", actual.match(/\nOK \(1 test\)/));
+        }
+
+        public function testPrinterFailure():void {
+            executeAFailingTest();
+            var expected:String = "testSomethingThatFails : Error: Fake Failure";
+            var actual:String = printer.toString();
+            assertTrue("Printer should fail", actual.indexOf(expected) > -1);
+            assertTrue("Printer should include Test Duration: ", actual.match(/\nTotal Time: \d/));
+        }
+
+        public function testPrinterWithNoTests():void {
+            testResult.onRunStarted();
+            testResult.onRunCompleted(null);
+            assertTrue("Printer should include Warning for no tests", printer.toString().indexOf("[WARNING]") > -1);
+        }
+
+        public function testPrinterDisplayed():void {
+            addChild(printer);
+            executeASucceedingTest();
+            assertTrue("The output was displayed.", printer.getTextDisplay().text.indexOf('Time Summary:') > -1);
+        }
+
+        public function testDisplaysWarnings():void {
+            var message:String = "problem"
+            executeASucceedingTestWithWarning(new TestWarning(message));
+            assertTrue("Printer displays warnings", printer.toString().indexOf(message) > -1);
+        }
+    }
+}
+
+import asunit.printers.TextPrinter;
+import flash.text.TextField;
+
+class FakeTextPrinter extends TextPrinter {
+
+    // Prevent the printer from tracing results:
+    override protected function logResult():void {
+    }
+
+    public function getTextDisplay():TextField {
+        return textDisplay;
+    }
+}
+

data/test/asunit/runners/LegacyRunnerTest.as

@@ -0,0 +1,40 @@
+package asunit.runners {
+
+    import asunit.framework.IResult;
+    import asunit.framework.LegacyTestIterator;
+    import asunit.framework.Result;
+    import asunit.framework.TestCase;
+    import asunit.support.LegacyTestCase;
+
+    import flash.events.Event;
+    import asunit.framework.CallbackBridge;
+
+    public class LegacyRunnerTest extends TestCase {
+
+        private var testRunner:LegacyRunner;
+
+        public function LegacyRunnerTest(methodName:String=null) {
+            super(methodName)
+        }
+
+        override protected function setUp():void {
+            super.setUp();
+            LegacyTestCase.callCount = 0;
+            testRunner = new LegacyRunner();
+        }
+
+        override protected function tearDown():void {
+            super.tearDown();
+            testRunner = null;
+        }
+
+        public function testSimpleSubclass():void {
+            var handler:Function = function(event:Event):void {
+                assertEquals(0, testRunner.bridge.failureCount);
+                assertEquals(2, testRunner.bridge.runCount);
+            };
+            testRunner.addEventListener(Event.COMPLETE, addAsync(handler));
+            testRunner.run(LegacyTestCase);
+        }
+    }
+}

data/test/asunit/runners/SuiteRunnerTest.as

@@ -0,0 +1,40 @@
+package asunit.runners {
+
+    import asunit.asserts.*;
+    import asunit.framework.IAsync;
+    import asunit.framework.Result;
+    import asunit.support.DoubleFailSuite;
+    import asunit.support.InjectionVerification;
+
+    import flash.events.Event;
+
+    public class SuiteRunnerTest {
+
+        [Inject]
+        public var async:IAsync;
+
+        [Inject]
+        public var suiteRunner:SuiteRunner;
+
+        [Inject]
+        public var runnerResult:Result;
+
+        public function testRunTriggersCompleteEvent():void {
+            suiteRunner.addEventListener(Event.COMPLETE, async.add(checkResultWasNotSuccessful));
+            suiteRunner.run(DoubleFailSuite);
+        }
+        
+        private function checkResultWasNotSuccessful(event:Event):void {
+            assertFalse(runnerResult.wasSuccessful);
+        }
+
+        [Test]
+        public function testCanHandATestToSuiteRunner():void {
+            suiteRunner.addEventListener(Event.COMPLETE, async.add());
+            suiteRunner.run(InjectionVerification);
+            assertFalse(runnerResult.wasSuccessful);
+        }
+    }
+}
+
+

data/test/asunit/runners/TestRunnerAsyncMethodTest.as

@@ -0,0 +1,107 @@
+package asunit.runners {
+
+    import asunit.asserts.*;
+    import asunit.framework.CallbackBridge;
+    import asunit.framework.TestCase;
+    import asunit.util.Iterator;
+
+    import asunit.framework.IAsync;
+    import asunit.framework.Method;
+    import asunit.framework.Result;
+    import asunit.framework.TestFailure;
+    import asunit.framework.TestIterator;
+
+    import flash.events.Event;
+    import flash.utils.getQualifiedClassName;
+
+    public class TestRunnerAsyncMethodTest {
+
+        [Inject]
+        public var async:IAsync;
+
+        [Inject]
+        public var runner:TestRunner;
+
+        [Test]
+        public function asyncShouldWork():void {
+            runner.addEventListener(Event.COMPLETE, async.add(ensureRunnerHasNotYetFailed, 100));
+            runner.run(AsyncMethodSuccessTest);
+        }
+
+        [Test]
+        public function runAsyncCallsAsyncDelegate():void {
+            runner.addEventListener(Event.COMPLETE, async.add(ensureRunnerHasNotYetFailed, 10));
+            runner.run(AsyncDelegateCalledSynchronouslyTest);
+        }
+        
+        private function ensureRunnerHasNotYetFailed(e:Event):void {
+            assertFalse('runner result has not failed', runner.bridge.failureEncountered);
+        }
+        
+        [Test]
+        public function shouldSeeErrorWhenAsyncFailure():void {
+            runner.addEventListener(Event.COMPLETE, async.add(checkResultForIllegalOperationError, 200));
+            runner.run(AsyncMethodTooSlowTest);
+        }
+        
+        private function checkResultForIllegalOperationError(e:Event):void {
+            assertEquals('number of errors', 1, runner.bridge.errors.length);
+            var failure0:TestFailure = runner.bridge.errors[0] as TestFailure;
+            assertEquals('exception type', 'flash.errors::IllegalOperationError', getQualifiedClassName(failure0.thrownException));
+            assertEquals('failed method name', 'shouldFailForBeingTooSlow', failure0.failedMethod);
+        }
+    }
+}
+
+import asunit.asserts.*;
+import asunit.framework.IAsync;
+import flash.utils.setTimeout;
+
+class AsyncMethodSuccessTest {
+
+    [Inject]
+    public var async:IAsync;
+    
+    [Test]
+    public function operationDelayedButFastEnoughToSucceed():void {
+        var delegate:Function = async.add();
+        setTimeout(delegate, 0);
+    }
+}
+
+class AsyncMethodTooSlowTest {
+
+    [Inject]
+    public var async:IAsync;
+
+    [Test]
+    public function shouldFailForBeingTooSlow():void {
+        // This will force an async timeout in 1 millisecond:
+        var delegate:Function = async.add(null, 1);
+        // This will still call the async handler in 100ms,
+        // but the test run should have already continued:
+        setTimeout(delegate, 100);
+    }
+}
+
+class AsyncDelegateCalledSynchronouslyTest {
+
+    import asunit.asserts.*;
+
+    [Inject]
+    public var async:IAsync;
+
+    private var handlerWasCalled:Boolean = false;
+    
+    [Test]
+    public function callingDelegateSynchronouslyShouldStillSucceed():void {
+        var delegate:Function = async.add(onComplete);
+        delegate();
+        assertTrue(handlerWasCalled);
+    }
+    
+    private function onComplete():void {
+        handlerWasCalled = true;
+    }
+}
+