as3signals 0.7.0

data/tests/org/osflash/signals/SignalTest.as

@@ -0,0 +1,267 @@
+package org.osflash.signals
+{
+	import asunit.asserts.*;
+	import asunit.framework.IAsync;
+
+	import org.osflash.signals.events.GenericEvent;
+	import org.osflash.signals.events.IEvent;
+
+	import flash.display.Sprite;
+
+	public class SignalTest
+	{	
+	    [Inject]
+	    public var async:IAsync;
+	    
+		public var completed:Signal;
+		
+		[Before]
+		public function setUp():void
+		{
+			completed = new Signal();
+		}
+
+		[After]
+		public function tearDown():void
+		{
+			completed.removeAll();
+			completed = null;
+		}
+
+		[Test]
+		public function numListeners_is_0_after_creation():void
+		{
+			assertEquals(0, completed.numListeners);
+		}
+		
+		//////
+		
+		[Test]
+		public function dispatch_should_pass_event_to_listener_but_not_set_signal_or_target_properties():void
+		{
+			completed.add(async.add(checkGenericEvent, 10));
+			completed.dispatch(new GenericEvent());
+		}
+		
+		protected function checkGenericEvent(e:GenericEvent):void
+		{
+			assertNull('event.signal is not set by Signal', e.signal);
+			assertNull('event.target is not set by Signal', e.target);
+		}
+		
+		//////
+		
+		[Test]
+		public function add_two_listeners_and_dispatch_should_call_both():void
+		{
+			completed.add(async.add(checkGenericEvent, 10));
+			completed.add(async.add(checkGenericEvent, 10));
+			completed.dispatch(new GenericEvent());
+		}
+
+		//////
+
+		[Test]
+		public function addOnce_and_dispatch_should_remove_listener_automatically():void
+		{
+			completed.addOnce(newEmptyHandler());
+			completed.dispatch(new GenericEvent());
+			assertEquals('there should be no listeners', 0, completed.numListeners);
+		}
+		
+		//////
+		
+		[Test]
+		public function add_listener_then_remove_then_dispatch_should_not_call_listener():void
+		{
+			completed.add(failIfCalled);
+			completed.remove(failIfCalled);
+			completed.dispatch(new GenericEvent());
+		}
+		
+		private function failIfCalled(e:IEvent):void
+		{
+			fail('This event handler should not have been called.');
+		}
+		
+		//////
+		
+		[Test]
+		public function add_listener_then_remove_function_not_in_listeners_should_do_nothing():void
+		{
+			completed.add(newEmptyHandler());
+			completed.remove(newEmptyHandler());
+			assertEquals(1, completed.numListeners);
+		}
+		
+		//////
+
+		[Test]
+		public function add_2_listeners_remove_2nd_then_dispatch_should_call_1st_not_2nd_listener():void
+		{
+			completed.add(async.add(checkGenericEvent, 10));
+			completed.add(failIfCalled);
+			completed.remove(failIfCalled);
+			completed.dispatch(new GenericEvent());
+		}
+		//////
+		[Test]
+		public function add_2_listeners_should_yield_numListeners_of_2():void
+		{
+			completed.add(newEmptyHandler());
+			completed.add(newEmptyHandler());
+			assertEquals(2, completed.numListeners);
+		}
+
+		private function newEmptyHandler():Function
+		{
+			return function(e:*):void {};
+		}
+		
+
+		//////
+		[Test]
+		public function add_2_listeners_then_remove_1_should_yield_numListeners_of_1():void
+		{
+			var firstFunc:Function = newEmptyHandler();
+			completed.add(firstFunc);
+			completed.add(newEmptyHandler());
+			
+			completed.remove(firstFunc);
+			
+			assertEquals(1, completed.numListeners);
+		}
+		
+		[Test]
+		public function add_2_listeners_then_removeAll_should_yield_numListeners_of_0():void
+		{
+			completed.add(newEmptyHandler());
+			completed.add(newEmptyHandler());
+			
+			completed.removeAll();
+			
+			assertEquals(0, completed.numListeners);
+		}
+		
+		[Test]
+		public function add_same_listener_twice_should_only_add_it_once():void
+		{
+			var func:Function = newEmptyHandler();
+			completed.add(func);
+			completed.add(func);
+			assertEquals(1, completed.numListeners);
+		}
+		
+		[Test]
+		public function addOnce_same_listener_twice_should_only_add_it_once():void
+		{
+			var func:Function = newEmptyHandler();
+			completed.addOnce(func);
+			completed.addOnce(func);
+			assertEquals(1, completed.numListeners);
+		}
+		
+		//////
+		[Test]
+		public function dispatch_non_IEvent_without_error():void
+		{
+			completed.addOnce(checkSprite);
+			// Sprite doesn't have a target property,
+			// so if the signal tried to set .target,
+			// an error would be thrown and this test would fail.
+			completed.dispatch(new Sprite());
+		}
+		
+		private function checkSprite(sprite:Sprite):void
+		{
+			assertTrue(sprite is Sprite);
+		}
+		//////
+		[Test]
+		public function dispatch_2_listeners_1st_listener_removes_itself_then_2nd_listener_is_still_called():void
+		{
+			completed.add(selfRemover);
+			// async.add verifies the second listener is called
+			completed.add(async.add(newEmptyHandler(), 10));
+			completed.dispatch();
+		}
+		
+		private function selfRemover():void
+		{
+			completed.remove(selfRemover);
+		}
+		//////
+		[Test]
+		public function dispatch_2_listeners_1st_listener_removes_all_then_2nd_listener_is_still_called():void
+		{
+			completed.add(async.add(allRemover, 10));
+			completed.add(async.add(newEmptyHandler(), 10));
+			completed.dispatch();
+		}
+		
+		//////
+		[Test]
+		public function can_use_anonymous_listeners():void
+		{
+			var listeners:Array = [];
+			
+			for ( var i:int = 0; i < 100;  i++ )
+			{
+				listeners.push(completed.add(function():void{}));
+			}
+
+			assertTrue("there should be 100 listeners", completed.numListeners == 100);
+
+			for each( var fnt:Function in listeners )
+			{
+				completed.remove(fnt);
+			}
+			assertTrue("all anonymous listeners removed", completed.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(completed.addOnce(function():void{}));
+			}
+
+			assertTrue("there should be 100 listeners", completed.numListeners == 100);
+
+			for each( var fnt:Function in listeners )
+			{
+				completed.remove(fnt);
+			}
+			assertTrue("all anonymous listeners removed", completed.numListeners == 0);
+		}
+		
+		private function allRemover():void
+		{
+			completed.removeAll();
+		}
+		//////
+		[Test]
+		public function adding_a_listener_during_dispatch_should_not_call_it():void
+		{
+			completed.add(async.add(addListenerDuringDispatch, 10));
+			completed.dispatch(new GenericEvent());
+		}
+		
+		private function addListenerDuringDispatch():void
+		{
+			completed.add(failIfCalled);
+		}
+		//////
+		[Test]
+		public function removed_listener_should_be_returned():void
+		{
+			var listener:Function = completed.add(function():void{});
+			
+			assertTrue("Listener is returned", listener == completed.remove(listener));
+	}
+	}
+}

