as3signals 0.7.0

data/tests/org/osflash/signals/natives/NativeMappedSignalFunctionArgTest.as

@@ -0,0 +1,148 @@
+package org.osflash.signals.natives
+{
+	import asunit.asserts.*;
+	import asunit.framework.IAsync;
+
+	import org.osflash.signals.IDeluxeSignal;
+
+	import flash.display.Sprite;
+	import flash.events.Event;
+	import flash.events.MouseEvent;
+
+	public class NativeMappedSignalFunctionArgTest
+	{
+	    [Inject]
+	    public var async:IAsync;
+		
+		private var signal:NativeMappedSignal;
+		private var signalMappingToEventType:NativeMappedSignal;
+		private var signalMappingToIncorrectEventType:NativeMappedSignal;
+		private var signalMappingToVoid:NativeMappedSignal;
+		private var sprite:Sprite;
+		private const EventType:String = MouseEvent.CLICK;
+		private const MappedObject:String = "mapped " + EventType;
+		
+		[Before]
+		public function setUp():void
+		{
+			sprite = new Sprite();
+			signal = new NativeMappedSignal(sprite, EventType, MouseEvent, String).mapTo(
+				function ():String {
+					return MappedObject;
+				}
+			);
+			
+			signalMappingToEventType = new NativeMappedSignal(sprite, EventType, MouseEvent, String).mapTo(
+				function (event:MouseEvent):String {
+					return event.type;
+				}
+			);
+			
+			signalMappingToIncorrectEventType = new NativeMappedSignal(sprite, EventType, MouseEvent, String).mapTo(
+				function (event:MouseEvent):int {
+					return event.delta;
+				}
+			);
+			
+			signalMappingToVoid = new NativeMappedSignal(sprite, EventType).mapTo(function ():void {});
+		}
+		
+		[After]
+		public function tearDown():void
+		{
+			signal.removeAll();
+			signal = null;
+			signalMappingToEventType.removeAll();
+			signalMappingToEventType = null;
+			signalMappingToIncorrectEventType.removeAll();
+			signalMappingToIncorrectEventType = null;
+			signalMappingToVoid.removeAll();
+			signalMappingToVoid = null;
+		}
+		
+		[Test]
+		public function testInstantiated():void
+		{
+			assertFalse('sprite has no click event listener to start', sprite.hasEventListener(EventType));
+			
+			assertTrue("NativeMappedSignal instantiated", signal is NativeMappedSignal);
+			assertTrue('implements IDeluxeSignal', signal is IDeluxeSignal);
+			assertSame('has only one value class', 1, signal.valueClasses.length);
+			assertSame('single value class is of type String', String, signal.valueClasses[0]);
+			
+			assertTrue("NativeMappedSignal instantiated", signalMappingToEventType is NativeMappedSignal);
+			assertTrue('implements IDeluxeSignal', signalMappingToEventType is IDeluxeSignal);
+			assertSame('has only one value class', 1, signalMappingToEventType.valueClasses.length);
+			assertSame('single value class is of type String', String, signalMappingToEventType.valueClasses[0]);
+			
+			assertTrue("NativeMappedSignal instantiated", signalMappingToIncorrectEventType is NativeMappedSignal);
+			assertTrue('implements IDeluxeSignal', signalMappingToIncorrectEventType is IDeluxeSignal);
+			assertSame('has only one value class', 1, signalMappingToIncorrectEventType.valueClasses.length);
+			assertSame('single value class is of type String', String, signalMappingToIncorrectEventType.valueClasses[0]);
+			
+			assertTrue("NativeMappedSignal instantiated", signalMappingToVoid is NativeMappedSignal);
+			assertTrue('implements IDeluxeSignal', signalMappingToVoid is IDeluxeSignal);
+			assertSame('has no value classes', 0, signalMappingToVoid.valueClasses.length);
+		}
+		
+		private function dispatchTestEvent():void
+		{
+			sprite.dispatchEvent(buildTestEvent());
+		}
+		
+		private function buildTestEvent():Event
+		{
+			return new MouseEvent(EventType);
+		}
+		
+		//////
+		[Test]
+		public function signal_add_then_mapped_object_should_be_callback_argument():void
+		{
+			signal.add( async.add(checkMappedArgument, 10) );
+			dispatchTestEvent();
+		}
+		
+		private function checkMappedArgument(argument:String):void
+		{
+			assertSame(MappedObject, argument);
+		}
+		//////
+		[Test]
+		public function mapping_function_should_receive_event_as_argument():void
+		{
+			signalMappingToEventType.add( async.add(checkMappedEventTypeArgument, 10) );
+			dispatchTestEvent();
+		}
+		
+		private function checkMappedEventTypeArgument(argument:String):void
+		{
+			assertSame(EventType, argument);
+		}
+		
+		[Test(expects="ArgumentError")]
+		public function mapping_function_has_to_many_arguments_should_throw_ArgumentError():void
+		{
+			var signal:NativeMappedSignal = new NativeMappedSignal(sprite, EventType, MouseEvent, String).mapTo(
+				function (event:MouseEvent, extraArg:Object):String {
+					return event.type;
+				}
+			);
+		}
+		
+		[Test(expects="Error")]
+		public function mapping_function_returns_incorrectly_typed_argument_should_throw_Error():void
+		{
+			signalMappingToIncorrectEventType.dispatch(buildTestEvent());
+		}
+		
+		private function emptyHandler(argument:String):void {}
+		
+		[Test]
+		public function mapping_to_void():void
+		{
+			signalMappingToVoid.add(async.add(emptyHandler, 10));
+			dispatchTestEvent();
+		}
+	}
+}

