asunit4 4.2.1.pre

data/src/asunit/runners/TestRunner.as

@@ -0,0 +1,403 @@
+package asunit.runners {
+
+    import asunit.events.TimeoutCommandEvent;
+    import asunit.framework.Assert;
+    import asunit.framework.Async;
+    import asunit.framework.CallbackBridge;
+    import asunit.framework.IAsync;
+    import asunit.framework.IResult;
+    import asunit.framework.IRunner;
+	import asunit.framework.IRunnerFactory;
+    import asunit.framework.Method;
+    import asunit.framework.TestFailure;
+    import asunit.framework.TestIterator;
+    import asunit.framework.TestSuccess;
+    import asunit.framework.TestWarning;
+    import asunit.util.ArrayIterator;
+    import asunit.util.Iterator;
+
+    import flash.display.DisplayObjectContainer;
+    import flash.errors.IllegalOperationError;
+    import flash.events.Event;
+    import flash.events.EventDispatcher;
+    import flash.events.IEventDispatcher;
+    import flash.events.TimerEvent;
+    import flash.utils.Timer;
+    import flash.utils.clearTimeout;
+    import flash.utils.getDefinitionByName;
+    import flash.utils.getTimer;
+    import flash.utils.setTimeout;
+
+    import p2.reflect.Reflection;
+    import p2.reflect.ReflectionMember;
+    import p2.reflect.ReflectionMetaData;
+    import p2.reflect.ReflectionVariable;
+
+    public class TestRunner extends EventDispatcher implements IRunner {
+        public static var ASYNC_NAME:String = 'asunit.framework::Async';
+        public static var IASYNC_NAME:String = 'asunit.framework::IAsync';
+        public static var DISPLAY_OBJECT_CONTAINER:String = 'flash.display::DisplayObjectContainer';
+
+        /**
+         * This is how the Runner connects to a printer.
+         * The AsUnitCore will inject the requested bridge
+         * based on the concrete data type.
+         *
+         * There should be a similar Injection point on
+         * whatever printers are interested in what this
+         * concrete runner will dispatch.
+         */
+        [Inject]
+        public var bridge:CallbackBridge;
+
+        // partially exposed for unit testing
+        internal var currentTest:Object;
+        internal var async:IAsync;
+
+        protected var asyncMembers:Iterator;
+        protected var currentMethod:Method;
+        protected var currentTestReflection:Reflection;
+        protected var injectableMembers:Iterator;
+        protected var methodIsExecuting:Boolean = false;
+        protected var methodPassed:Boolean = true;
+        protected var methodTimeoutID:Number;
+        protected var methodsToRun:TestIterator;
+        protected var startTime:Number;
+        protected var testMethodNameReceived:Boolean;
+        protected var timer:Timer;
+        protected var visualContext:DisplayObjectContainer;
+        protected var visualInstances:Array;
+
+        private var _factory:IRunnerFactory;
+
+        public function TestRunner() {
+            async  = new Async();
+            bridge = new CallbackBridge();
+            timer  = new Timer(0, 1);
+            timer.addEventListener(TimerEvent.TIMER, runNextMethod);
+            visualInstances = [];
+        }
+
+        public function run(testOrSuite:Class, methodName:String=null, visualContext:DisplayObjectContainer=null):void {
+            runMethodByName(testOrSuite, methodName, visualContext);
+        }
+
+        public function shouldRunTest(testClass:Class):Boolean {
+            return bridge.shouldRunTest(testClass);
+        }
+
+        // This class doesn't really use the runner factory,
+        // since it represents a leaf node in the test
+        // hierarchy...
+        public function set factory(factory:IRunnerFactory):void {
+            _factory = factory;
+        }
+
+        public function get factory():IRunnerFactory {
+            return _factory;
+        }
+
+        public function runMethodByName(test:Class, methodName:String=null, visualContext:DisplayObjectContainer=null):void {
+            currentTestReflection  = Reflection.create(test);
+            this.visualContext     = visualContext;
+            currentMethod          = null;
+            testMethodNameReceived = (methodName != null);
+
+            try {
+                currentTest            = new test();
+            }
+            catch(e:VerifyError) {
+                warn("Unable to instantiate provided test case with: " + currentTestReflection.name);
+                return;
+            }
+
+            initializeInjectableMembers();
+            
+            async.addEventListener(TimeoutCommandEvent.CALLED,     onAsyncMethodCalled);
+            async.addEventListener(TimeoutCommandEvent.TIMED_OUT,  onAsyncMethodTimedOut);
+            
+            startTime = getTimer();
+            bridge.onTestStarted(currentTest);
+            
+            methodsToRun = createTestIterator(currentTest, methodName);
+
+            if(methodsToRun.length == 0) {
+                warn(">> We were unable to find any test methods in " + currentTestReflection.name + ". Did you set the --keep-as3-metadata flag?");
+            }
+            runNextMethod();
+        }
+
+        protected function createTestIterator(test:*, testMethodName:String):TestIterator {
+            return new TestIterator(test, testMethodName);
+        }
+
+        protected function initializeInjectableMembers():void {
+            injectableMembers = new ArrayIterator(currentTestReflection.getMembersByMetaData('Inject'));
+        }
+
+        protected function runNextMethod(e:TimerEvent = null):void {
+            if(!testMethodNameReceived && methodsToRun.readyToTearDown) {
+                removeInjectedMembers();
+                removeInjectedVisualInstances();
+            }
+            
+            if (testCompleted) {
+                onTestCompleted();
+                return;
+            }
+
+            if(methodsToRun.readyToSetUp) {
+                prepareForSetUp();
+            }
+
+            runMethod(methodsToRun.next());
+        }
+        
+        protected function runMethod(method:Method):void {
+            if (!method) return;
+            currentMethod = method;
+            methodPassed = true; // innocent until proven guilty by recordFailure()
+            
+            if (currentMethod.ignore) {
+                bridge.onTestIgnored(currentMethod);
+                onMethodCompleted();
+                return;
+            }
+
+            // This is used to prevent async callbacks from triggering onMethodCompleted too early.
+            methodIsExecuting = true;
+            
+            if (currentMethod.expects) {
+                try {
+                    var errorClass:Class = getDefinitionByName(currentMethod.expects) as Class;
+                    Assert.assertThrows(errorClass, currentMethod.value);
+                }
+                catch(definitionError:ReferenceError) {
+                    // NOTE: [luke] Added ReferenceError catch here b/c I had a bad class name in my expects.
+                    // Does this look right?
+                    recordFailure(new Error('Could not find Reference for: ' + currentMethod.expects));
+                }
+                catch (error:Error) {
+                    recordFailure(error);
+                }
+            }
+            else {
+                try {
+                    currentMethod.execute();
+                }
+                catch (error:Error) {
+                    recordFailure(error);
+                }
+            }
+            
+            methodIsExecuting = false;
+            
+            if (async.hasPending) return;
+
+            onMethodCompleted();
+        }
+
+        protected function onMethodCompleted():void {
+            async.cancelPending();
+            
+            if (currentMethod.isTest && methodPassed && !currentMethod.ignore) {
+                bridge.onTestSuccess(new TestSuccess(currentTest, currentMethod.name));
+            }
+
+            // Calling synchronously is faster but keeps adding to the call stack.
+            //runNextMethod();
+            
+            // green thread for runNextMethod()
+            // This runs much slower in Flash Player 10.1.
+            timer.reset();
+            timer.start();
+        }
+        
+        protected function onAsyncMethodCalled(event:TimeoutCommandEvent):void {
+            try {
+                event.command.execute();
+            }
+            catch (error:Error) {
+                recordFailure(error);
+            }
+            onAsyncMethodCompleted(event);
+        }
+        
+        protected function onAsyncMethodTimedOut(event:TimeoutCommandEvent):void {
+            var error:IllegalOperationError = new IllegalOperationError("Timeout (" + event.command.duration + "ms) exceeded on an asynchronous operation.");
+            recordFailure(error);
+            onAsyncMethodCompleted(event);
+        }
+        
+        protected function recordFailure(error:Error):void {
+            methodPassed = false;
+            bridge.onTestFailure(new TestFailure(currentTest, currentMethod.name, error));
+        }
+
+        protected function onAsyncMethodCompleted(event:Event = null):void {
+            if (!methodIsExecuting && !async.hasPending) {
+                onMethodCompleted();
+            }
+        }
+        
+        protected function onTestCompleted():void {
+            async.removeEventListener(TimeoutCommandEvent.CALLED,      onAsyncMethodCalled);
+            async.removeEventListener(TimeoutCommandEvent.TIMED_OUT,   onAsyncMethodTimedOut);
+            async.cancelPending();
+            
+            bridge.onTestCompleted(currentTest);
+            
+            dispatchEvent(new Event(Event.COMPLETE));
+        }
+        
+        protected function get testCompleted():Boolean {
+            return (!methodsToRun.hasNext() && !async.hasPending);
+        }
+
+        protected function removeInjectedMembers():void {
+            var member:ReflectionVariable;
+            while(injectableMembers.hasNext()) {
+                removeInjectedMember(injectableMembers.next());
+            }
+            injectableMembers.reset();
+        }
+
+        protected function removeInjectedVisualInstances():void {
+            var visuals:Iterator = new ArrayIterator(visualInstances);
+            while(visuals.hasNext()) {
+                visualContext.removeChild(visuals.next());
+            }
+            visualInstances = [];
+        }
+
+        protected function removeInjectedMember(member:ReflectionVariable):void {
+            if(!member) return;
+            currentTest[member.name] = null;
+        }
+
+        protected function prepareForSetUp():void {
+            injectMembers();
+        }
+
+        protected function injectMembers():void {
+            var member:ReflectionVariable;
+            while(injectableMembers.hasNext()) {
+                injectMember(injectableMembers.next());
+            }
+            injectableMembers.reset();
+        }
+
+        protected function injectMember(member:ReflectionVariable):void {
+            if(!member) return;
+            var definition:Class;
+            try {
+                definition = getDefinitionByName(member.type) as Class;
+            }
+            catch(referenceError:ReferenceError) {
+                warn("Unable to [Inject] with " + member.type + ". Maybe this was an inner class? That makes it unavailable to external code, try putting it in it's own file.");
+                return;
+            }
+            var reflection:Reflection = Reflection.create(definition);
+            try {
+                var instance:* = createInstanceFromReflection(reflection);
+                configureInjectedInstance(member, instance);
+                currentTest[member.name] = instance;
+            }
+            catch(e:VerifyError) {
+                throw new VerifyError("Failed to instantiate " + member.type + " in order to inject public var " + member.name);
+            }
+        }
+
+        protected function configureInjectedInstance(member:ReflectionVariable, instance:*):void {
+            var injectTag:ReflectionMetaData = member.getMetaDataByName('Inject');
+            var args:Array = injectTag.args;
+            var arg:Object;
+            var len:int = args.length;
+            for(var i:int; i < len; i++) {
+                arg = args[i];
+                try {
+                    instance[arg.key] = coerceArgumentType(member, arg.value);
+                }
+                catch(e:ReferenceError) {
+                    var reflect:Reflection = Reflection.create(instance);
+                    warn("Unable to inject attribute " + arg.key + " on " + reflect.name);
+                }
+            }
+        }
+
+        protected function coerceArgumentType(member:ReflectionVariable, value:String):* {
+            switch(value) {
+                case "false" :
+                    return false;
+                case "true" :
+                    return true;
+            }
+
+            return value;
+        }
+
+        protected function createInstanceFromReflection(reflection:Reflection):* {
+            // Return the shared async instance if they're expecting the interface
+            // or concrete instance, but NOT if their Inject is merely a subclass...
+            if(reflection.name == ASYNC_NAME || reflection.name == IASYNC_NAME) {
+                return async;
+            }
+
+            var clazz:Class = getClassReferenceFromReflection(reflection);
+            var constructorReflection:Reflection = Reflection.create(clazz);
+            try {
+                var instance:* = new constructorReflection.classReference();
+            }
+            catch(e:VerifyError) {
+                warn("Unable to instantiate: " + reflection.name + " for injection");
+            }
+
+            if(constructorReflection.isA(DISPLAY_OBJECT_CONTAINER)) {
+                // Add injected DisplayObjectContainers to a collection
+                // for removal, and add them to the visualContext if
+                // one was provided to the run() method.
+                if(visualContext) {
+                    visualInstances.push(instance);
+                    visualContext.addChild(instance);
+                } 
+                else {
+                    warn("TestRunner is injecting a DisplayObjectContainer on your Test but wasn't given a visualContext when run was called. This means your visual entity will not be attached to the Display List.");
+                }
+            }
+
+            return instance;
+        }
+
+        protected function warn(message:String, method:Method=null):void {
+            bridge.onWarning(new TestWarning(message, method));
+        }
+
+        protected function getClassReferenceFromReflection(reflection:Reflection):Class {
+            // This will attempt to deal with I-prefixed interfaces - like IAsync.
+            if(reflection.isInterface) {
+                return attemptToGetClassReferenceFromReflection(reflection);
+            }
+            return reflection.classReference;
+        }
+
+        protected function attemptToGetClassReferenceFromReflection(reflection:Reflection):Class {
+            var fullName:String = reflection.name;
+            var parts:Array = fullName.split("::");
+            var interfaceName:String = parts.pop();
+            var expr:RegExp = /I([AZ].+)/;
+            var match:Object = expr.exec(interfaceName);
+            if(match) {
+                parts.push(match[1]);
+                var implementationName:String = parts.join("::");
+                return Class(getDefinitionByName(implementationName));
+            }
+            throw new VerifyError("Unable to find class instance for interface " + fullName);
+        }
+
+        // TODO: Implement this method:
+        protected function argumentFreeConstructor(reflection:Reflection):Boolean {
+            return true;
+        }
+    }
+}
+

