asunit4 4.2.1.pre

data/test/asunit/support/InjectionVerification.as

@@ -0,0 +1,69 @@
+package asunit.support {
+
+    import asunit.asserts.*;
+    import asunit.framework.Async;
+    import asunit.framework.IAsync;
+
+    import flash.display.Sprite;
+
+    public class InjectionVerification {
+
+        [Inject]
+        public var iAsync:IAsync;
+
+        [Inject]
+        public var async:Async;
+
+        [Inject]
+        public var context:Sprite;
+
+        [Inject(someString="stringValue", someBoolean=false, someNumber=23.4, someInt=-23, someUInt=25)]
+        public var custom:CustomParameters;
+
+        [Test]
+        public function injectedShouldReceiveUIntValue():void {
+            assertSame(25, custom.someUInt);
+        }
+
+        [Test]
+        public function injectedShouldReceiveIntegerValue():void {
+            assertSame(-23, custom.someInt);
+        }
+
+        [Test]
+        public function injectedShouldReceiveNumberValue():void {
+            assertSame(23.4, custom.someNumber);
+        }
+
+        [Test]
+        public function injectedShouldReceiveBooleanValue():void {
+            assertSame(false, custom.someBoolean);
+        }
+
+        [Test]
+        public function injectedShouldReceiveStringValue():void {
+            assertEquals("stringValue", custom.someString);
+        }
+
+        [Test]
+        public function verifyDisplayObjectInjection():void {
+            assertNotNull("DisplayObject should exiset", context);
+        }
+
+        [Test]
+        public function verifyDisplayObjectAttachedToStage():void {
+            assertNotNull("DisplayObjects hould be attached", context.stage);
+        }
+
+        [Test]
+        public function verifyAsyncInjection():void {
+            assertNotNull(async);
+        }
+
+        [Test]
+        public function verifyIAsyncInjection():void {
+            assertNotNull(iAsync);
+        }
+    }
+}
+

data/test/asunit/support/LegacyTestCase.as

@@ -0,0 +1,38 @@
+package asunit.support {
+    
+    import asunit.framework.TestCase;
+
+    public class LegacyTestCase extends TestCase {
+
+        public static var callCount:int;
+
+        private var instance:*;
+
+        override protected function setUp():void {
+            super.setUp();
+            instance = {};
+            instance.name = "foo";
+        }
+
+        override protected function tearDown():void {
+            super.tearDown();
+            instance = null;
+        }
+
+        public function testSomething():void {
+            assertEquals("foo", instance.name);
+        }
+
+        public function someNonTestMethod():void {
+            throw new Error("This should not be called");
+        }
+
+        [Test]
+        // Ensure this method only gets called once
+        // in a given test run...
+        public function testSomethingElse():void {
+            callCount++;
+        }
+    }
+}
+

data/test/asunit/support/MultiMethod.as

@@ -0,0 +1,77 @@
+package asunit.support {
+
+	import asunit.asserts.*;
+
+	import flash.display.Sprite;
+
+	public class MultiMethod {
+		
+		public static var methodsCalled:Array = [];
+
+		protected var sprite:Sprite;
+	
+		public function MultiMethod() {
+		}
+		
+		[BeforeClass]
+		public static function runBeforeClass1():void {
+			methodsCalled.push(arguments.callee);
+		}
+		
+		[BeforeClass]
+		public static function runBeforeClass2():void {
+			methodsCalled.push(arguments.callee);
+		}
+		
+		[Before]
+		public function runBefore1():void {
+			methodsCalled.push(arguments.callee);
+			sprite = new Sprite();
+		}
+		
+		[Before]
+		public function runBefore2():void {
+			methodsCalled.push(arguments.callee);
+		}
+		
+		[After]
+		public function runAfter1():void {
+			methodsCalled.push(arguments.callee);
+			sprite = null;
+		}
+		
+		[After]
+		public function runAfter2():void {
+			methodsCalled.push(arguments.callee);
+		}
+		
+		[Test]
+		public function numChildren_is_0_by_default():void {
+			methodsCalled.push(arguments.callee);
+			assertEquals(0, sprite.numChildren);
+		}
+		
+		[Test]
+		public function stage_is_null_by_default():void {
+			methodsCalled.push(arguments.callee);
+			assertNull(sprite.stage);
+		}
+		
+		[Test]
+		public function fail_assertEquals():void {
+			methodsCalled.push(arguments.callee);
+			assertEquals('wrongName', sprite.name);
+		}
+		
+		[AfterClass]
+		public static function runAfterClass1():void {
+			methodsCalled.push(arguments.callee);
+		}
+		
+		[AfterClass]
+		public static function runAfterClass2():void {
+			methodsCalled.push(arguments.callee);
+		}
+	}
+}
+