data/tests/org/osflash/signals/natives/NativeMappedSignalFunctionNoArgsTest.as

@@ -0,0 +1,95 @@
+package org.osflash.signals.natives
+{
+	import asunit.asserts.*;
+	import asunit.framework.IAsync;
+
+	import org.osflash.signals.IDeluxeSignal;
+
+	import flash.display.Sprite;
+	import flash.events.MouseEvent;
+
+	public class NativeMappedSignalFunctionNoArgsTest
+	{
+	    [Inject]
+	    public var async:IAsync;
+		
+		private var signalSingle:NativeMappedSignal;
+		private var signalList:NativeMappedSignal;
+		private var sprite:Sprite;
+		private const EventType:String = MouseEvent.CLICK;
+		private const MappedObject:String = "mapped " + EventType;
+		private const MappedObject2:int = 3;
+		private const MappedObject3:Number = 3.1415;
+		
+		[Before]
+		public function setUp():void
+		{
+			sprite = new Sprite();
+			signalSingle = new NativeMappedSignal(sprite, EventType, MouseEvent, String).mapTo(
+				function ():String {
+					return MappedObject;
+				}
+			);
+			
+			signalList = new NativeMappedSignal(sprite, EventType, MouseEvent, String, int, Number).mapTo(
+				function ():Array
+				{
+					return [MappedObject, MappedObject2, MappedObject3];
+				}
+			);
+		}
+		
+		[After]
+		public function tearDown():void
+		{
+			signalSingle.removeAll();
+			signalSingle = null;
+			signalList.removeAll();
+			signalList = null;
+		}
+		
+		[Test]
+		public function testInstantiated():void
+		{
+			assertFalse('sprite has no click event listener to start', sprite.hasEventListener(EventType));
+			
+			assertTrue("NativeMappedSignal instantiated", signalSingle is NativeMappedSignal);
+			assertTrue('implements IDeluxeSignal', signalSingle is IDeluxeSignal);
+			assertSame('has only one value class', 1, signalSingle.valueClasses.length);
+			assertSame('single value class is of type String', String, signalSingle.valueClasses[0]);
+			
+			assertTrue("NativeMappedSignal instantiated", signalList is NativeMappedSignal);
+			assertTrue('implements IDeluxeSignal', signalList is IDeluxeSignal);
+			assertSame('has three value classes', 3, signalList.valueClasses.length);
+			assertSame('first value class is of type String', String, signalList.valueClasses[0]);
+			assertSame('second value class is of type int', int, signalList.valueClasses[1]);
+			assertSame('third value class is of type Number', Number, signalList.valueClasses[2]);
+		}
+		//////
+		[Test]
+		public function signal_add_then_mapped_object_should_be_callback_argument():void
+		{
+			signalSingle.add( async.add(checkMappedArgumentSingle, 10) );
+			sprite.dispatchEvent(new MouseEvent(EventType));
+		}
+		
+		private function checkMappedArgumentSingle(argument:String):void
+		{
+			assertSame(MappedObject, argument);
+		}
+		//////
+		[Test]
+		public function signal_list_add_then_mapped_object_should_be_callback_argument():void
+		{
+			signalList.add( async.add(checkMappedArgumentList, 10) );
+			sprite.dispatchEvent(new MouseEvent(EventType));
+		}
+		
+		private function checkMappedArgumentList(argument1:String, argument2:int, argument3:Number):void
+		{
+			assertSame(MappedObject, argument1);
+			assertSame(MappedObject2, argument2);
+			assertSame(MappedObject3, argument3);
+		}
+	}
+}