data/src/asunit/util/ArrayIterator.as

@@ -0,0 +1,30 @@
+package asunit.util {
+
+    import asunit.util.Iterator;
+
+    [ExcludeClass]
+    public class ArrayIterator implements Iterator {
+        private var items:Array;
+        private var index:Number = 0;
+
+        public function ArrayIterator(items:Array=null) {
+            this.items = items || [];
+        }
+
+        public function hasNext():Boolean {
+            return items[index] != null;
+        }
+
+        public function next():* {
+            return items[index++];
+        }
+
+        public function get length():uint {
+            return items.length;
+        }
+
+        public function reset():void {
+            index = 0;
+        }
+    }
+}

data/src/asunit/util/Iterator.as

@@ -0,0 +1,10 @@
+package asunit.util {
+
+    [ExcludeClass]
+    public interface Iterator {
+        function next():*;
+        function hasNext():Boolean;
+        function reset():void;
+        function get length():uint;
+    }
+}

data/test/AllTests.as

@@ -0,0 +1,73 @@
+package {
+	/**
+	 * This file has been automatically created using
+	 * #!/usr/bin/ruby script/generate suite
+	 * If you modify it and run this script, your
+	 * modifications will be lost!
+	 */
+    
+    import asunit.core.AsUnitCoreTest;
+    import asunit.framework.AssertEqualsArraysIgnoringOrderTest;
+    import asunit.framework.AssertEqualsArraysTest;
+    import asunit.framework.AssertTest;
+    import asunit.framework.AssertThrowsTest;
+    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.ResultTest;
+    import asunit.framework.RunnerFactoryTest;
+    import asunit.framework.SuiteIteratorTest;
+    import asunit.framework.TestIteratorIgnoredMethodTest;
+    import asunit.framework.TestIteratorMethodByNameTest;
+    import asunit.framework.TestIteratorMultiMethodTest;
+    import asunit.framework.TestIteratorOrderedTestMethodTest;
+    import asunit.framework.TestIteratorSingleMethodTest;
+    import asunit.framework.VisualTestCaseTest;
+    import asunit.printers.TextPrinterTest;
+    import asunit.runners.LegacyRunnerTest;
+    import asunit.runners.SuiteRunnerTest;
+    import asunit.runners.TestRunnerAsyncMethodTest;
+    import asunit.runners.TestRunnerErrorMethodTest;
+    import asunit.runners.TestRunnerExpectsErrorTest;
+    import asunit.runners.TestRunnerIgnoredMethodTest;
+    import asunit.runners.TestRunnerTest;
+    import asunit.util.ArrayIteratorTest;
+
+    [Suite]
+	public class AllTests {
+        
+        public var asunit_core_AsUnitCoreTest:asunit.core.AsUnitCoreTest;
+        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_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_ResultTest:asunit.framework.ResultTest;
+        public var asunit_framework_RunnerFactoryTest:asunit.framework.RunnerFactoryTest;
+        public var asunit_framework_SuiteIteratorTest:asunit.framework.SuiteIteratorTest;
+        public var asunit_framework_TestIteratorIgnoredMethodTest:asunit.framework.TestIteratorIgnoredMethodTest;
+        public var asunit_framework_TestIteratorMethodByNameTest:asunit.framework.TestIteratorMethodByNameTest;
+        public var asunit_framework_TestIteratorMultiMethodTest:asunit.framework.TestIteratorMultiMethodTest;
+        public var asunit_framework_TestIteratorOrderedTestMethodTest:asunit.framework.TestIteratorOrderedTestMethodTest;
+        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_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_TestRunnerIgnoredMethodTest:asunit.runners.TestRunnerIgnoredMethodTest;
+        public var asunit_runners_TestRunnerTest:asunit.runners.TestRunnerTest;
+        public var asunit_util_ArrayIteratorTest:asunit.util.ArrayIteratorTest;
+	}
+}
+