data/test/asunit/support/OrderedTestMethod.as

@@ -0,0 +1,36 @@
+package asunit.support {
+
+	import asunit.asserts.*;
+
+	import flash.display.Sprite;
+
+	public class OrderedTestMethod {
+		
+		public var methodsCalled:Array = [];
+	
+		public function OrderedTestMethod() {
+		}
+		
+		// Method names are chosen to avoid coinciding with alphabetical order.
+		
+		[Test(order=2)]
+		public function two():void {
+			methodsCalled.push(arguments.callee);
+		}
+		
+		[Test(order=3)]
+		public function three():void {
+			methodsCalled.push(arguments.callee);
+		}
+		
+		[Test]
+		public function zeroIsDefaultOrder():void {
+			methodsCalled.push(arguments.callee);
+		}
+		
+		[Test(order=-1)]
+		public function negativeOrderIsAllowed():void {
+			methodsCalled.push(arguments.callee);
+		}
+	}
+}

data/test/asunit/support/RunWithButNoType.as

@@ -0,0 +1,14 @@
+package asunit.support {
+    
+    import asunit.asserts.*;
+
+    [RunWith]
+    public class RunWithButNoType {
+
+        [Test]
+        public function simplePassing():void {
+            assertTrue("This will pass, we're interested in the RunWith", true);
+        } 
+    }
+}
+

data/test/asunit/support/RunWithSuiteButNoType.as

@@ -0,0 +1,11 @@
+package asunit.support {
+
+    [RunWith]
+    [Suite]
+    public class RunWithSuiteButNoType {
+
+        // Just used to indicate this is a Suite:
+        public var testCase:SucceedAssertTrue;
+    }
+}
+

data/test/asunit/support/SingleErrorSuite.as

@@ -0,0 +1,7 @@
+package asunit.support {
+		
+	[Suite]
+	public class SingleErrorSuite {
+		public var errorInMethodTest:ErrorInMethod;
+	}
+}

data/test/asunit/support/SingleSuccessSuite.as

@@ -0,0 +1,7 @@
+package asunit.support {
+		
+	[Suite]
+	public class SingleSuccessSuite {
+		public var succeedAssertTrue:SucceedAssertTrue;
+	}
+}

data/test/asunit/support/SucceedAssertTrue.as

@@ -0,0 +1,31 @@
+package asunit.support {
+
+	import asunit.asserts.*;
+
+	public class SucceedAssertTrue{
+		
+		public var methodsCalled:Array;
+		
+		public function SucceedAssertTrue() {
+			methodsCalled = [];
+		}
+		
+		[Before]
+		public function runBefore():void {
+			methodsCalled.push(arguments.callee);
+		}
+		
+		[After]
+		public function runAfter():void {
+			methodsCalled.push(arguments.callee);
+		}
+		
+		[Test]
+		public function succeed_assertTrue():void {
+			methodsCalled.push(arguments.callee);
+			assertTrue(true);
+		}
+		
+	}
+
+}

