asunit4 4.2.2.pre → 4.2.3.pre

data/src/asunit/framework/ITestResult.as

@@ -1,21 +0,0 @@
-package asunit.framework {
-
-	public interface ITestResult {
-		
-		function addFailure(failure:ITestFailure):void;
-		
-		function get errors():Array;
-		function get errorCount():uint;
-		
-		function get failures():Array;
-		function get failureCount():uint;
-		
-		function get runCount():uint;
-		function set runCount(value:uint):void;
-		
-		function get wasSuccessful():Boolean;
-		
-		function addListener(listener:ITestListener):void;
-		function removeListener(listener:ITestListener):void;
-	}
-}

data/src/asunit/framework/InjectionDelegate.as

@@ -1,96 +0,0 @@
-package asunit.framework {
-	
-	import p2.reflect.ReflectionMetaData;
-	import p2.reflect.Reflection;
-		
-	import flash.utils.Dictionary;
-	import asunit.errors.UsageError;
-	import p2.reflect.ReflectionVariable;
-	import p2.reflect.ReflectionMember;
-	import flash.utils.getDefinitionByName;
-
-	public class InjectionDelegate {
-		//---------------------------------------
-		// CLASS CONSTANTS
-		//---------------------------------------
-		
-		public static const THROW_ERROR_ON_MISSING_INJECTION_POINT:Boolean = true;
-		public static const INJECT_ANNOTATION:String = "Inject";
-		
-		private var entities:Dictionary;
-		
-		public function InjectionDelegate()
-		{
-			entities = new Dictionary();
-		}
-		
-		/**
-		 * @param addict * an entity with at least one [Inject] annotation
-		*/
-		public function updateInjectionPoints(addict:*, throwErrorOnMissingInjection:Boolean=false):void {
-			var reflection:Reflection = Reflection.create(addict);
-			var members:Array = reflection.getMembersByMetaData(INJECT_ANNOTATION);
-			var addictName:String = reflection.name
-			if (throwErrorOnMissingInjection)
-			{
-				validateMembers(members, addictName);
-			}			
-			var reflectionVariable:ReflectionVariable;
-			var injectionPointFound:Boolean;
-			members.forEach(function(member:ReflectionMember, index:int, items:Array):void {
-				reflectionVariable = member as ReflectionVariable;
-				if (reflectionVariable)
-				{
-					updateInjectionPoint(addict, reflectionVariable);
-					injectionPointFound = true;
-				}
-			});
-			
-			if (!injectionPointFound && throwErrorOnMissingInjection)
-			{
-				throw new UsageError("InjectionDelegate expected at least one [Inject] annotation on a variable or accessor on" + addictName);
-			}
-			
-		}
-		
-		/**
-		 * For each inject annotation we call this method
-		 * @private
-		 * @return 
-		*/
-		private function updateInjectionPoint(addict:*, member:ReflectionVariable):void {
-			//FIXME: This actually could be a getter. If someone has their head up their booty.
-			var instance:* = getInstanceFromTypeName(member.type);
-			addict[member.name] = instance;
-		}
-		
-		private function getInstanceFromTypeName(name:String):* {
-			var clazz:Class = getDefinitionByName(name) as Class;
-			 return getOrCacheInstanceFromClass(clazz);
-		}
-		
-		private function getOrCacheInstanceFromClass(clazz:Class):* {
-			if (!entities[clazz])
-			{
-				//FIXME: This will choke if given a class with constructor arguments!
-				entities[clazz] = new clazz();
-				updateInjectionPoints(entities[clazz]);
-			}
-
-			return entities[clazz];
-		}
-		
-		/**
-		 * @private
-		 */
-		private function validateMembers(members:Array, name:String):void
-		{
-			if (!members || members.length == 0)
-			{
-				throw new UsageError("InjectionDelegate expects at least one [Inject] annotation on " + name);
-			}
-			
-		}
-		
-	}
-}

data/src/asunit/framework/MessageBridge.as

@@ -1,24 +0,0 @@
-package asunit.framework {
-
-    /**
-     * MessageBridge is a marker interface that is used
-     * by AsUnit core in order to support custom messaging
-     * schemes between TestObservers and IRunners.
-     *
-     * The idea is that you [Inject] one or more entities
-     * into your concrete IRunner and related TestObservers.
-     *
-     * The contract is between the concrete MessageBridge,
-     * and the other actors that [Inject] it into.
-     * 
-     * This implementation gives AsUnit the ability to support
-     * a variety of messaging protocols including native
-     * Flash EventDispatchers, callbacks, and even progressive
-     * systems like AS3Signals. The decision as to which
-     * messaging system to use is made by the person creating
-     * the concrete Runner and Observer.
-     */
-    public interface MessageBridge {
-    }
-}
-

data/src/asunit/framework/TestObserver.as

@@ -1,12 +0,0 @@
-package asunit.framework {
-
-    /**
-     * TestObserver is a marker interface that usually
-     * indicates that a given class will have at least
-     * one [Inject] annotation above a public instance
-     * variable that implements MessageBridge.
-     */
-    public interface TestObserver {
-    }
-}
-

data/test/asunit/framework/CallbackBridgeTest.as