data/test/AsUnitRunner.as

@@ -0,0 +1,15 @@
+package {
+
+    import asunit.core.TextCore;
+    import flash.display.MovieClip;
+
+	public class AsUnitRunner extends MovieClip {
+	    
+        private var core:TextCore;
+
+        public function AsUnitRunner() {
+            core = new TextCore();
+            core.start(AllTests, null, this);
+        }
+    }
+}

data/test/Flex3Runner.mxml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<mx:Application 
+	xmlns:mx="http://www.adobe.com/2006/mxml" 
+	layout="absolute" 
+	minWidth="640" 
+	minHeight="480"
+    backgroundColor="#333333"
+    backgroundImage=""
+	creationComplete="creationCompleteHandler(event)"
+	>
+	<mx:Script>
+		<![CDATA[
+            import asunit.core.TextCore;
+
+            private var core:TextCore;
+			
+			private function creationCompleteHandler(event:Event):void {
+                core = new TextCore();
+                core.start(AllTests, null, visualContext);
+			}
+		]]>
+	</mx:Script>
+    <mx:UIComponent id="visualContext" width="100%" height="100%" />
+</mx:Application>

data/test/Flex4Runner.mxml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
+			   xmlns:s="library://ns.adobe.com/flex/spark" 
+			   xmlns:mx="library://ns.adobe.com/flex/mx" 
+               minWidth="955" 
+               minHeight="600"
+               creationComplete="creationCompleteHandler(event)"
+               >
+	<fx:Script>
+		<![CDATA[
+            import asunit.core.TextCore;
+            import mx.core.UIComponent;
+
+            private var core:TextCore;
+			
+			private function creationCompleteHandler(event:Event):void {
+                // Flex 4 complains when we use UICompenent from MXML... Boo.
+                var visualContext:UIComponent = new UIComponent();
+                addElement(visualContext);
+
+                core = new TextCore();
+                core.start(AllTests, null, visualContext);
+			}
+		]]>
+	</fx:Script>
+</s:Application>
+