data/tests/org/osflash/signals/natives/NativeMappedSignalObjectArgTest.as

@@ -0,0 +1,85 @@
+package org.osflash.signals.natives
+{
+	import asunit.asserts.*;
+	import asunit.framework.IAsync;
+
+	import org.osflash.signals.IDeluxeSignal;
+
+	import flash.display.Sprite;
+	import flash.events.MouseEvent;
+
+	public class NativeMappedSignalObjectArgTest
+	{
+	    [Inject]
+	    public var async:IAsync;
+		
+		private var signalSingle:NativeMappedSignal;
+		private var signalList:NativeMappedSignal;
+		private var sprite:Sprite;
+		private const EventType:String = MouseEvent.CLICK;
+		private const MappedObject:String = "mapped " + EventType;
+		private const MappedObject2:int = 3;
+		private const MappedObject3:Number = 3.1415;
+		
+		[Before]
+		public function setUp():void
+		{
+			sprite = new Sprite();
+			signalSingle = new NativeMappedSignal(sprite, EventType, MouseEvent, String).mapTo(MappedObject);
+			signalList = new NativeMappedSignal(sprite, EventType, MouseEvent, String, int, Number).mapTo(MappedObject, MappedObject2, MappedObject3);
+		}
+		
+		[After]
+		public function tearDown():void
+		{
+			signalSingle.removeAll();
+			signalSingle = null;
+			signalList.removeAll();
+			signalList = null;
+		}
+		
+		[Test]
+		public function testInstantiated():void
+		{
+			assertFalse('sprite has no click event listener to start', sprite.hasEventListener(EventType));
+			
+			assertTrue("NativeMappedSignal instantiated", signalSingle is NativeMappedSignal);
+			assertTrue('implements ISignal', signalSingle is IDeluxeSignal);
+			assertSame('has only one value class', 1, signalSingle.valueClasses.length);
+			assertSame('single value class is of type String', String, signalSingle.valueClasses[0]);
+			
+			assertTrue("NativeMappedSignal instantiated", signalList is NativeMappedSignal);
+			assertTrue('implements IDeluxeSignal', signalList is IDeluxeSignal);
+			assertSame('has three value classes', 3, signalList.valueClasses.length);
+			assertSame('first value class is of type String', String, signalList.valueClasses[0]);
+			assertSame('second value class is of type int', int, signalList.valueClasses[1]);
+			assertSame('third value class is of type Number', Number, signalList.valueClasses[2]);
+		}
+		//////
+		[Test]
+		public function signal_single_add_then_mapped_object_should_be_callback_argument():void
+		{
+			signalSingle.add( async.add(checkMappedArgumentSingle, 10) );
+			sprite.dispatchEvent(new MouseEvent(EventType));
+		}
+		
+		private function checkMappedArgumentSingle(argument:String):void
+		{
+			assertSame(MappedObject, argument);
+		}
+		//////
+		[Test]
+		public function signal_list_add_then_mapped_object_should_be_callback_argument():void
+		{
+			signalList.add( async.add(checkMappedArgumentList, 10) );
+			sprite.dispatchEvent(new MouseEvent(EventType));
+		}
+		
+		private function checkMappedArgumentList(argument1:String, argument2:int, argument3:Number):void
+		{
+			assertSame(MappedObject, argument1);
+			assertSame(MappedObject2, argument2);
+			assertSame(MappedObject3, argument3);
+		}
+	}
+}

data/tests/org/osflash/signals/natives/NativeRelaySignalTest.as

