as3signals 0.7.0

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

@@ -0,0 +1,190 @@
+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 DeluxeSignalWithGenericEventTest
+	{	
+	    [Inject]
+	    public var async:IAsync;
+	    
+		protected var completed:DeluxeSignal;
+		protected var delegate:Function;
+		
+		[Before]
+		public function setUp():void
+		{
+			completed = new DeluxeSignal(this);
+		}
+
+		[After]
+		public function tearDown():void
+		{
+			completed.removeAll();
+			completed = null;
+			delegate = null;
+		}
+
+		[Test]
+		public function signal_length_is_0_after_creation():void
+		{
+			assertEquals(0, completed.numListeners);
+		}
+		
+		//////
+		
+		[Test]
+		public function add_listener_and_dispatch_event_should_pass_event_to_listener():void
+		{
+			completed.add(async.add(checkGenericEvent, 10));
+			completed.dispatch(new GenericEvent());
+		}
+		
+		protected function checkGenericEvent(e:IEvent):void
+		{
+			assertTrue('instance of IEvent', e is IEvent);
+			assertTrue('instance of GenericEvent', e is GenericEvent);
+			assertEquals('event.signal points to the originating Signal', this.completed, e.signal);
+			assertEquals('event.target points to object containing the Signal', this, e.target);
+			assertEquals('event.target is e.currentTarget because event does not bubble', e.target, e.currentTarget);
+		}
+		
+		//////
+
+		
+		[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_one_listener_and_dispatch_then_listener_remove_itself_using_event_signal():void
+		{
+			delegate = async.add(remove_myself_from_signal, 10);
+			completed.add(delegate);
+			completed.dispatch(new GenericEvent());
+		}
+		
+		private function remove_myself_from_signal(e:IEvent):void
+		{
+			assertEquals('listener still in signal', 1, e.signal.numListeners);
+			
+			// Can't remove(arguments.callee) because it's wrapped with delegate created by async.add().
+			e.signal.remove(delegate);
+			
+			assertEquals('listener removed from signal', 0, e.signal.numListeners);
+		}
+
+		//////
+		
+		[Test]
+		public function add_listener_then_remove_then_dispatch_should_not_call_listener():void
+		{
+			var delegate:Function = failIfCalled;
+			completed.add(delegate);
+			completed.remove(delegate);
+			completed.dispatch(new GenericEvent());
+		}
+		
+		private function failIfCalled(e:IEvent):void
+		{
+			fail('This event handler should not have been called.');
+		}
+		
+		//////
+
+		[Test]
+		public function add_2_listeners_remove_2nd_then_dispatch_should_call_1st_not_2nd_listener():void
+		{
+			completed.add(async.add(checkGenericEvent, 10));
+			var delegate:Function = failIfCalled;
+			completed.add(delegate);
+			completed.remove(delegate);
+			completed.dispatch(new GenericEvent());
+		}
+		//////
+		[Test]
+		public function add_2_listeners_should_yield_length_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_length_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_length_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 dispatch_object_that_isnt_an_IEvent_should_dispatch_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);
+		}
+		//////
+
+	}
+}

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

@@ -0,0 +1,62 @@
+package org.osflash.signals
+{
+	import asunit.asserts.*;
+
+	import org.osflash.signals.events.GenericEvent;
+	import org.osflash.signals.events.IEvent;
+
+	public class GenericEventTest
+	{
+		private var instance:GenericEvent;
+
+		[Before]
+		public function setUp():void
+		{
+			instance = new GenericEvent();
+		}
+
+		[After]
+		public function tearDown():void
+		{
+			instance = null;
+		}
+
+		public function testInstantiated():void
+		{
+			assertTrue("GenericEvent instantiated", instance is GenericEvent);
+			assertNull('target is null by default', instance.target);
+			assertFalse('bubbles is false by default', instance.bubbles);
+		}
+		
+		[Test]
+		public function bubbles_roundtrips_through_constructor():void
+		{
+			var bubblingEvent:GenericEvent = new GenericEvent(true);
+			assertTrue(bubblingEvent.bubbles);
+		}
+		
+		[Test]
+		public function clone_should_be_instance_of_original_event_class():void
+		{
+			var theClone:IEvent = instance.clone();
+			assertTrue(theClone is GenericEvent);
+		}
+		
+		[Test]
+		public function clone_non_bubbling_event_should_have_bubbles_false():void
+		{
+			var theClone:GenericEvent = GenericEvent(instance.clone());
+			assertFalse(theClone.bubbles);
+		}
+		
+		[Test]
+		public function clone_bubbling_event_should_have_bubbles_true():void
+		{
+			var bubblingEvent:GenericEvent = new GenericEvent(true);
+			var theClone:IEvent = bubblingEvent.clone();
+			assertTrue(theClone.bubbles);
+		}
+
+
+	}
+}

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