data/test/asunit/core/AsUnitCoreTest.as

@@ -0,0 +1,97 @@
+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.SuiteWithCustomRunner;
+    import asunit.support.SuiteWithOneCustomChildSuite;
+    import asunit.support.SucceedAssertTrue;
+
+    import flash.display.Sprite;
+    import flash.events.Event;
+
+    public class AsUnitCoreTest {
+
+        [Inject]
+        public var async:IAsync;
+
+        [Inject]
+        public var core:AsUnitCore;
+
+        [Inject]
+        public var context:Sprite;
+
+        [After]
+        public function cleanUpStatics():void {
+            CustomTestRunner.runCalledCount = 0;
+        }
+
+        [Test]
+        public function shouldBeInstantiated():void {
+            assertTrue("core is AsUnitCore", core is AsUnitCore);
+        }
+
+        [Test]
+        public function startShouldWork():void {
+            core.start(SucceedAssertTrue);
+        }
+
+        [Test]
+        public function setVisualContextShouldWork():void {
+            core.visualContext = context;
+            assertEquals(context, core.visualContext);
+        }
+
+        [Test]
+        public function textPrinterShouldWork():void {
+            var printer:TextPrinter = new TextPrinter();
+            printer.traceOnComplete = false;
+            core.addObserver(printer);
+
+            // Wait for the complete event:
+            var handler:Function = function(event:Event):void {
+                var output:String = printer.toString();
+                assertTrue("should include test summary", output.indexOf('OK (1 test)') > -1);
+                assertTrue("should include provided test name", output.indexOf('asunit.support::SucceedAssertTrue') > -1);
+            }
+
+            core.addEventListener(Event.COMPLETE, async.add(handler));
+            core.start(SucceedAssertTrue);
+        }
+
+        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";
+                // This is the number of Tests that will used the custom Runner:
+                assertEquals(message, testCaseCount, CustomTestRunner.runCalledCount);
+                // This is the number of test methods:
+                assertEquals("Total Test Count", testMethodCount, core.bridge.runCount);
+            }
+
+            core.addEventListener(Event.COMPLETE, async.add(handler));
+            core.start(Suite);
+        }
+
+        [Test]
+        public function shouldAssignRunWithUsingOuterSuite():void {
+            // This will work b/c the RunWith is on the outer Suite:
+            var testCaseCount:int = 2;
+            var testMethodCount:int = 4;
+            verifyRunWithOnASuite(SuiteWithCustomRunner, testCaseCount, testMethodCount);
+        }
+
+        [Ignore(description="This doesn't work because we discard the hierarchy of Suites in the SuiteIterator")]
+        [Test]
+        public function shouldAssignRunWithUsingChildSuite():void {
+            // This will work b/c the RunWith is on the outer Suite:
+            var testCaseCount:int = 2;
+            var testMethodCount:int = 4;
+            verifyRunWithOnASuite(SuiteWithOneCustomChildSuite, testCaseCount, testMethodCount);
+        }
+    }
+}