asunit4 4.2.2.pre → 4.2.3.pre

data/src/asunit/printers/TextPrinter.as

@@ -17,28 +17,31 @@ package asunit.printers {
     import flash.text.TextFormat;
     import flash.utils.getQualifiedClassName;
     import flash.utils.getTimer;
-    import asunit.framework.CallbackBridge;
 
     public class TextPrinter extends Sprite implements IRunListener {
-        public static var LOCAL_PATH_PATTERN:RegExp = /([A-Z]:\\[^\/:\*\?<>\|]+\.\w{2,6})|(\\{2}[^\/:\*\?<>\|]+\.\w{2,6})/g;
-        public static var BACKGROUND_COLOR:uint = 0x333333;
-        public static var DEFAULT_HEADER:String = "AsUnit 4.0 by Luke Bayes, Ali Mills and Robert Penner\n\nFlash Player version: " + Capabilities.version
-        public static var FONT_SIZE:int = 12;
-        public static var TEXT_COLOR:uint = 0xffffff;
+        public static const LOCAL_PATH_PATTERN:RegExp = /([A-Z]:\\[^\/:\*\?<>\|]+\.\w{2,6})|(\\{2}[^\/:\*\?<>\|]+\.\w{2,6})/g;
+        public static const DEFAULT_BACKGROUND_COLOR:uint = 0x333333;
+        public static const DEFAULT_HEADER:String = "AsUnit 4.0 by Luke Bayes, Ali Mills and Robert Penner\n\nFlash Player version: " + Capabilities.version
+        public static const DEFAULT_FOOTER:String = "";
+        public static const DEFAULT_FONT_SIZE:int = 12;
+        public static const DEFAULT_PERFORMANCE_COUNT:int = 10;
+        public static const DEFAULT_TEXT_COLOR:uint = 0xffffff;
 
-        public var backgroundColor:uint              = BACKGROUND_COLOR;
+        public var header:String                     = DEFAULT_HEADER;
+        public var footer:String                     = DEFAULT_FOOTER;
+        public var backgroundColor:uint              = DEFAULT_BACKGROUND_COLOR;
+        public var textColor:uint                    = DEFAULT_TEXT_COLOR;
         public var displayPerformanceDetails:Boolean = true;
-        public var localPathPattern:RegExp;
-        public var textColor:uint                    = TEXT_COLOR;
         public var traceOnComplete:Boolean           = true;
+        public var hideLocalPaths:Boolean            = false;
+        public var localPathPattern:RegExp           = LOCAL_PATH_PATTERN;
+        public var performanceCount:int              = DEFAULT_PERFORMANCE_COUNT;
 
         protected var textDisplay:TextField;
 
         private var backgroundFill:Shape;
         private var dots:Array;
         private var failures:Array;
-        private var footer:String;
-        private var header:String;
         private var ignores:Array;
         private var resultBar:Shape;
         private var resultBarHeight:uint = 3;
@@ -48,34 +51,6 @@ package asunit.printers {
         private var testTimes:Array;
         private var warnings:Array;
 
-        /**
-         * The bridge provides the connection between the printer
-         * and the Runner(s) that it's interested in.
-         *
-         * Generally, a bridge can observe Runners, and build up
-         * state over the course of a test run.
-         *
-         * If you create a custom Runner, Printer and Bridge,
-         * you can decide to manage notifications however you wish.
-         *
-         */
-		private var _bridge:CallbackBridge;
-		
-		[Inject]
-		public function set bridge(value:CallbackBridge):void
-		{
-			if (value !== _bridge)
-			{
-				_bridge = value;
-				_bridge.addObserver(this);
-			}
-		}
-
-		public function get bridge():CallbackBridge
-		{
-			return _bridge;
-		}
-		
         public function TextPrinter() {
             initialize();
         }
@@ -88,10 +63,6 @@ package asunit.printers {
             testTimes = [];
             warnings  = [];
             
-            footer           = '';
-            header           = DEFAULT_HEADER;
-            localPathPattern = LOCAL_PATH_PATTERN;
-
             if(stage) {
                 initializeDisplay();
             } else {
@@ -117,7 +88,7 @@ package asunit.printers {
         private function getFailureStackTrace(failure:ITestFailure):String {
             var stack:String = "";
             stack = failure.thrownException.getStackTrace();
-            //stack = stack.replace(localPathPattern, '');
+			if (hideLocalPaths) stack = stack.replace(localPathPattern, '');
             stack = stack.replace(/AssertionFailedError: /, '');
             stack += "\n\n";
             return stack;
@@ -218,7 +189,7 @@ package asunit.printers {
             println();
             println('Time Summary:');
             println();
-            var len:Number = testTimes.length;
+            var len:Number = Math.min(performanceCount, testTimes.length);
             var total:Number = 0;
             var testTime:Object;
             for (var i:Number = 0; i < len; i++) {
@@ -310,7 +281,7 @@ package asunit.printers {
 
             var format:TextFormat = textDisplay.getTextFormat();
             format.font           = '_sans';
-            format.size           = FONT_SIZE;
+            format.size           = DEFAULT_FONT_SIZE;
             format.leftMargin     = 5;
             format.rightMargin    = 5;
             textDisplay.defaultTextFormat = format;

data/src/asunit/printers/XMLPrinter.as

@@ -0,0 +1,127 @@
+
+package asunit.printers {
+	import asunit.framework.ITestFailure;
+	import asunit.framework.ITestWarning;
+	import asunit.framework.IResult;
+	import asunit.framework.IRunListener;
+	import asunit.framework.ITestSuccess;
+	import asunit.framework.Method;
+
+	import flash.events.Event;
+	import flash.events.IOErrorEvent;
+	import flash.events.SecurityErrorEvent;
+	import flash.utils.getQualifiedClassName;
+
+    /**
+    *   The <code>XMLPrinter</code> is used to transform AsUnit test results
+    *   to JUnit-compatible XML content.
+    *   
+    *   This printer will send JUnit-compatible XML content to trace output. The XML content
+    *   will be enclosed by '&lt;TestResults/&gt;' tags.
+    **/
+	public class XMLPrinter implements IRunListener {
+        public var traceResults:Boolean = true;
+
+		protected var projectName:String;
+		protected var contextName:String;
+		protected var messageQueue:Array;
+        protected var testPrefix:String = "<TestResults>";
+        protected var testSuffix:String = "</TestResults>";
+		
+		public function XMLPrinter(projectName:String = '', contextName:String = '') {
+			this.projectName = projectName;
+			this.contextName = contextName;
+			messageQueue = [];
+        }
+
+        public function onRunStarted():void {
+            if (testPrefix) {
+                sendMessage(testPrefix);
+            }
+			sendMessage("<startTestRun totalTestCount='0' projectName='" + projectName
+				+ "' contextName='" + contextName +"' />");
+        }
+
+        public function onRunCompleted(result:IResult):void {
+			sendMessage('<endOfTestRun />');
+
+            if (testSuffix) {
+                sendMessage("</TestResults>");
+            }
+
+            if (traceResults) {
+                trace(toString());
+            }
+        }
+
+		public function onTestStarted(test:Object):void {
+		}
+		
+		public function onTestCompleted(test:Object):void {
+        }
+		
+		// works for both errors and failures
+		public function onTestFailure(failure:ITestFailure):void {
+			sendMessage(getFailureMessage(failure));
+		}
+		
+		public function onTestSuccess(success:ITestSuccess):void {
+			var xmlMessageSuccess:String = "<testCase name='" + success.method
+				+ "' testSuite='" + getQualifiedClassName(success.test) + "' status='success'/>";
+			sendMessage(xmlMessageSuccess);
+		}
+		
+		public function onTestIgnored(method:Method):void {
+			var xmlMessageIgnore:String = "<testCase name='" + method.name
+				+ "' testSuite='" + getQualifiedClassName(method.scope) + "' status='ignore'/>";
+			sendMessage(xmlMessageIgnore);
+		}
+
+		public function onWarning(warning:ITestWarning):void {
+			var xmlMessage:String = "<testCase name='" + warning.method.name
+				+ "' testSuite='" + getQualifiedClassName(warning.method.scope) + "' status='warning'/>";
+			sendMessage(xmlMessage);
+		}
+		
+        public function toString():String {
+            return messageQueue.join("\n");
+        }
+		
+		protected function sendMessage(message:String):void {
+            messageQueue.push(message);
+        }
+
+		protected function getFailureMessage(failure:ITestFailure):String {
+			var status:String = failure.isFailure ? 'failure' : 'error';
+			var xml:String =
+				"<testCase name='" + failure.failedMethod
+				+ "' testSuite='" + getQualifiedClassName(failure.failedTest)
+				+ "' status='" + status + "'>"
+					+ "<failure type='" + getQualifiedClassName(failure.thrownException) + "' >"
+					
+						+ "<messageInfo>" + xmlEscapeMessage(failure.exceptionMessage)
+						+ "</messageInfo>"
+						
+						+ "<stackTraceInfo>" + xmlEscapeMessage(failure.thrownException.getStackTrace())
+						+ "</stackTraceInfo>"
+						
+					+ "</failure>"
+				+ "</testCase>";
+
+			return xml;
+		}
+		
+		protected static function xmlEscapeMessage(message:String):String {
+			if (!message) return '';
+			
+			var escape:XML = <escape/>;
+			escape.setChildren( message );
+			return escape.children()[0].toXMLString();
+		}
+	}
+}
+
+
+
+
+

data/src/asunit/runners/LegacyRunner.as

@@ -1,11 +1,16 @@
 package asunit.runners {
 
+	import asunit.framework.IResult;
     import asunit.framework.LegacyTestIterator;
     import asunit.framework.TestIterator;
     
     public class LegacyRunner extends TestRunner {
         
-        override protected function createTestIterator(test:*, testMethodName:String):TestIterator {
+		public function LegacyRunner(result:IResult = null) {
+			super(result);
+		}
+        
+		override protected function createTestIterator(test:*, testMethodName:String):TestIterator {
             return new LegacyTestIterator(test, testMethodName);
         }
     }

data/src/asunit/runners/SuiteRunner.as

@@ -1,41 +1,41 @@
 package asunit.runners {
-    
-    import asunit.framework.CallbackBridge;
-    import asunit.framework.IResult;
-    import asunit.framework.IRunner;
-    import asunit.framework.IRunnerFactory;
-    import asunit.framework.RunnerFactory;
-    import asunit.util.Iterator;
-    import asunit.framework.SuiteIterator;
-
-    import flash.display.DisplayObjectContainer;
-    import flash.events.Event;
-    import flash.events.EventDispatcher;
-    import flash.events.IEventDispatcher;
-    import flash.events.TimerEvent;
-    import flash.utils.Timer;
-    import flash.utils.getDefinitionByName;
+	
+	import asunit.framework.IResult;
+	import asunit.framework.IRunner;
+	import asunit.framework.IRunnerFactory;
+	import asunit.framework.Result;
+	import asunit.framework.RunnerFactory;
+	import asunit.framework.SuiteIterator;
+	import asunit.util.Iterator;
+	import org.swiftsuspenders.Injector;
 
-    import p2.reflect.Reflection;
-    import p2.reflect.ReflectionMetaData;
-
-    public class SuiteRunner implements IEventDispatcher, IRunner {
+	import flash.display.DisplayObjectContainer;
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	import flash.events.TimerEvent;
+	import flash.utils.Timer;
+    
+    public class SuiteRunner extends EventDispatcher implements IRunner {
 
-		[Inject]
-        public var bridge:CallbackBridge;
+		public var result:IResult;
 		
-        protected var dispatcher:IEventDispatcher;
         protected var testClasses:Iterator;
         protected var timer:Timer;
         protected var visualContext:DisplayObjectContainer;
         protected var testMethod:String;
-
-        private var _factory:IRunnerFactory;
+ 		protected var injector:Injector;
+        protected var factory:IRunnerFactory;
         
-        public function SuiteRunner() {
-            timer      = new Timer(0, 1);
-            dispatcher = new EventDispatcher();
-        }
+        public function SuiteRunner(factory:IRunnerFactory = null, result:IResult = null, injector:Injector = null) {
+            timer = new Timer(0, 1);
+
+			this.injector = injector ||= new Injector();
+			injector.mapValue(Injector, injector);
+ 			this.result = result ||= new Result();
+			injector.mapValue(IResult, result);
+			this.factory = factory ||= injector.instantiate(RunnerFactory);
+ 			injector.mapValue(IRunnerFactory, factory);
+		}
         
         public function run(suite:Class, testMethod:String=null, visualContext:DisplayObjectContainer=null):void {
             this.visualContext = visualContext;
@@ -43,20 +43,8 @@ package asunit.runners {
             runSuite(suite);
         }
 
-        public function shouldRunTest(testClass:Class):Boolean {
-            return bridge.shouldRunTest(testClass);
-        }
-
-        public function set factory(factory:IRunnerFactory):void {
-            _factory = factory;
-        }
-
-        public function get factory():IRunnerFactory {
-            return _factory ||= new RunnerFactory();
-        }
-
         protected function runSuite(suite:*):void {
-            testClasses = new SuiteIterator(suite, bridge);
+            testClasses = new SuiteIterator(suite);
             timer.addEventListener(TimerEvent.TIMER, runNextTest);
             
             runNextTest();
@@ -97,29 +85,5 @@ package asunit.runners {
          */
         protected function onRunCompleted():void {
         }
-
-        // BEGIN: Implement the IEvent Dispatcher Interface:
-
-        public function addEventListener(type:String, listener:Function, useCapture:Boolean=false, priority:int=0, useWeakReference:Boolean=false):void {
-            dispatcher.addEventListener(type, listener, useCapture, priority, useWeakReference);
-        }
-        
-        public function removeEventListener(type:String, listener:Function, useCapture:Boolean=false):void {
-            dispatcher.removeEventListener(type, listener, useCapture);
-        }
-        
-        public function dispatchEvent(event:Event):Boolean {
-            return dispatcher.dispatchEvent(event);
-        }
-        
-        public function hasEventListener(type:String):Boolean {
-            return dispatcher.hasEventListener(type);
-        }
-        
-        public function willTrigger(type:String):Boolean {
-            return dispatcher.willTrigger(type);
-        }
-
-        // END: Implement the IEvent Dispatcher Interface:
     }
 }

data/src/asunit/runners/TestRunner.as

@@ -1,63 +1,52 @@
 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.events.TimeoutCommandEvent;
+	import asunit.framework.Assert;
+	import asunit.framework.Async;
+	import asunit.framework.IResult;
+	import asunit.framework.Result;
+	import asunit.framework.IAsync;
+	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;
+	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.Sprite;
+	import org.swiftsuspenders.Injector;
+
+	import p2.reflect.Reflection;
+	import p2.reflect.ReflectionMetaData;
+	import p2.reflect.ReflectionVariable;
+
+	import flash.display.DisplayObjectContainer;
+	import flash.errors.IllegalOperationError;
+	import flash.events.Event;
+	import flash.events.EventDispatcher;
+	import flash.events.TimerEvent;
+	import flash.utils.Timer;
+	import flash.utils.getDefinitionByName;
+	import flash.utils.getTimer;
 
     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;
+        
+		/**
+		 * 
+		 */
+		//TODO: perhaps add a getter for this to IRunner
+        public var result:IResult;
 
         // partially exposed for unit testing
         internal var currentTest:Object;
         internal var async:IAsync;
+		/** Supplies dependencies to tests, e.g. IAsync, context Sprite. */
+		internal var testInjector:Injector;
 
-        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;
@@ -68,100 +57,80 @@ package asunit.runners {
         protected var visualContext:DisplayObjectContainer;
         protected var visualInstances:Array;
 
-        private var _factory:IRunnerFactory;
-
-        public function TestRunner() {
+        public function TestRunner(result:IResult = null) {
             async  = new Async();
-            bridge = new CallbackBridge();
-            timer  = new Timer(0, 1);
-            timer.addEventListener(TimerEvent.TIMER, runNextMethod);
+            this.result = result ||= new Result();
+            testInjector = new Injector();
+			testInjector.mapValue(IAsync, async);
+			testInjector.mapValue(Async, async);
+            timer = new Timer(0, 1);
+            timer.addEventListener(TimerEvent.TIMER, runNextMethods);
             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 runMethodByName(testOrSuite:Class, methodName:String=null, visualContext:DisplayObjectContainer=null):void {
+            run(testOrSuite, methodName, visualContext);
         }
 
-        public function get factory():IRunnerFactory {
-            return _factory;
-        }
-
-        public function runMethodByName(test:Class, methodName:String=null, visualContext:DisplayObjectContainer=null):void {
-            currentTestReflection  = Reflection.create(test);
+        public function run(test:Class, methodName:String=null, visualContext:DisplayObjectContainer=null):void {
+			currentTestReflection  = Reflection.create(test);
             this.visualContext     = visualContext;
+			testInjector.mapValue(Sprite, visualContext);
             currentMethod          = null;
             testMethodNameReceived = (methodName != null);
 
             try {
-                currentTest            = new test();
+                currentTest = testInjector.instantiate(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);
+            result.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();
+			
+            runNextMethods();
         }
 
         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 runNextMethods(e:TimerEvent = null):void {
+			// Loop through as many as possible without hitting asynchronous tests.
+			// This keeps the call stack small.
+			while (methodsToRun.hasNext()) {
+				var hasAsyncPending:Boolean = runMethod(methodsToRun.next());
+				if (hasAsyncPending) return;
+			}
+			
+			onTestCompleted();
         }
         
-        protected function runMethod(method:Method):void {
-            if (!method) return;
+		/**
+		 * 
+		 * @param	method
+		 * @return	true if asynchronous calls are pending after calling the test method.
+		 */
+        protected function runMethod(method:Method):Boolean {
+            if (!method) return false;
             currentMethod = method;
             methodPassed = true; // innocent until proven guilty by recordFailure()
             
             if (currentMethod.ignore) {
-                bridge.onTestIgnored(currentMethod);
+                result.onTestIgnored(currentMethod);
                 onMethodCompleted();
-                return;
+                return false;
             }
 
             // This is used to prevent async callbacks from triggering onMethodCompleted too early.
@@ -170,7 +139,13 @@ package asunit.runners {
             if (currentMethod.expects) {
                 try {
                     var errorClass:Class = getDefinitionByName(currentMethod.expects) as Class;
-                    Assert.assertThrows(errorClass, currentMethod.value);
+                    var errorMessage:String = currentMethod.message;
+                    if(errorMessage == null) {
+                    	Assert.assertThrows(errorClass, currentMethod.value);
+                    }
+                    else {
+                        Assert.assertThrowsWithMessage(errorClass, errorMessage, currentMethod.value);
+                    }
                 }
                 catch(definitionError:ReferenceError) {
                     // NOTE: [luke] Added ReferenceError catch here b/c I had a bad class name in my expects.
@@ -192,22 +167,23 @@ package asunit.runners {
             
             methodIsExecuting = false;
             
-            if (async.hasPending) return;
+            if (async.hasPending) return true;
 
             onMethodCompleted();
+			return false;
         }
 
-        protected function onMethodCompleted():void {
+        protected function onMethodCompleted(wasAsync:Boolean = false):void {
             async.cancelPending();
             
             if (currentMethod.isTest && methodPassed && !currentMethod.ignore) {
-                bridge.onTestSuccess(new TestSuccess(currentTest, currentMethod.name));
+                result.onTestSuccess(new TestSuccess(currentTest, currentMethod.name));
             }
 
-            // Calling synchronously is faster but keeps adding to the call stack.
-            runNextMethod();
+            if (wasAsync)
+				runNextMethods();
             
-            // green thread for runNextMethod()
+            // green thread for runNextMethods()
             // This runs much slower in Flash Player 10.1.
             //timer.reset();
             //timer.start();
@@ -231,12 +207,12 @@ package asunit.runners {
         
         protected function recordFailure(error:Error):void {
             methodPassed = false;
-            bridge.onTestFailure(new TestFailure(currentTest, currentMethod.name, error));
+            result.onTestFailure(new TestFailure(currentTest, currentMethod.name, error));
         }
 
         protected function onAsyncMethodCompleted(event:Event = null):void {
             if (!methodIsExecuting && !async.hasPending) {
-                onMethodCompleted();
+                onMethodCompleted(true);
             }
         }
         
@@ -245,158 +221,17 @@ package asunit.runners {
             async.removeEventListener(TimeoutCommandEvent.TIMED_OUT,   onAsyncMethodTimedOut);
             async.cancelPending();
             
-            bridge.onTestCompleted(currentTest);
+            result.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;
+            result.onWarning(new TestWarning(message, method));
         }
     }
 }