@@ -0,0 +1,68 @@
+package org.osflash.signals
+{
+	import asunit.asserts.*;
+	import asunit.framework.IAsync;
+
+	public class PriorityListenersTest
+	{	
+	    [Inject]
+	    public var async:IAsync;
+	    
+		public var completed:DeluxeSignal;
+		private var listenersCalled:Array;
+
+		[Before]
+		public function setUp():void
+		{
+			completed = new DeluxeSignal(this);
+			listenersCalled = [];
+		}
+
+		[After]
+		public function tearDown():void
+		{
+			completed.removeAll();
+			completed = null;
+			listenersCalled = null;
+		}
+		//////
+		[Test]
+		public function listener_added_second_with_higher_priority_should_be_called_first():void
+		{
+			completed.addWithPriority( async.add(listener1, 5) );
+			completed.addWithPriority( async.add(listener0, 5), 10 );
+			
+			completed.dispatch();
+		}
+		
+		private function listener0():void
+		{
+			listenersCalled.push(arguments.callee);
+			assertSame('this should be the first listener called', arguments.callee, listenersCalled[0]);
+		}
+		
+		private function listener1():void
+		{
+			listenersCalled.push(arguments.callee);
+			assertSame('this should be the second listener called', arguments.callee, listenersCalled[1]);
+		}
+		
+		private function listener2():void
+		{
+			listenersCalled.push(arguments.callee);
+			assertSame('this should be the third listener called', arguments.callee, listenersCalled[2]);
+		}
+		//////
+		[Test]
+		public function listeners_added_with_same_priority_should_be_called_in_order_added():void
+		{
+			completed.addWithPriority( async.add(listener0, 5), 10 );
+			completed.addWithPriority( async.add(listener1, 5), 10 );
+			completed.addWithPriority( async.add(listener2, 5), 10 );
+			
+			completed.dispatch();
+		}
+		
+		
+	}
+}

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

@@ -0,0 +1,51 @@
+package org.osflash.signals
+{
+	import asunit.asserts.*;
+	import asunit.framework.IAsync;
+
+	import org.osflash.signals.events.GenericEvent;
+
+	public class RedispatchedEventTest
+	{	
+	    [Inject]
+	    public var async:IAsync;
+	    
+		public var completed:DeluxeSignal;
+		protected var originalEvent:GenericEvent;
+
+		[Before]
+		public function setUp():void
+		{
+			completed = new DeluxeSignal(this);
+		}
+
+		[After]
+		public function tearDown():void
+		{
+			completed.removeAll();
+			completed = null;
+		}
+		//////
+		[Test]
+		public function dispatch_event_already_dispatched_should_clone_it():void
+		{
+			completed.add(async.add(redispatchEvent, 10));
+			originalEvent = new GenericEvent();
+			completed.dispatch(originalEvent);
+		}
+		
+		private function redispatchEvent(e:GenericEvent):void
+		{
+			DeluxeSignal(e.signal).removeAll();
+			assertSame(originalEvent, e);
+			completed.add(async.add(check_redispatched_event_is_not_original, 10));
+			
+			completed.dispatch(originalEvent);
+		}
+		
+		private function check_redispatched_event_is_not_original(e:GenericEvent):void
+		{
+			assertNotSame(originalEvent, e);
+		}
+	}
+}

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