data/test/asunit/support/SuiteOfTwoSuites.as

@@ -0,0 +1,8 @@
+package asunit.support {
+		
+	[Suite]
+	public class SuiteOfTwoSuites {
+		public var singleSuccessSuite:SingleSuccessSuite;
+		public var doubleFailSuite:DoubleFailSuite;
+	}
+}

data/test/asunit/support/SuiteWithCustomRunner.as

@@ -0,0 +1,12 @@
+package asunit.support {
+
+    [Suite]
+    [RunWith("asunit.support.CustomTestRunner")]
+    public class SuiteWithCustomRunner {
+
+        public var succeedAssertTrue:SucceedAssertTrue;
+		public var singleSuccessSuite:SingleSuccessSuite;
+        public var multiMethod:MultiMethod;
+    }
+}
+

data/test/asunit/support/SuiteWithOneCustomChildSuite.as

@@ -0,0 +1,10 @@
+package asunit.support {
+
+    [Suite]
+    public class SuiteWithOneCustomChildSuite {
+
+        public var suiteWithCustomRunner:SuiteWithCustomRunner;
+		public var orderedTestMethod:OrderedTestMethod;
+    }
+}
+

data/test/asunit/support/TestForFakeRunner.as

@@ -0,0 +1,14 @@
+package asunit.support {
+
+    // Declare a fully-qualified runner for this test case:
+    [RunWith("asunit.support::FakeRunner")]
+    public class TestForFakeRunner {
+
+        private var runnerReference:FakeRunner;
+
+        public function customTestMethod():int {
+            throw new Error("This method shouldn't really get called");
+        }
+    }
+}
+

data/test/asunit/util/ArrayIteratorTest.as

@@ -0,0 +1,65 @@
+package asunit.util {
+    import asunit.framework.TestCase;
+
+    public class ArrayIteratorTest extends TestCase {
+        private var itr:ArrayIterator;
+
+        public function ArrayIteratorTest(testMethod:String = null) {
+            super(testMethod);
+        }
+
+        protected override function setUp():void {
+            itr = new ArrayIterator(getSimpleArray(5));
+        }
+        
+        private function getSimpleArray(count:Number):Array {
+            var arr:Array = new Array();
+            for(var i:Number = 0; i < count; i++) {
+                arr.push("item-" + i);
+            }
+            return arr;
+        }
+
+        protected override function tearDown():void {
+            itr = null;
+        }
+
+        public function testInstantiated():void {
+            assertTrue("ArrayIterator instantiated", itr is ArrayIterator);
+        }
+
+        public function testHasNext():void {
+            assertTrue(itr.hasNext());
+        }
+        
+        public function testNext():void {
+            assertEquals("item-0", itr.next());
+        }
+        
+        public function testNextTwice():void {
+            assertEquals("item-0", itr.next());
+            assertEquals("item-1", itr.next());
+        }
+        
+        public function testLast():void {
+            assertTrue(itr.hasNext());
+            assertEquals("item-0", itr.next());
+            assertTrue(itr.hasNext());
+            assertEquals("item-1", itr.next());
+            assertTrue(itr.hasNext());
+            assertEquals("item-2", itr.next());
+            assertTrue(itr.hasNext());
+            assertEquals("item-3", itr.next());
+            assertTrue(itr.hasNext());
+            assertEquals("item-4", itr.next());
+            assertFalse(itr.hasNext());
+        }
+        
+        public function testReset():void {
+            testLast();
+            itr.reset();
+            assertTrue(itr.hasNext());
+            assertEquals("item-0", itr.next());
+        }
+    }
+}

data/vendor/as3reflection/README

@@ -0,0 +1,7 @@
+These source files should be merged with the src path in the source 
+distribution of AsUnit, but when compiling, developing and testing
+AsUnit, we should always build against the lib/Reflection.swc
+
+These files are being included simply to avoid making users add
+another SWC to their library-path.
+