data/tests/org/osflash/signals/SignalWithCustomEventTest.as

@@ -0,0 +1,107 @@
+package org.osflash.signals
+{
+	import asunit.asserts.*;
+	import asunit.framework.IAsync;
+
+	import org.osflash.signals.events.GenericEvent;
+
+	public class SignalWithCustomEventTest
+	{
+	    [Inject]
+	    public var async:IAsync;
+	
+		public var messaged:Signal;
+
+		[Before]
+		public function setUp():void
+		{
+			messaged = new Signal(MessageEvent);
+		}
+
+		[After]
+		public function tearDown():void
+		{
+			messaged.removeAll();
+			messaged = null;
+		}
+		//////
+		[Test]
+		public function valueClasses_roundtrip_through_constructor():void
+		{
+			assertSame(MessageEvent, messaged.valueClasses[0]);
+		}
+		
+		[Test]
+		public function add_one_listener_and_dispatch():void
+		{
+			messaged.add(async.add(onMessage, 50));
+			messaged.dispatch(new MessageEvent('ok'));
+		}
+		
+		protected function onMessage(e:MessageEvent):void
+		{
+			assertEquals('message value in the event', 'ok', e.message);
+		}
+		//////
+		[Test(expects="ArgumentError")]
+		public function dispatch_wrong_event_type_should_throw_ArgumentError():void
+		{
+			messaged.dispatch(new GenericEvent());
+		}
+
+		[Test(expects="ArgumentError")]
+		public function signal_with_eventClass_adding_listener_without_args_should_throw_ArgumentError():void
+		{
+			messaged.add(function():void {});
+		}
+
+		[Test(expects="ArgumentError")]
+		public function constructing_signal_with_non_class_should_throw_ArgumentError():void
+		{
+			new Signal(new Date());
+		}
+		
+		[Test(expects="ArgumentError")]
+		public function constructing_signal_with_two_nulls_should_throw_ArgumentError():void
+		{
+			new Signal(null, null);
+		}
+		
+		[Test(expects="ArgumentError")]
+		public function constructing_signal_with_class_and_non_class_should_throw_ArgumentError():void
+		{
+			new Signal(Date, 42);
+		}
+
+		[Test(expects="ArgumentError")]
+		public function add_listener_with_fewer_args_than_valueClasses_should_throw_ArgumentError():void
+		{
+			var signal:Signal = new Signal(Date, Array);
+			signal.add( function(date:Date):void { } );
+		}
+	}
+}
+
+import org.osflash.signals.events.GenericEvent;
+import org.osflash.signals.events.IEvent;
+
+////// PRIVATE CLASSES //////
+
+
+class MessageEvent extends GenericEvent implements IEvent
+{
+	public var message:String;
+	
+	public function MessageEvent(message:String)
+	{
+		super();
+		this.message = message;
+	}
+	
+	override public function clone():IEvent
+	{
+		return new MessageEvent(message);
+	}
+	
+}
+

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