@@ -0,0 +1,74 @@
+package org.osflash.signals
+{
+	import asunit.asserts.*;
+	import asunit.framework.IAsync;
+
+	public class SignalDispatchArgsTest
+	{
+	    [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 dispatch_two_correct_value_objects_should_succeed():void
+		{
+			var signal:Signal = new Signal(String, uint);
+			signal.dispatch("the Answer", 42);
+		}
+		
+		[Test(expects="ArgumentError")]
+		public function dispatch_fewer_value_objects_than_value_classes_should_should_throw_ArgumentError():void
+		{
+			var signal:Signal = new Signal(Date, Array);
+			signal.dispatch(new Date());
+		}
+		
+		[Test]
+		public function dispatch_more_value_objects_than_value_classes_should_succeed():void
+		{
+			var signal:Signal = new Signal(Date, Array);
+			signal.dispatch(new Date(), new Array(), "extra value object");
+		}
+		
+		[Test]
+		public function dispatch_values_with_no_value_classes_defined_should_pass_to_listener():void
+		{
+			var signalNoValueClasses:Signal = new Signal();
+			signalNoValueClasses.add( async.add(checkDispatchedValues, 10) );
+			signalNoValueClasses.dispatch(22, 'done', new Date());
+		}
+		
+		private function checkDispatchedValues(a:uint, b:String, c:Date):void
+		{
+			assertEquals('correct number of arguments were dispatched', 3, arguments.length);
+			assertEquals('the uint was dispatched', 22, a);
+			assertEquals('the String was dispatched', 'done', b);
+			assertTrue('a Date was dispatched', c is Date);
+		}
+
+		[Test(expects="ArgumentError")]
+		public function dispatch_one_correct_and_one_incorrect_value_object_should_throw_ArgumentError():void
+		{
+			var signal:Signal = new Signal(Date, Array);
+			signal.dispatch(new Date(), "wrong value type");
+		}
+		
+		
+		
+		
+	}
+}

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

@@ -0,0 +1,55 @@
+package org.osflash.signals
+{
+	import asunit.asserts.*;
+	import asunit.framework.IAsync;
+
+	public class SignalDispatchNoArgsTest
+	{	
+	    [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 dispatch_no_args_should_call_listener_with_no_args():void
+		{
+			completed.add( async.add(onCompleted, 10) );
+			completed.dispatch();
+		}
+		
+		private function onCompleted():void
+		{
+			assertEquals(0, arguments.length);
+		}
+		//////
+		[Test]
+		public function addOnce_in_handler_and_dispatch_should_call_new_listener():void
+		{
+			completed.addOnce( async.add(addOnceInHandler, 10) );
+			completed.dispatch();
+		}
+		
+		protected function addOnceInHandler():void
+		{
+			completed.addOnce( async.add(secondAddOnceListener, 10) );
+			completed.dispatch();
+		}
+		
+		protected function secondAddOnceListener():void
+		{
+		}
+	}
+}

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

@@ -0,0 +1,81 @@
+package org.osflash.signals
+{
+	import asunit.asserts.*;
+	import asunit.framework.IAsync;
+
+	public class SignalDispatchNonEventTest
+	{	
+	    [Inject]
+	    public var async:IAsync;
+	    
+		public var completed:Signal;
+
+		[Before]
+		public function setUp():void
+		{
+			completed = new Signal(Date);
+		}
+
+		[After]
+		public function tearDown():void
+		{
+			completed.removeAll();
+			completed = null;
+		}
+		
+		/**
+		 * Captures bug where dispatching 0 was considered null.
+		 */
+		[Test]
+		public function dispatch_zero_should_call_listener_with_zero():void
+		{
+			completed = new Signal(Number);
+			completed.add( async.add(onZero, 10) );
+			completed.dispatch(0);
+		}
+		
+		private function onZero(num:Number):void
+		{
+			assertEquals(0, num);
+		}
+		//////
+		[Test]
+		public function dispatch_2_zeroes_should_call_listener_with_2_zeroes():void
+		{
+			completed = new Signal(Number, Number);
+			completed.add( async.add(onZeroZero, 10) );
+			completed.dispatch(0, 0);
+		}
+		
+		private function onZeroZero(a:Object, b:Object):void
+		{
+			assertEquals(0, a);
+			assertEquals(0, b);
+		}
+		//////
+		[Test]
+		public function dispatch_null_should_call_listener_with_null():void
+		{
+			completed.addOnce( async.add(checkNullDate, 10) );
+			completed.dispatch(null);
+		}
+		
+		private function checkNullDate(date:Date):void
+		{
+			assertNull(date);
+		}
+		//////
+		[Test]
+		public function dispatch_null_through_int_Signal_should_be_autoconverted_to_zero():void
+		{
+			completed = new Signal(int);
+			completed.addOnce( async.add(checkNullConvertedToZero, 10) );
+			completed.dispatch(null);
+		}
+		
+		private function checkNullConvertedToZero(intValue:int):void
+		{
+			assertEquals('null was converted to 0', 0, intValue);
+		}
+	}
+}

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

@@ -0,0 +1,47 @@
+package org.osflash.signals
+{
+	import asunit.asserts.*;
+	import asunit.framework.IAsync;
+
+	public class SignalSplitInterfacesTest
+	{	
+	    [Inject]
+	    public var async:IAsync;
+	    
+		// Notice the use of the ISignal interface, rather than Signal.
+		// This makes dispatch() inaccessible unless the ISignal is cast to IDispatcher or Signal.
+		public var completed:ISignal;
+
+		[Before]
+		public function setUp():void
+		{
+			completed = new Signal();
+		}
+
+		[After]
+		public function tearDown():void
+		{
+			Signal(completed).removeAll();
+			completed = null;
+		}
+		
+		[Test]
+		public function cast_ISignal_to_IDispatcher_and_dispatch():void
+		{
+			completed.addOnce( async.add(onCompleted, 10) );
+			IDispatcher(completed).dispatch();
+		}
+		
+		private function onCompleted():void
+		{
+			assertEquals(0, arguments.length);
+		}
+		
+		[Test]
+		public function cast_ISignal_to_Signal_and_dispatch():void
+		{
+			completed.addOnce( async.add(onCompleted, 10) );
+			Signal(completed).dispatch();
+		}
+	}
+}