@@ -1,73 +0,0 @@
-package asunit.framework {
-
-    import asunit.asserts.*;
-    import asunit.support.FakeObserver;
-    import asunit.framework.Result;
-    import asunit.framework.CallbackBridge;
-
-	public class CallbackBridgeTest {
-
-        private var bridge:CallbackBridge;
-
-        private var observer:FakeObserver;
-
-        [Before]
-        public function createObserver():void {
-            observer = new FakeObserver();
-			bridge = new CallbackBridge();
-            bridge.addListener(observer);
-        }
-
-        [After]
-        public function destroyObserver():void {
-            observer = null;
-        }
-
-        [Test]
-		public function canInstantiate():void {
-			assertTrue("instance is CallbackBridge", bridge is CallbackBridge);
-		}
-
-        [Test]
-		public function addListenerWorked():void {
-            assertEquals(1, bridge.length);
-		}
-
-        [Test]
-        public function addedListenerReceivesOnRunStarted():void {
-            bridge.onRunStarted();
-            assertTrue(observer.onRunStartedCalled);
-        }
-
-        [Test]
-        public function addedListenerReceivesOnTestStarted():void {
-            bridge.onTestStarted(null);
-            assertTrue(observer.onTestStartedCalled);
-        }
-
-		[Test]
-		public function shouldHaveDefaultRunCount():void
-		{
-			assertEquals(0, bridge.runCount);
-		}
-		
-		[Test]
-		public function shouldHaveCumulativeRunCount():void
-		{
-			/*
-				function onTestStarted(test:Object):void;
-				function onTestCompleted(test:Object):void;
-				function onTestFailure(failure:ITestFailure):void;
-				function onTestSuccess(success:ITestSuccess):void;
-			*/
-			bridge.onTestStarted(null);
-			bridge.onTestSuccess(null);
-			bridge.onTestCompleted(null);
-			bridge.onTestStarted(null);
-			bridge.onTestSuccess(null);
-			bridge.onTestCompleted(null);
-			assertEquals(2, bridge.runCount);
-		}
-		
-	}
-}

data/test/asunit/framework/InjectionDelegateTest.as

@@ -1,79 +0,0 @@
-package asunit.framework {
-
-	import asunit.asserts.*;
-	
-	public class InjectionDelegateTest  {
-		
-		[Inject]
-		public var injector:InjectionDelegate;
-		
-		[Test]
-		public function testInstantiated():void {
-			assertTrue("instance is InjectionDelegate", injector is InjectionDelegate);
-		}
-
-		[Test]
-		public function testUpdateInjectionPoints():void {
-			var addict:Addict = new Addict();
-			injector.updateInjectionPoints(addict);
-			assertNotNull(addict.array);
-		}
-		
-		[Test]
-		public function injectedInstancesShouldBeCached():void {			
-			var addict:Addict = new Addict();			
-			var addict2:Addict = new Addict();
-			
-			injector.updateInjectionPoints(addict);			
-			injector.updateInjectionPoints(addict2);			
-			
-			assertSame(addict.array, addict2.array);
-			
-		}
-		
-		[Test(expects="asunit.errors.UsageError")]
-		public function shouldThrowUsageErrorOnInvalidAddict():void
-		{
-			var invalidAddict:AddictWithNoInjections = new AddictWithNoInjections();
-			injector.updateInjectionPoints(invalidAddict, InjectionDelegate.THROW_ERROR_ON_MISSING_INJECTION_POINT);
-		}
-		
-		[Test(expects="asunit.errors.UsageError")]
-		public function shouldThrowUsageErrorIfNoVariableInjectionsFound():void
-		{
-			var invalidAddict:AddictWithOnlyMethodInjection = new AddictWithOnlyMethodInjection();
-			injector.updateInjectionPoints(invalidAddict, InjectionDelegate.THROW_ERROR_ON_MISSING_INJECTION_POINT);
-		}
-		
-		[Test]
-		public function shouldNotThrowUsageErrorOnInvalidAddict():void
-		{
-			var invalidAddict:AddictWithNoInjections = new AddictWithNoInjections();
-			injector.updateInjectionPoints(invalidAddict);
-		}
-		
-		[Test]
-		public function shouldNotThrowUsageErrorIfNoVariableInjectionsFound():void
-		{
-			var invalidAddict:AddictWithOnlyMethodInjection = new AddictWithOnlyMethodInjection();
-			injector.updateInjectionPoints(invalidAddict);
-		}
-			
-	}
-}
-
-//An addict that has no inject annotations
-class AddictWithNoInjections {}
-
-class AddictWithOnlyMethodInjection {
-	[Inject]
-	public function pleaseInjectMe(array:Array):void{};
-}
-
-class Addict {
-	[Inject]
-	public var array:Array;
-	
-	[Inject]
-	public function pleaseInjectMe(array:Array):void{};
-}

data/test/asunit/support/AnnotatedSubClass.as

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

data/test/asunit/support/AnnotatedSuperClass.as

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

data/test/asunit/support/FakeRunner.as

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

data/test/asunit/support/InjectTimeoutOnAsync.as

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

data/test/asunit/support/TestForFakeRunner.as

@@ -1,14 +0,0 @@
-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");
-        }
-    }
-}
-