as3signals 0.7.0

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

@@ -0,0 +1,43 @@
+package org.osflash.signals
+{
+	import asunit.asserts.*;
+	import asunit.framework.IAsync;
+
+	public class DeluxeSignalDispatchExtraArgsTest
+	{
+	    [Inject]
+	    public var async:IAsync;
+	    
+		public var completed:DeluxeSignal;
+
+		[Before]
+		public function setUp():void
+		{
+			completed = new DeluxeSignal(this);
+		}
+
+		[After]
+		public function tearDown():void
+		{
+			completed.removeAll();
+			completed = null;
+		}
+		//////
+		[Test]
+		public function dispatch_extra_args_should_call_listener_with_extra_args():void
+		{
+			completed.add( async.add(onCompleted, 10) );
+			completed.dispatch(22, 'done', new Date());
+		}
+		
+		private function onCompleted(a:uint, b:String, c:Date):void
+		{
+			assertEquals(3, arguments.length);
+			assertEquals(22, a);
+			assertEquals('done', b);
+			assertTrue(c is Date);
+		}
+		//////
+		
+	}
+}

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

@@ -0,0 +1,55 @@
+package org.osflash.signals
+{
+	import asunit.asserts.*;
+	import asunit.framework.IAsync;
+
+	public class DeluxeSignalDispatchNoArgsTest
+	{	
+	    [Inject]
+	    public var async:IAsync;
+
+		public var completed:DeluxeSignal;
+
+		[Before]
+		public function setUp():void
+		{
+			completed = new DeluxeSignal(this);
+		}
+
+		[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/DeluxeSignalDispatchNonEventTest.as

@@ -0,0 +1,67 @@
+package org.osflash.signals
+{
+	import asunit.asserts.*;
+	import asunit.framework.IAsync;
+
+	public class DeluxeSignalDispatchNonEventTest
+	{	
+	    [Inject]
+	    public var async:IAsync;
+	    
+		public var completed:DeluxeSignal;
+
+		[Before]
+		public function setUp():void
+		{
+			completed = new DeluxeSignal(this, 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 DeluxeSignal(this, Number);
+			completed.add( async.add(onZero, 10) );
+			completed.dispatch(0);
+		}
+		
+		private function onZero(num:Number):void
+		{
+			assertEquals(0, num);
+		}
+		//////
+		[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_DeluxeSignal_should_be_autoconverted_to_zero():void
+		{
+			completed = new DeluxeSignal(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/DeluxeSignalSplitInterfacesTest.as

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

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

@@ -0,0 +1,134 @@
+package org.osflash.signals
+{
+	import asunit.asserts.*;
+	import asunit.framework.IAsync;
+
+	public class DeluxeSignalTest
+	{	
+	    [Inject]
+	    public var async:IAsync;
+	    
+		private var completed:DeluxeSignal;
+		
+		[Before]
+		public function setUp():void
+		{
+			completed = new DeluxeSignal(this);
+		}
+		
+		[After]
+		public function tearDown():void
+		{
+			completed.removeAll();
+			completed = null;
+		}
+
+		[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);
+		}
+		
+		private function newEmptyHandler():Function
+		{
+			return function():void {};
+		}
+		
+		//////
+		[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();
+		}
+		
+		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();
+		}
+		
+		private function addListenerDuringDispatch():void
+		{
+			completed.add(failIfCalled);
+		}
+		
+		private function failIfCalled():void
+		{
+			fail("This listener should not be called.");
+		}
+		
+		
+		//////
+		[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);
+		}
+		
+		//////
+		[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/DeluxeSignalWithBubblingEventTest.as

@@ -0,0 +1,129 @@
+package org.osflash.signals
+{
+	import asunit.asserts.*;
+	import asunit.framework.IAsync;
+
+	import org.osflash.signals.events.GenericEvent;
+	import org.osflash.signals.events.IBubbleEventHandler;
+	import org.osflash.signals.events.IEvent;
+
+	public class DeluxeSignalWithBubblingEventTest implements IBubbleEventHandler
+	{
+	    [Inject]
+	    public var async:IAsync;
+	
+		protected var theParent:IBubbleEventHandler;
+		protected var theChild:Child;
+		protected var theGrandChild:Child;
+		protected var cancelTimeout:Function;
+
+		[Before]
+		public function setUp():void
+		{
+			theParent = this;
+			theChild = new Child(this, 'theChild');
+			theGrandChild = new Child(theChild, 'theGrandChild');
+		}
+
+		[After]
+		public function tearDown():void
+		{
+			theChild = null;
+			theGrandChild = null;
+			cancelTimeout = null;
+		}
+		
+		[Test]
+		public function parent_child_relationships():void
+		{
+			assertSame("theChild's parent is this", this, theChild.parent);
+			assertTrue("this can handle bubbling events", this is IBubbleEventHandler);
+		}
+
+		[Test]
+		public function dispatch_bubbling_event_from_theGrandChild_should_bubble_to_parent_IBubbleHandler():void
+		{
+			// If cancelTimeout() isn't called, this test will fail.
+			cancelTimeout = async.add(null, 10);
+			var event:IEvent = new GenericEvent();
+			event.bubbles = true;
+			
+			theGrandChild.completed.dispatch(event);
+		}
+		
+		public function onEventBubbled(e:IEvent):Boolean
+		{
+			cancelTimeout();
+			assertSame('e.target should be the object that originally dispatched event', theGrandChild, e.target);
+			assertSame('e.currentTarget should be the object receiving the bubbled event', this, e.currentTarget);
+			return false;
+		}
+		
+		[Test]
+		public function returning_false_from_onEventBubbled_should_stop_bubbling():void
+		{
+			var bubbleHater:BubbleHater = new BubbleHater();
+			theChild = new Child(bubbleHater, 'bubblePopper');
+			theChild.popsBubbles = true;
+			theGrandChild = new Child(theChild, 'bubbleBlower');
+			
+			var bubblingEvent:IEvent = new GenericEvent(true);
+			// Will only complete without error if theChild pops the bubble.
+			theGrandChild.completed.dispatch(bubblingEvent);
+		}
+		
+		[Test(expects="flash.errors.IllegalOperationError")]
+		public function returning_true_from_onEventBubbled_should_continue_bubbling():void
+		{
+			var bubbleHater:BubbleHater = new BubbleHater();
+			theChild = new Child(bubbleHater, 'bubblePopper');
+			// Changing popsBubbles to false will fail the test nicely.
+			theChild.popsBubbles = false;
+			theGrandChild = new Child(theChild, 'bubbleBlower');
+			
+			var bubblingEvent:IEvent = new GenericEvent(true);
+			// Because theChild didn't pop the bubble, this causes bubbleHater to throw an error.
+			theGrandChild.completed.dispatch(bubblingEvent);
+		}
+	}
+}
+
+import org.osflash.signals.DeluxeSignal;
+import org.osflash.signals.events.IBubbleEventHandler;
+import org.osflash.signals.events.IEvent;
+
+import flash.errors.IllegalOperationError;
+
+class Child implements IBubbleEventHandler
+{
+	public var parent:Object;
+	public var completed:DeluxeSignal;
+	public var name:String;
+	public var popsBubbles:Boolean = false;
+	
+	public function Child(parent:Object = null, name:String = '')
+	{
+		this.parent = parent;
+		this.name = name;
+		completed = new DeluxeSignal(this);
+	}
+	
+	public function toString():String
+	{
+		return '[Child '+name+']';
+	}
+	
+	public function onEventBubbled(event:IEvent):Boolean
+	{
+		return !popsBubbles;
+	}
+}
+
+class BubbleHater implements IBubbleEventHandler
+{
+	public function onEventBubbled(event:IEvent):Boolean
+	{
+		throw new IllegalOperationError('I SAID NO BUBBLES!!!');
+		return false;
+	}
+}

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

@@ -0,0 +1,84 @@
+package org.osflash.signals
+{
+	import asunit.asserts.*;
+	import asunit.framework.IAsync;
+
+	import org.osflash.signals.events.GenericEvent;
+
+	public class DeluxeSignalWithCustomEventTest
+	{	
+	    [Inject]
+	    public var async:IAsync;
+	    
+		public var messaged:DeluxeSignal;
+
+		[Before]
+		public function setUp():void
+		{
+			messaged = new DeluxeSignal(this, 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('source of the event', messaged, e.signal);
+			assertEquals('target of the event', this, e.target);
+			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 {});
+		}
+	}
+}
+
+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);
+	}
+	
+}
+