@@ -0,0 +1,63 @@
+package org.osflash.signals.natives
+{
+	import asunit.asserts.*;
+
+	import flash.display.Sprite;
+	import flash.events.Event;
+
+	public class AmbiguousRelationshipInNativeSignalTest
+	{
+		private var target:Sprite;
+		
+		private var instance:NativeSignal;
+
+		[Before]
+		public function setUp():void
+		{
+			target = new Sprite();
+			instance = new NativeSignal(target, Event.CHANGE);
+		}
+
+		[After]
+		public function tearDown():void
+		{
+			instance = null;
+		}
+		
+		[Test(expects="flash.errors.IllegalOperationError")]
+		public function add_then_addOnce_throws_error():void
+		{
+			instance.add(failIfCalled);
+			instance.addOnce(failIfCalled);
+		}
+		
+		[Test(expects="flash.errors.IllegalOperationError")]
+		public function addOnce_then_add_should_throw_error():void
+		{
+			instance.addOnce(failIfCalled);
+			instance.add(failIfCalled);
+		}
+		
+		[Test]
+		public function add_then_add_should_not_throw_error():void
+		{
+			instance.add(failIfCalled);
+			instance.add(failIfCalled);
+			assertEquals(1, instance.numListeners);
+		}
+		
+		[Test]
+		public function addOnce_then_addOnce_should_not_throw_error():void
+		{
+			instance.addOnce(failIfCalled);
+			instance.addOnce(failIfCalled);
+			assertEquals(1, instance.numListeners);
+		}
+		
+		private function failIfCalled(event:Event):void
+		{
+			fail("if this listener is called, something horrible is going on");
+		}
+		
+	}
+}

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

@@ -0,0 +1,100 @@
+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 NativeMappedSignalBoundaryUseTest
+	{
+	    [Inject]
+	    public var async:IAsync;
+		
+		private var signalArrayOfFunctions:NativeMappedSignal;
+		private var signalPassArray:NativeMappedSignal;
+		private var signalPassArrayThroughFunction:NativeMappedSignal;
+		private var sprite:Sprite;
+		private const EventType:String = MouseEvent.CLICK;
+		private const func1:Function = function ():String { return 'mapped arg 1'; };
+		private const func2:Function = function ():String { return 'mapped arg 2'; };
+		private const MappedArray:Array = [0, 1];
+		
+		[Before]
+		public function setUp():void
+		{
+			sprite = new Sprite();
+			signalArrayOfFunctions = new NativeMappedSignal(sprite, EventType).mapTo(func1, func2);
+			signalPassArray = new NativeMappedSignal(sprite, EventType).mapTo(MappedArray);
+			signalPassArrayThroughFunction = new NativeMappedSignal(sprite, EventType, MouseEvent, Array).mapTo(
+				function ():Array {
+					return MappedArray;
+				}
+			);
+		}
+		
+		[After]
+		public function tearDown():void
+		{
+			signalArrayOfFunctions.removeAll();
+			signalArrayOfFunctions = null;
+			signalPassArray.removeAll();
+			signalPassArray = null;
+			signalPassArrayThroughFunction.removeAll();
+			signalPassArrayThroughFunction = null;
+		}
+		
+		[Test]
+		public function testInstantiated():void
+		{
+			assertFalse('sprite has no click event listener to start', sprite.hasEventListener(EventType));
+			
+			assertTrue("NativeMappedSignal instantiated", signalArrayOfFunctions is NativeMappedSignal);
+			assertTrue('implements ISignal', signalArrayOfFunctions is IDeluxeSignal);
+			assertSame('has no value classes', 0, signalArrayOfFunctions.valueClasses.length);
+			
+			assertTrue("NativeMappedSignal instantiated", signalPassArray is NativeMappedSignal);
+			assertTrue('implements IDeluxeSignal', signalPassArray is IDeluxeSignal);
+			assertSame('has no value classed', 0, signalPassArray.valueClasses.length);
+			
+			assertTrue("NativeMappedSignal instantiated", signalPassArrayThroughFunction is NativeMappedSignal);
+			assertTrue('implements IDeluxeSignal', signalPassArrayThroughFunction is IDeluxeSignal);
+			assertSame('has only one value class', 1, signalPassArrayThroughFunction.valueClasses.length);
+			assertSame('single value class is of type Array', Array, signalPassArrayThroughFunction.valueClasses[0]);
+		}
+		//////
+		[Test]
+		public function signal_array_of_functions_add_then_callback_called():void
+		{
+			signalArrayOfFunctions.add( async.add(callbackTwoFunctions, 10) );
+			sprite.dispatchEvent(new MouseEvent(EventType));
+		}
+		
+		private function callbackTwoFunctions(argFunc1:Function, argFunc2:Function):void
+		{
+			assertSame(func1, argFunc1);
+			assertSame(func2, argFunc2);
+		}
+		
+		[Test]
+		public function signal_pass_array_add_then_array_callback_should_be_called():void
+		{
+			signalPassArray.add( async.add(callbackArrayAsArg, 10) );
+			sprite.dispatchEvent(new MouseEvent(EventType));
+		}
+		
+		private function callbackArrayAsArg(argArray:Array):void
+		{
+			assertSame(MappedArray, argArray);
+		}
+		
+		[Test]
+		public function signal_pass_array_through_function_add_then_array_callback_should_be_called():void
+		{
+			signalPassArrayThroughFunction.add( async.add(callbackArrayAsArg, 10) );
+			sprite.dispatchEvent(new MouseEvent(EventType));
+		}
+	}
+}

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