@@ -0,0 +1,174 @@
+package org.osflash.signals.natives
+{
+	import asunit.asserts.*;
+	import asunit.framework.IAsync;
+
+	import org.osflash.signals.ISignal;
+
+	import flash.display.Sprite;
+	import flash.events.EventDispatcher;
+	import flash.events.MouseEvent;
+
+	public class NativeRelaySignalTest
+	{	
+	    [Inject]
+	    public var async:IAsync;
+	    
+		private var clicked:NativeRelaySignal;
+		private var sprite:Sprite;
+
+		[Before]
+		public function setUp():void
+		{
+			sprite = new Sprite();
+			clicked = new NativeRelaySignal(sprite, 'click', MouseEvent);
+		}
+
+		[After]
+		public function tearDown():void
+		{
+			clicked.removeAll();
+			clicked = null;
+		}
+
+		public function testInstantiated():void
+		{
+			assertTrue("NativeRelaySignal instantiated", clicked is NativeRelaySignal);
+			assertTrue('implements ISignal', clicked is ISignal);
+			assertFalse('sprite has no click event listener to start', sprite.hasEventListener('click'));
+		}
+		//////
+		[Test]
+		public function signal_add_then_EventDispatcher_dispatch_should_call_signal_listener():void
+		{
+			clicked.add( async.add(checkSpriteAsCurrentTarget, 10) );
+			sprite.dispatchEvent(new MouseEvent('click'));
+		}
+		
+		private function checkSpriteAsCurrentTarget(e:MouseEvent):void
+		{
+			assertSame(sprite, e.currentTarget);
+		}
+		//////
+		[Test]
+		public function signal_addOnce_then_EventDispatcher_dispatch_should_call_signal_listener():void
+		{
+			clicked.addOnce( async.add(checkSpriteAsCurrentTarget, 10) );
+			sprite.dispatchEvent(new MouseEvent('click'));
+		}
+		//////
+		[Test]
+		public function when_signal_adds_listener_then_hasEventListener_should_be_true():void
+		{
+			clicked.add(emptyHandler);
+			assertTrue(sprite.hasEventListener('click'));
+		}
+		
+		private function emptyHandler(e:MouseEvent):void { }
+		
+		[Test]
+		public function when_signal_addOnce_listener_then_hasEventListener_should_be_true():void
+		{
+			clicked.addOnce(emptyHandler);
+			assertTrue(sprite.hasEventListener('click'));
+		}
+		
+		[Test]
+		public function when_signal_adds_then_removes_listener_then_hasEventListener_should_be_false():void
+		{
+			clicked.add(emptyHandler);
+			clicked.remove(emptyHandler);
+			assertFalse(sprite.hasEventListener('click'));
+		}
+		
+		[Test]
+		public function when_signal_addOnce_then_removes_listener_then_hasEventListener_should_be_false():void
+		{
+			clicked.addOnce(emptyHandler);
+			clicked.remove(emptyHandler);
+			assertFalse(sprite.hasEventListener('click'));
+		}
+		
+		[Test]
+		public function when_signal_adds_then_removeAll_listeners_then_hasEventListener_should_be_false():void
+		{
+			clicked.add(emptyHandler);
+			clicked.removeAll();
+			assertFalse(sprite.hasEventListener('click'));
+		}
+		//////
+		[Test]
+		public function setting_target_to_a_different_object_should_remove_all_listeners_from_1st_target():void
+		{
+			clicked.add(emptyHandler);
+			clicked.target = new EventDispatcher();
+			assertFalse(sprite.hasEventListener('click'));
+		}
+		//////
+		[Test]
+		public function setting_target_to_the_same_object_should_not_remove_listeners():void
+		{
+			clicked.add(emptyHandler);
+			var numListenersBefore:uint = clicked.numListeners;
+			clicked.target = sprite;
+			assertEquals(numListenersBefore, clicked.numListeners);
+		}
+		//////
+		[Test]
+		public function addOnce_and_dispatch_should_remove_listener_automatically():void
+		{
+			clicked.addOnce(emptyHandler);
+			clicked.dispatch(new MouseEvent('click'));
+			assertEquals('there should be no listeners', 0, clicked.numListeners);
+		}
+		
+		//////
+		[Test]
+		public function can_use_anonymous_listeners():void
+		{
+			var listeners:Array = [];
+			
+			for ( var i:int = 0; i < 100;  i++ )
+			{
+				listeners.push(clicked.add(function(e:MouseEvent):void{}));
+			}
+			
+			assertTrue("there should be 100 listeners", clicked.numListeners == 100);
+			
+			for each( var fnt:Function in listeners )
+			{
+				clicked.remove(fnt);
+			}
+			assertTrue("all anonymous listeners removed", clicked.numListeners == 0);
+		}
+		
+		//////
+		[Test]
+		public function can_use_anonymous_listeners_in_addOnce():void
+		{
+			var listeners:Array = [];
+			
+			for ( var i:int = 0; i < 100;  i++ )
+			{
+				listeners.push(clicked.addOnce(function(e:MouseEvent):void{}));
+			}
+			
+			assertTrue("there should be 100 listeners", clicked.numListeners == 100);
+			
+			for each( var fnt:Function in listeners )
+			{
+				clicked.remove(fnt);
+			}
+			assertTrue("all anonymous listeners removed", clicked.numListeners == 0);
+		}
+		
+		//////
+		[Test]
+		public function removed_listener_should_be_returned():void
+		{
+			var listener:Function = clicked.add(function(e:MouseEvent):void{});
+			
+			assertTrue("Listener is returned", listener == clicked.remove(listener));
+		}
+	}
+}