@@ -0,0 +1,78 @@
+package org.osflash.signals.natives
+{
+	import asunit.framework.IAsync;
+
+	import flash.display.Sprite;
+	import flash.events.MouseEvent;
+
+	public class NativeMappedSignalDefaultsTest
+	{
+	    [Inject]
+	    public var async:IAsync;
+		
+		private var signalDefault:NativeMappedSignal;
+		private var signalDefaultWithMappingObject:NativeMappedSignal;
+		private var signalDefaultWithMappingFunction:NativeMappedSignal;
+		private var signalWithValueClassesWithoutMappingFunction: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();
+			signalDefault = new NativeMappedSignal(sprite, EventType);
+			signalDefaultWithMappingObject = new NativeMappedSignal(sprite, EventType).mapTo(MappedObject);
+			signalDefaultWithMappingFunction = new NativeMappedSignal(sprite, EventType).mapTo(
+				function ():String {
+					return MappedObject;
+				}
+			);
+			signalWithValueClassesWithoutMappingFunction = new NativeMappedSignal(sprite, EventType, MouseEvent, String);
+		}
+		
+		[After]
+		public function tearDown():void
+		{
+			signalDefault.removeAll();
+			signalDefault = null;
+			signalDefaultWithMappingObject.removeAll();
+			signalDefaultWithMappingObject = null;
+			signalDefaultWithMappingFunction.removeAll();
+			signalDefaultWithMappingFunction = null;
+			signalWithValueClassesWithoutMappingFunction.removeAll();
+			signalWithValueClassesWithoutMappingFunction = null;
+		}
+		
+		//////
+		[Test]
+		public function signal_default_add_then_emptyCallback_should_be_called():void
+		{
+			signalDefault.add( async.add(emptyCallback, 10) );
+			sprite.dispatchEvent(new MouseEvent(EventType));
+		}
+		
+		private function emptyCallback():void {}
+		
+		[Test]
+		public function signal_default_with_mapped_object_add_then_emptyCallback_should_be_called():void
+		{
+			signalDefaultWithMappingObject.add( async.add(emptyCallback, 10) );
+			sprite.dispatchEvent(new MouseEvent(EventType));
+		}
+		
+		[Test]
+		public function signal_default_with_mapped_function_add_then_emptyCallback_should_be_called():void
+		{
+			signalDefaultWithMappingFunction.add( async.add(emptyCallback, 10) );
+			sprite.dispatchEvent(new MouseEvent(EventType));
+		}
+		
+		[Test(expects="ArgumentError")]
+		public function signal_with_value_classes_without_mapping_function():void
+		{
+			signalWithValueClassesWithoutMappingFunction.dispatch(new MouseEvent(EventType));
+		}
+	}
+}