diff --git a/src/org/osflash/signals/natives/NativeMappedSignal.as b/src/org/osflash/signals/natives/NativeMappedSignal.as index eafc464..f2ebafd 100644 --- a/src/org/osflash/signals/natives/NativeMappedSignal.as +++ b/src/org/osflash/signals/natives/NativeMappedSignal.as @@ -40,6 +40,8 @@ package org.osflash.signals.natives public function NativeMappedSignal(target:IEventDispatcher, eventType:String, eventClass:Class=null, ... mappedTypes) { super(target, eventType, eventClass); + // Cannot use super.apply(null, mappedTypes), so allow the subclass to call super(mappedTypes). + mappedTypes = (mappedTypes.length == 1 && mappedTypes[0] is Array) ? mappedTypes[0]:mappedTypes; valueClasses = mappedTypes; } diff --git a/src/org/osflash/signals/relaxed/RelaxedDeluxeSignal.as b/src/org/osflash/signals/relaxed/RelaxedDeluxeSignal.as new file mode 100644 index 0000000..e0afecd --- /dev/null +++ b/src/org/osflash/signals/relaxed/RelaxedDeluxeSignal.as @@ -0,0 +1,96 @@ +package org.osflash.signals.relaxed +{ + import org.osflash.signals.DeluxeSignal; + import org.osflash.signals.ISlot; + + /** + * Allows the valueClasses to be set in MXML, e.g. + * {[String, uint]} + */ + [DefaultProperty("valueClasses")] + /** + * Signal dispatches events to multiple listeners. + * It is inspired by C# events and delegates, and by + * signals and slots + * in Qt. + * A Signal adds event dispatching functionality through composition and interfaces, + * rather than inheriting from a dispatcher. + *

+ * Project home: http://github.com/robertpenner/as3-signals/ + */ + public class RelaxedDeluxeSignal extends DeluxeSignal + { + /** + * Creates a RelaxedDeluxeSignal instance to dispatch events on behalf of a target object. + * @param target The object the signal is dispatching events on behalf of. + * @param valueClasses Any number of class references that enable type checks in dispatch(). + * For example, new DeluxeSignal(this, String, uint) + * would allow: signal.dispatch("the Answer", 42) + * but not: signal.dispatch(true, 42.5) + * nor: signal.dispatch() + * + * NOTE: Subclasses cannot call super.apply(null, valueClasses), + * but this constructor has logic to support super(valueClasses). + */ + public function RelaxedDeluxeSignal(target:Object=null, ...valueClasses) + { + // Cannot use super.apply(null, valueClasses), so allow the subclass to call super(valueClasses). + valueClasses = (valueClasses.length == 1 && valueClasses[0] is Array) ? valueClasses[0]:valueClasses; + super(target, valueClasses); + _stateController = new RelaxedStateController(); + } + + protected var _stateController : RelaxedStateController; + + /** + * @inheritDoc + * @throws ArgumentError ArgumentError: Incorrect number of arguments. + * @throws ArgumentError ArgumentError: Value object is not an instance of the appropriate valueClasses Class. + */ + override public function dispatch(...valueObjects):void + { + _stateController.dispatchedValueObjects = valueObjects; + _stateController.hasBeenDispatched = true; + super.dispatch.apply( this, valueObjects); + } + + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot addOnce() then add() the same listener without removing the relationship first. + * @throws ArgumentError ArgumentError: Given listener is null. + */ + override public function addOnceWithPriority(listener:Function, priority:int=0):ISlot + { + return _stateController.handleSlot( super.addOnceWithPriority( listener, priority ) ); + } + + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot addOnce() then add() the same listener without removing the relationship first. + * @throws ArgumentError ArgumentError: Given listener is null. + */ + override public function addWithPriority(listener:Function, priority:int=0):ISlot + { + return _stateController.handleSlot( super.addWithPriority( listener, priority ) ); + } + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot addOnce() then add() the same listener without removing the relationship first. + * @throws ArgumentError ArgumentError: Given listener is null. + */ + override public function addOnce(listener:Function):ISlot + { + return _stateController.handleSlot( super.addOnce( listener ) ); + } + + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot addOnce() then add() the same listener without removing the relationship first. + * @throws ArgumentError ArgumentError: Given listener is null. + */ + override public function add(listener:Function):ISlot + { + return _stateController.handleSlot( super.add( listener ) ); + } + } +} \ No newline at end of file diff --git a/src/org/osflash/signals/relaxed/RelaxedMonoSignal.as b/src/org/osflash/signals/relaxed/RelaxedMonoSignal.as new file mode 100644 index 0000000..db3e493 --- /dev/null +++ b/src/org/osflash/signals/relaxed/RelaxedMonoSignal.as @@ -0,0 +1,69 @@ +package org.osflash.signals.relaxed +{ + import org.osflash.signals.ISlot; + import org.osflash.signals.MonoSignal; + + /** + * Allows the valueClasses to be set in MXML, e.g. + * {[String, uint]} + */ + [DefaultProperty("valueClasses")] + + /** + * A MonoSignal can have only one listener. + */ + public class RelaxedMonoSignal extends MonoSignal + { + /** + * Creates a RelaxedMonoSignal instance to dispatch value objects. + * @param valueClasses Any number of class references that enable type checks in dispatch(). + * For example, new Signal(String, uint) + * would allow: signal.dispatch("the Answer", 42) + * but not: signal.dispatch(true, 42.5) + * nor: signal.dispatch() + * + * NOTE: Subclasses cannot call super.apply(null, valueClasses), + * but this constructor has logic to support super(valueClasses). + */ + public function RelaxedMonoSignal(...valueClasses) + { + // Cannot use super.apply(null, valueClasses), so allow the subclass to call super(valueClasses). + valueClasses = (valueClasses.length == 1 && valueClasses[0] is Array) ? valueClasses[0]:valueClasses; + super(valueClasses); + _stateController = new RelaxedStateController(); + } + protected var _stateController : RelaxedStateController; + + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot add or addOnce with a listener already added, remove the current listener first. + * @throws ArgumentError ArgumentError: Given listener is null. + */ + override public function add(listener:Function):ISlot + { + return _stateController.handleSlot( super.add( listener ) ); + } + + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot add or addOnce with a listener already added, remove the current listener first. + * @throws ArgumentError ArgumentError: Given listener is null. + */ + override public function addOnce(listener:Function):ISlot + { + return _stateController.handleSlot( super.addOnce( listener ) ); + } + + /** + * @inheritDoc + * @throws ArgumentError ArgumentError: Incorrect number of arguments. + * @throws ArgumentError ArgumentError: Value object is not an instance of the appropriate valueClasses Class. + */ + override public function dispatch(...valueObjects):void + { + _stateController.dispatchedValueObjects = valueObjects; + _stateController.hasBeenDispatched = true; + super.dispatch.apply( this, valueObjects); + } + } +} \ No newline at end of file diff --git a/src/org/osflash/signals/relaxed/RelaxedOnceSignal.as b/src/org/osflash/signals/relaxed/RelaxedOnceSignal.as new file mode 100644 index 0000000..311c530 --- /dev/null +++ b/src/org/osflash/signals/relaxed/RelaxedOnceSignal.as @@ -0,0 +1,72 @@ +package org.osflash.signals.relaxed +{ + import org.osflash.signals.ISlot; + import org.osflash.signals.OnceSignal; + + /** + * Allows the valueClasses to be set in MXML, e.g. + * {[String, uint]} + */ + [DefaultProperty("valueClasses")] + + /** + * @author Camille Reynders - info@creynders.be + * + * Signal dispatches events to multiple listeners. + * It is inspired by C# events and delegates, and by + * signals and slots + * in Qt. + * A Signal adds event dispatching functionality through composition and interfaces, + * rather than inheriting from a dispatcher. + *

+ * Project home: http://github.com/robertpenner/as3-signals/ + */ + + public class RelaxedOnceSignal extends OnceSignal + { + /** + * Creates a Signal instance to dispatch value objects. + * @param valueClasses Any number of class references that enable type checks in dispatch(). + * For example, new Signal(String, uint) + * would allow: signal.dispatch("the Answer", 42) + * but not: signal.dispatch(true, 42.5) + * nor: signal.dispatch() + * + * NOTE: In AS3, subclasses cannot call super.apply(null, valueClasses), + * but this constructor has logic to support super(valueClasses). + */ + public function RelaxedOnceSignal(...valueClasses) + { + // Cannot use super.apply(null, valueClasses), so allow the subclass to call super(valueClasses). + valueClasses = (valueClasses.length == 1 && valueClasses[0] is Array) ? valueClasses[0]:valueClasses; + super(valueClasses); + _stateController = new RelaxedStateController(); + } + + protected var _stateController : RelaxedStateController; + + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot addOnce() then add() the same listener without removing the relationship first. + * @throws ArgumentError ArgumentError: Given listener is null. + */ + override public function addOnce(listener:Function):ISlot + { + return _stateController.handleSlot( super.addOnce( listener ) ); + } + + + /** + * @inheritDoc + * @throws ArgumentError ArgumentError: Incorrect number of arguments. + * @throws ArgumentError ArgumentError: Value object is not an instance of the appropriate valueClasses Class. + */ + override public function dispatch(...valueObjects):void + { + _stateController.dispatchedValueObjects = valueObjects; + _stateController.hasBeenDispatched = true; + super.dispatch.apply( this, valueObjects); + } + + } +} \ No newline at end of file diff --git a/src/org/osflash/signals/relaxed/RelaxedPrioritySignal.as b/src/org/osflash/signals/relaxed/RelaxedPrioritySignal.as new file mode 100644 index 0000000..e8fd214 --- /dev/null +++ b/src/org/osflash/signals/relaxed/RelaxedPrioritySignal.as @@ -0,0 +1,69 @@ +package org.osflash.signals.relaxed +{ + import org.osflash.signals.ISlot; + import org.osflash.signals.PrioritySignal; + + public class RelaxedPrioritySignal extends PrioritySignal + { + public function RelaxedPrioritySignal(...valueClasses) + { + // Cannot use super.apply(null, valueClasses), so allow the subclass to call super(valueClasses). + valueClasses = (valueClasses.length == 1 && valueClasses[0] is Array) ? valueClasses[0]:valueClasses; + super(valueClasses); + _stateController = new RelaxedStateController(); + } + + protected var _stateController : RelaxedStateController; + + /** + * @inheritDoc + * @throws ArgumentError ArgumentError: Incorrect number of arguments. + * @throws ArgumentError ArgumentError: Value object is not an instance of the appropriate valueClasses Class. + */ + override public function dispatch(...valueObjects):void + { + _stateController.dispatchedValueObjects = valueObjects; + _stateController.hasBeenDispatched = true; + super.dispatch.apply( this, valueObjects); + } + + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot addOnce() then add() the same listener without removing the relationship first. + * @throws ArgumentError ArgumentError: Given listener is null. + */ + override public function addOnceWithPriority(listener:Function, priority:int=0):ISlot + { + return _stateController.handleSlot( super.addOnceWithPriority( listener, priority ) ); + } + + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot addOnce() then add() the same listener without removing the relationship first. + * @throws ArgumentError ArgumentError: Given listener is null. + */ + override public function addWithPriority(listener:Function, priority:int=0):ISlot + { + return _stateController.handleSlot( super.addWithPriority( listener, priority ) ); + } + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot addOnce() then add() the same listener without removing the relationship first. + * @throws ArgumentError ArgumentError: Given listener is null. + */ + override public function addOnce(listener:Function):ISlot + { + return _stateController.handleSlot( super.addOnce( listener ) ); + } + + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot addOnce() then add() the same listener without removing the relationship first. + * @throws ArgumentError ArgumentError: Given listener is null. + */ + override public function add(listener:Function):ISlot + { + return _stateController.handleSlot( super.add( listener ) ); + } + } +} \ No newline at end of file diff --git a/src/org/osflash/signals/relaxed/RelaxedSignal.as b/src/org/osflash/signals/relaxed/RelaxedSignal.as new file mode 100644 index 0000000..3f5c6c7 --- /dev/null +++ b/src/org/osflash/signals/relaxed/RelaxedSignal.as @@ -0,0 +1,52 @@ +package org.osflash.signals.relaxed +{ + import org.osflash.signals.ISignal; + import org.osflash.signals.ISlot; + import org.osflash.signals.Signal; + + public class RelaxedSignal extends Signal implements ISignal + { + public function RelaxedSignal(...valueClasses) + { + // Cannot use super.apply(null, valueClasses), so allow the subclass to call super(valueClasses). + valueClasses = (valueClasses.length == 1 && valueClasses[0] is Array) ? valueClasses[0]:valueClasses; + super(valueClasses); + _stateController = new RelaxedStateController(); + } + + protected var _stateController : RelaxedStateController; + + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot addOnce() then add() the same listener without removing the relationship first. + * @throws ArgumentError ArgumentError: Given listener is null. + */ + override public function add(listener:Function):ISlot + { + return _stateController.handleSlot( super.add( listener ) ); + } + + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot addOnce() then add() the same listener without removing the relationship first. + * @throws ArgumentError ArgumentError: Given listener is null. + */ + override public function addOnce(listener:Function):ISlot + { + return _stateController.handleSlot( super.addOnce( listener ) ); + } + + /** + * @inheritDoc + * @throws ArgumentError ArgumentError: Incorrect number of arguments. + * @throws ArgumentError ArgumentError: Value object is not an instance of the appropriate valueClasses Class. + */ + override public function dispatch(...valueObjects):void + { + _stateController.dispatchedValueObjects = valueObjects; + _stateController.hasBeenDispatched = true; + super.dispatch.apply( this, valueObjects); + } + + } +} \ No newline at end of file diff --git a/src/org/osflash/signals/relaxed/RelaxedStateController.as b/src/org/osflash/signals/relaxed/RelaxedStateController.as new file mode 100644 index 0000000..a4f1417 --- /dev/null +++ b/src/org/osflash/signals/relaxed/RelaxedStateController.as @@ -0,0 +1,39 @@ +package org.osflash.signals.relaxed +{ + import org.osflash.signals.ISlot; + + public class RelaxedStateController + { + public function RelaxedStateController() + { + } + + private var _hasBeenDispatched : Boolean = false; + private var _lastDispatchedValueObjects : *; + + public function get hasBeenDispatched():Boolean{ + return _hasBeenDispatched; + } + + public function set hasBeenDispatched(value:Boolean):void{ + _hasBeenDispatched = value; + } + + public function get dispatchedValueObjects():*{ + return _lastDispatchedValueObjects; + } + + public function set dispatchedValueObjects(value:*):void{ + _lastDispatchedValueObjects = value; + } + + public function handleSlot(slot:ISlot):ISlot{ + if( hasBeenDispatched ){ + slot.execute( dispatchedValueObjects ); + } + return slot; + } + + + } +} \ No newline at end of file diff --git a/src/org/osflash/signals/relaxed/natives/RelaxedNativeMappedSignal.as b/src/org/osflash/signals/relaxed/natives/RelaxedNativeMappedSignal.as new file mode 100644 index 0000000..f8470b8 --- /dev/null +++ b/src/org/osflash/signals/relaxed/natives/RelaxedNativeMappedSignal.as @@ -0,0 +1,72 @@ +package org.osflash.signals.relaxed.natives +{ + import flash.events.Event; + import flash.events.IEventDispatcher; + + import org.osflash.signals.ISlot; + import org.osflash.signals.natives.NativeMappedSignal; + import org.osflash.signals.relaxed.RelaxedStateController; + + /** + *

+ * The RelaxedNativeMappedSignal class is used to map/transform a native Event, + * relayed from an IEventDispatcher, into other forms of data, + * which are dispatched to all listeners. + *

+ *

This can be used to form a border where native flash Events do not cross.

+ */ + public class RelaxedNativeMappedSignal extends NativeMappedSignal + { + /** + * Creates a new RelaxedNativeMappedSignal instance to map/transform a native Event, + * relayed from an IEventDispatcher, into other forms of data, + * which are dispatched to all listeners. + * + * @param target An object that implements the flash.events.IEventDispatcher interface. + * @param eventType The event string name that would normally be passed to IEventDispatcher.addEventListener(). + * @param eventClass An optional class reference that enables an event type check in dispatch(). + * @param mappedTypes an optional list of types that enables the checking of the types mapped from an Event. + */ + public function RelaxedNativeMappedSignal(target:IEventDispatcher, eventType:String, eventClass:Class=null, ...mappedTypes) + { + // Cannot use super.apply(null, mappedTypes), so allow the subclass to call super(mappedTypes). + mappedTypes = (mappedTypes.length == 1 && mappedTypes[0] is Array) ? mappedTypes[0]:mappedTypes; + super(target, eventType, eventClass, mappedTypes); + _stateController = new RelaxedStateController(); + target.addEventListener( eventType, _handleEvent, false, 0, true ); + } + protected var _stateController : RelaxedStateController; + + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot addOnce() then add() the same listener without removing the relationship first. + * @throws ArgumentError ArgumentError: Given listener is null. + * @throws ArgumentError ArgumentError: Target object cannot be null. + */ + override public function addOnceWithPriority(listener:Function, priority:int=0):ISlot + { + return _stateController.handleSlot( super.addOnceWithPriority( listener, priority ) ); + } + + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot addOnce() then add() the same listener without removing the relationship first. + * @throws ArgumentError ArgumentError: Given listener is null. + * @throws ArgumentError ArgumentError: Target object cannot be null. + */ + override public function addWithPriority(listener:Function, priority:int=0):ISlot + { + return _stateController.handleSlot( super.addWithPriority( listener, priority ) ); + } + + private function _handleEvent( event : Event ):void + { + _stateController.dispatchedValueObjects = mapEvent( event ); + _stateController.hasBeenDispatched = true; + } + + + + + } +} \ No newline at end of file diff --git a/src/org/osflash/signals/relaxed/natives/RelaxedNativeRelaySignal.as b/src/org/osflash/signals/relaxed/natives/RelaxedNativeRelaySignal.as new file mode 100644 index 0000000..ef835ac --- /dev/null +++ b/src/org/osflash/signals/relaxed/natives/RelaxedNativeRelaySignal.as @@ -0,0 +1,64 @@ +package org.osflash.signals.relaxed.natives +{ + import flash.events.IEventDispatcher; + + import org.osflash.signals.ISlot; + import org.osflash.signals.natives.NativeRelaySignal; + import org.osflash.signals.relaxed.RelaxedStateController; + + /** + * The RelaxedNativeRelaySignal class is used to relay events from an IEventDispatcher + * to listeners. + * The difference as compared to NativeSignal is that + * NativeRelaySignal has its own dispatching code, + * whereas NativeSignal uses the IEventDispatcher to dispatch. + */ + public class RelaxedNativeRelaySignal extends NativeRelaySignal + { + /** + * Creates a new RelaxedNativeRelaySignal instance to relay events from an IEventDispatcher. + * @param target An object that implements the flash.events.IEventDispatcher interface. + * @param eventType The event string name that would normally be passed to IEventDispatcher.addEventListener(). + * @param eventClass An optional class reference that enables an event type check in dispatch(). + * Because the target is an IEventDispatcher, + * eventClass needs to be flash.events.Event or a subclass of it. + */ + public function RelaxedNativeRelaySignal(target:IEventDispatcher, eventType:String, eventClass:Class=null) + { + super(target, eventType, eventClass); + _stateController = new RelaxedStateController(); + target.addEventListener( eventType, _handleEvent, false, 0, true ); + } + + protected var _stateController : RelaxedStateController; + + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot addOnce() then add() the same listener without removing the relationship first. + * @throws ArgumentError ArgumentError: Given listener is null. + * @throws ArgumentError ArgumentError: Target object cannot be null. + */ + override public function addOnceWithPriority(listener:Function, priority:int=0):ISlot + { + return _stateController.handleSlot( super.addOnceWithPriority( listener, priority ) ); + } + + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot addOnce() then add() the same listener without removing the relationship first. + * @throws ArgumentError ArgumentError: Given listener is null. + * @throws ArgumentError ArgumentError: Target object cannot be null. + */ + override public function addWithPriority(listener:Function, priority:int=0):ISlot + { + return _stateController.handleSlot( super.addWithPriority( listener, priority ) ); + } + + private function _handleEvent( ...valueObjects ):void + { + _stateController.dispatchedValueObjects = valueObjects; + _stateController.hasBeenDispatched = true; + } + + } +} \ No newline at end of file diff --git a/src/org/osflash/signals/relaxed/natives/RelaxedNativeSignal.as b/src/org/osflash/signals/relaxed/natives/RelaxedNativeSignal.as new file mode 100644 index 0000000..a415e38 --- /dev/null +++ b/src/org/osflash/signals/relaxed/natives/RelaxedNativeSignal.as @@ -0,0 +1,68 @@ +package org.osflash.signals.relaxed.natives +{ + import flash.events.Event; + import flash.events.IEventDispatcher; + + import org.osflash.signals.ISlot; + import org.osflash.signals.natives.NativeSignal; + import org.osflash.signals.relaxed.RelaxedStateController; + + /** + * Allows the eventClass to be set in MXML, e.g. + * {MouseEvent} + */ + [DefaultProperty("eventClass")] + + /** + * The RelaxedNativeSignal class provides a strongly-typed facade for an IEventDispatcher. + * A NativeSignal is essentially a mini-dispatcher locked to a specific event type and class. + * It can become part of an interface. + */ + public class RelaxedNativeSignal extends NativeSignal + { + /** + * Creates a RelaxedNativeSignal instance to dispatch events on behalf of a target object. + * @param target The object on whose behalf the signal is dispatching events. + * @param eventType The type of Event permitted to be dispatched from this signal. Corresponds to Event.type. + * @param eventClass An optional class reference that enables an event type check in dispatch(). Defaults to flash.events.Event if omitted. + */ + public function RelaxedNativeSignal(target:IEventDispatcher=null, eventType:String="", eventClass:Class=null) + { + super(target, eventType, eventClass); + _stateController = new RelaxedStateController(); + target.addEventListener( eventType, _handleEvent, false, 0, true ); + } + + protected var _stateController : RelaxedStateController; + + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot addOnce() then add() the same listener without removing the relationship first. + * @throws ArgumentError ArgumentError: Given listener is null. + * @throws ArgumentError ArgumentError: Target object cannot be null. + */ + override public function addOnceWithPriority(listener:Function, priority:int=0):ISlot + { + return _stateController.handleSlot( super.addOnceWithPriority( listener, priority ) ); + } + + /** + * @inheritDoc + * @throws flash.errors.IllegalOperationError IllegalOperationError: You cannot addOnce() then add() the same listener without removing the relationship first. + * @throws ArgumentError ArgumentError: Given listener is null. + * @throws ArgumentError ArgumentError: Target object cannot be null. + */ + override public function addWithPriority(listener:Function, priority:int=0):ISlot + { + return _stateController.handleSlot( super.addWithPriority( listener, priority ) ); + } + + private function _handleEvent( ...valueObjects ):void + { + _stateController.dispatchedValueObjects = valueObjects; + _stateController.hasBeenDispatched = true; + } + + + } +} \ No newline at end of file diff --git a/tests/org/osflash/signals/AllTests.as b/tests/org/osflash/signals/AllTests.as index 1840c84..4e34012 100644 --- a/tests/org/osflash/signals/AllTests.as +++ b/tests/org/osflash/signals/AllTests.as @@ -12,7 +12,7 @@ package org.osflash.signals import org.osflash.signals.natives.NativeSignalTest; import org.osflash.signals.natives.sets.DisplayObjectSignalSetTest; import org.osflash.signals.natives.sets.EventDispatcherSignalSetTest; - import org.osflash.signals.natives.sets.NativeSignalSetTest; + import org.osflash.signals.natives.sets.NativeSignalSetTest; [Suite] public class AllTests @@ -61,5 +61,6 @@ package org.osflash.signals public var _NativeSignalSetTest:NativeSignalSetTest; public var _EventDispatcherSignalSetTest:EventDispatcherSignalSetTest; public var _DisplayObjectSignalSetTest:DisplayObjectSignalSetTest; + } } diff --git a/tests/org/osflash/signals/relaxed/RelaxedDeluxeSignalTest.as b/tests/org/osflash/signals/relaxed/RelaxedDeluxeSignalTest.as new file mode 100644 index 0000000..ee300f6 --- /dev/null +++ b/tests/org/osflash/signals/relaxed/RelaxedDeluxeSignalTest.as @@ -0,0 +1,153 @@ +package org.osflash.signals.relaxed +{ + import asunit.asserts.assertEquals; + import asunit.asserts.assertTrue; + + import org.osflash.signals.IOnceSignal; + import org.osflash.signals.relaxed.support.RelaxedSignalTestVO; + + public class RelaxedDeluxeSignalTest + { + public function RelaxedDeluxeSignalTest() + { + } + private var _signal : RelaxedDeluxeSignal; + + [Before] + public function setUp():void + { + _signal = new RelaxedDeluxeSignal(); + } + + [After] + public function tearDown():void{ + _signal = null; + } + + [Test] + public function testRelaxedDispatchingToOnceAddedListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.dispatch(); + _signal.addOnce( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testRelaxedDispatchingToOnceAddedWitPriorityListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.dispatch(); + _signal.addOnceWithPriority( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testRelaxedDispatchingToAddedListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.dispatch(); + _signal.add( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testRelaxedDispatchingToAddedWithPriorityListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.dispatch(); + _signal.addWithPriority( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testListenerDoesntExistAfterAddedOnce():void{ + var handler : Function = function():void{ + } + _signal.dispatch(); + _signal.addOnce( handler ); + assertEquals( 'should have no listeners', 0, _signal.numListeners ); + } + + [Test] + public function testListenerExistsAfterAdded():void{ + var handler : Function = function():void{ + } + _signal.dispatch(); + _signal.add( handler ); + assertEquals( 'should have exactly one listener', 1, _signal.numListeners ); + } + + [Test] + public function testSingleVO():void{ + var value : String = 'foo'; + var passedPayload : String; + var handler : Function =function( payload : String ) : void{ + passedPayload = payload; + } + _signal.dispatch( value ); + _signal.addOnce( handler ); + assertEquals( 'should match', value, passedPayload ); + } + + [Test] + public function testMultipleVOs():void{ + var value1 : String = 'foo'; + var value2 : String = 'bar'; + var passedPayload1 : String; + var passedPayload2 : String; + var handler : Function =function( payload1 : String, payload2 : String ) : void{ + passedPayload1 = payload1; + passedPayload2 = payload2; + } + _signal.dispatch( value1, value2 ); + _signal.addOnce( handler ); + assertTrue( passedPayload1 == value1 && passedPayload2 == value2 ); + } + + [Test] + public function testArrayAsPayload():void{ + var value : Array = [ 'a', 'b', 'c' ]; + var passedPayload : Array; + var handler : Function =function( payload : Array ) : void{ + passedPayload = payload; + } + _signal.dispatch( value ); + _signal.addOnce( handler ); + assertEquals( 'should match', value, passedPayload ); + } + + [Test] + public function testStandardDispatchingStillWorks():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.addOnce( handler ); + _signal.dispatch(); + assertTrue( handlerExecuted ); + } + + [Test] + public function testStrictPayload():void{ + var value : RelaxedSignalTestVO = new RelaxedSignalTestVO(); + var passedPayload : RelaxedSignalTestVO; + var handler : Function =function( payload : RelaxedSignalTestVO ) : void{ + passedPayload = payload; + } + _signal= new RelaxedDeluxeSignal( this, RelaxedSignalTestVO ); + _signal.dispatch( value ); + _signal.addOnce( handler ); + assertEquals( 'should match', value, passedPayload ); + } + + } +} \ No newline at end of file diff --git a/tests/org/osflash/signals/relaxed/RelaxedMonoSignalTest.as b/tests/org/osflash/signals/relaxed/RelaxedMonoSignalTest.as new file mode 100644 index 0000000..c805334 --- /dev/null +++ b/tests/org/osflash/signals/relaxed/RelaxedMonoSignalTest.as @@ -0,0 +1,131 @@ +package org.osflash.signals.relaxed +{ + import asunit.asserts.assertEquals; + import asunit.asserts.assertTrue; + + import org.osflash.signals.relaxed.support.RelaxedSignalTestVO; + + public class RelaxedMonoSignalTest + { + public function RelaxedMonoSignalTest() + { + } + private var _signal : RelaxedMonoSignal; + + [Before] + public function setUp():void + { + _signal = new RelaxedMonoSignal(); + } + + [After] + public function tearDown():void{ + _signal = null; + } + + [Test] + public function testRelaxedDispatchingToOnceAddedListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.dispatch(); + _signal.addOnce( handler ); + assertTrue( handlerExecuted ); + } + + + [Test] + public function testRelaxedDispatchingToAddedListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.dispatch(); + _signal.add( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testListenerDoesntExistAfterAddedOnce():void{ + var handler : Function = function():void{ + } + _signal.dispatch(); + _signal.addOnce( handler ); + assertEquals( 'should have no listeners', 0, _signal.numListeners ); + } + + [Test] + public function testListenerExistsAfterAdded():void{ + var handler : Function = function():void{ + } + _signal.dispatch(); + _signal.add( handler ); + assertEquals( 'should have exactly one listener', 1, _signal.numListeners ); + } + + [Test] + public function testSingleVO():void{ + var value : String = 'foo'; + var passedPayload : String; + var handler : Function =function( payload : String ) : void{ + passedPayload = payload; + } + _signal.dispatch( value ); + _signal.addOnce( handler ); + assertEquals( 'should match', value, passedPayload ); + } + + [Test] + public function testMultipleVOs():void{ + var value1 : String = 'foo'; + var value2 : String = 'bar'; + var passedPayload1 : String; + var passedPayload2 : String; + var handler : Function =function( payload1 : String, payload2 : String ) : void{ + passedPayload1 = payload1; + passedPayload2 = payload2; + } + _signal.dispatch( value1, value2 ); + _signal.addOnce( handler ); + assertTrue( passedPayload1 == value1 && passedPayload2 == value2 ); + } + + [Test] + public function testArrayAsPayload():void{ + var value : Array = [ 'a', 'b', 'c' ]; + var passedPayload : Array; + var handler : Function =function( payload : Array ) : void{ + passedPayload = payload; + } + _signal.dispatch( value ); + _signal.addOnce( handler ); + assertEquals( 'should match', value, passedPayload ); + } + + [Test] + public function testStandardDispatchingStillWorks():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.addOnce( handler ); + _signal.dispatch(); + assertTrue( handlerExecuted ); + } + + [Test] + public function testStrictPayload():void{ + var value : RelaxedSignalTestVO = new RelaxedSignalTestVO(); + var passedPayload : RelaxedSignalTestVO; + var handler : Function =function( payload : RelaxedSignalTestVO ) : void{ + passedPayload = payload; + } + _signal= new RelaxedMonoSignal( RelaxedSignalTestVO ); + _signal.dispatch( value ); + _signal.addOnce( handler ); + assertEquals( 'should match', value, passedPayload ); + } + + } +} \ No newline at end of file diff --git a/tests/org/osflash/signals/relaxed/RelaxedOnceSignalTest.as b/tests/org/osflash/signals/relaxed/RelaxedOnceSignalTest.as new file mode 100644 index 0000000..8b223d9 --- /dev/null +++ b/tests/org/osflash/signals/relaxed/RelaxedOnceSignalTest.as @@ -0,0 +1,118 @@ +package org.osflash.signals.relaxed +{ + import asunit.asserts.assertEquals; + import asunit.asserts.assertTrue; + + import org.osflash.signals.IOnceSignal; + import org.osflash.signals.OnceSignal; + import org.osflash.signals.relaxed.support.RelaxedSignalTestVO; + + /** + * @author Camille Reynders - info@creynders.be + */ + + public class RelaxedOnceSignalTest + { + public function RelaxedOnceSignalTest() + { + } + + private var _signal : IOnceSignal; + + [Before] + public function setUp():void + { + _signal = new RelaxedOnceSignal(); + } + + [After] + public function tearDown():void{ + _signal = null; + } + + [Test] + public function testRelaxedDispatching():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.dispatch(); + _signal.addOnce( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testListenerDoesntExist():void{ + var handler : Function = function():void{ + } + _signal.dispatch(); + _signal.addOnce( handler ); + assertEquals( 'should have no listeners', 0, _signal.numListeners ); + } + + [Test] + public function testSingleVO():void{ + var value : String = 'foo'; + var passedPayload : String; + var handler : Function =function( payload : String ) : void{ + passedPayload = payload; + } + _signal.dispatch( value ); + _signal.addOnce( handler ); + assertEquals( 'should match', value, passedPayload ); + } + + [Test] + public function testMultipleVOs():void{ + var value1 : String = 'foo'; + var value2 : String = 'bar'; + var passedPayload1 : String; + var passedPayload2 : String; + var handler : Function =function( payload1 : String, payload2 : String ) : void{ + passedPayload1 = payload1; + passedPayload2 = payload2; + } + _signal.dispatch( value1, value2 ); + _signal.addOnce( handler ); + assertTrue( passedPayload1 == value1 && passedPayload2 == value2 ); + } + + [Test] + public function testArrayAsPayload():void{ + var value : Array = [ 'a', 'b', 'c' ]; + var passedPayload : Array; + var handler : Function =function( payload : Array ) : void{ + passedPayload = payload; + } + _signal.dispatch( value ); + _signal.addOnce( handler ); + assertEquals( 'should match', value, passedPayload ); + } + + [Test] + public function testStandardDispatchingStillWorks():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.addOnce( handler ); + _signal.dispatch(); + assertTrue( handlerExecuted ); + } + + [Test] + public function testStrictPayload():void{ + var value : RelaxedSignalTestVO = new RelaxedSignalTestVO(); + var passedPayload : RelaxedSignalTestVO; + var handler : Function =function( payload : RelaxedSignalTestVO ) : void{ + passedPayload = payload; + } + _signal= new RelaxedOnceSignal( RelaxedSignalTestVO ); + _signal.dispatch( value ); + _signal.addOnce( handler ); + assertEquals( 'should match', value, passedPayload ); + } + + + } +} \ No newline at end of file diff --git a/tests/org/osflash/signals/relaxed/RelaxedPrioritySignalTest.as b/tests/org/osflash/signals/relaxed/RelaxedPrioritySignalTest.as new file mode 100644 index 0000000..c73db5d --- /dev/null +++ b/tests/org/osflash/signals/relaxed/RelaxedPrioritySignalTest.as @@ -0,0 +1,152 @@ +package org.osflash.signals.relaxed +{ + import asunit.asserts.assertEquals; + import asunit.asserts.assertTrue; + + import org.osflash.signals.relaxed.support.RelaxedSignalTestVO; + + public class RelaxedPrioritySignalTest + { + public function RelaxedPrioritySignalTest() + { + } + private var _signal : RelaxedPrioritySignal; + + [Before] + public function setUp():void + { + _signal = new RelaxedPrioritySignal(); + } + + [After] + public function tearDown():void{ + _signal = null; + } + + [Test] + public function testRelaxedDispatchingToOnceAddedListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.dispatch(); + _signal.addOnce( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testRelaxedDispatchingToOnceAddedWitPriorityListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.dispatch(); + _signal.addOnceWithPriority( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testRelaxedDispatchingToAddedListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.dispatch(); + _signal.add( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testRelaxedDispatchingToAddedWithPriorityListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.dispatch(); + _signal.addWithPriority( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testListenerDoesntExistAfterAddedOnce():void{ + var handler : Function = function():void{ + } + _signal.dispatch(); + _signal.addOnce( handler ); + assertEquals( 'should have no listeners', 0, _signal.numListeners ); + } + + [Test] + public function testListenerExistsAfterAdded():void{ + var handler : Function = function():void{ + } + _signal.dispatch(); + _signal.add( handler ); + assertEquals( 'should have exactly one listener', 1, _signal.numListeners ); + } + + [Test] + public function testSingleVO():void{ + var value : String = 'foo'; + var passedPayload : String; + var handler : Function =function( payload : String ) : void{ + passedPayload = payload; + } + _signal.dispatch( value ); + _signal.addOnce( handler ); + assertEquals( 'should match', value, passedPayload ); + } + + [Test] + public function testMultipleVOs():void{ + var value1 : String = 'foo'; + var value2 : String = 'bar'; + var passedPayload1 : String; + var passedPayload2 : String; + var handler : Function =function( payload1 : String, payload2 : String ) : void{ + passedPayload1 = payload1; + passedPayload2 = payload2; + } + _signal.dispatch( value1, value2 ); + _signal.addOnce( handler ); + assertTrue( passedPayload1 == value1 && passedPayload2 == value2 ); + } + + [Test] + public function testArrayAsPayload():void{ + var value : Array = [ 'a', 'b', 'c' ]; + var passedPayload : Array; + var handler : Function =function( payload : Array ) : void{ + passedPayload = payload; + } + _signal.dispatch( value ); + _signal.addOnce( handler ); + assertEquals( 'should match', value, passedPayload ); + } + + [Test] + public function testStandardDispatchingStillWorks():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.addOnce( handler ); + _signal.dispatch(); + assertTrue( handlerExecuted ); + } + + [Test] + public function testStrictPayload():void{ + var value : RelaxedSignalTestVO = new RelaxedSignalTestVO(); + var passedPayload : RelaxedSignalTestVO; + var handler : Function =function( payload : RelaxedSignalTestVO ) : void{ + passedPayload = payload; + } + _signal= new RelaxedPrioritySignal( RelaxedSignalTestVO ); + _signal.dispatch( value ); + _signal.addOnce( handler ); + assertEquals( 'should match', value, passedPayload ); + } + + } +} \ No newline at end of file diff --git a/tests/org/osflash/signals/relaxed/RelaxedSignalTest.as b/tests/org/osflash/signals/relaxed/RelaxedSignalTest.as new file mode 100644 index 0000000..c8c656d --- /dev/null +++ b/tests/org/osflash/signals/relaxed/RelaxedSignalTest.as @@ -0,0 +1,134 @@ +package org.osflash.signals.relaxed +{ + import asunit.asserts.assertEquals; + import asunit.asserts.assertTrue; + + import org.osflash.signals.OnceSignal; + import org.osflash.signals.relaxed.support.RelaxedSignalTestVO; + + public class RelaxedSignalTest + { + public function RelaxedSignalTest() + { + } + private var _signal : RelaxedSignal; + + [Before] + public function setUp():void + { + _signal = new RelaxedSignal(); + } + + [After] + public function tearDown():void{ + _signal = null; + } + + [Test] + public function testRelaxedDispatchingToOnceAddedListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.dispatch(); + _signal.addOnce( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testRelaxedDispatchingToAddedListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.dispatch(); + _signal.add( handler ); + assertTrue( handlerExecuted ); + } + + + [Test] + public function testListenerDoesntExistAfterAddedOnce():void{ + var handler : Function = function():void{ + } + _signal.dispatch(); + _signal.addOnce( handler ); + assertEquals( 'should have no listeners', 0, _signal.numListeners ); + } + + [Test] + public function testListenerExistsAfterAdded():void{ + var handler : Function = function():void{ + } + _signal.dispatch(); + _signal.add( handler ); + assertEquals( 'should have exactly one listener', 1, _signal.numListeners ); + } + + [Test] + public function testSingleVO():void{ + var value : String = 'foo'; + var passedPayload : String; + var handler : Function =function( payload : String ) : void{ + passedPayload = payload; + } + _signal.dispatch( value ); + _signal.addOnce( handler ); + assertEquals( 'should match', value, passedPayload ); + } + + [Test] + public function testMultipleVOs():void{ + var value1 : String = 'foo'; + var value2 : String = 'bar'; + var passedPayload1 : String; + var passedPayload2 : String; + var handler : Function =function( payload1 : String, payload2 : String ) : void{ + passedPayload1 = payload1; + passedPayload2 = payload2; + } + _signal.dispatch( value1, value2 ); + _signal.addOnce( handler ); + assertTrue( passedPayload1 == value1 && passedPayload2 == value2 ); + } + + [Test] + public function testArrayAsPayload():void{ + var value : Array = [ 'a', 'b', 'c' ]; + var passedPayload : Array; + var handler : Function =function( payload : Array ) : void{ + passedPayload = payload; + } + _signal.dispatch( value ); + _signal.addOnce( handler ); + assertEquals( 'should match', value, passedPayload ); + } + + [Test] + public function testStandardDispatchingStillWorks():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.addOnce( handler ); + _signal.dispatch(); + assertTrue( handlerExecuted ); + } + + [Test] + public function testStrictPayload():void{ + var value : RelaxedSignalTestVO = new RelaxedSignalTestVO(); + var passedPayload : RelaxedSignalTestVO; + var handler : Function =function( payload : RelaxedSignalTestVO ) : void{ + passedPayload = payload; + } + _signal= new RelaxedSignal( RelaxedSignalTestVO ); + _signal.dispatch( value ); + _signal.addOnce( handler ); + assertEquals( 'should match', value, passedPayload ); + } + + + } +} + diff --git a/tests/org/osflash/signals/relaxed/RelaxedTestSuite.as b/tests/org/osflash/signals/relaxed/RelaxedTestSuite.as new file mode 100644 index 0000000..b237cb6 --- /dev/null +++ b/tests/org/osflash/signals/relaxed/RelaxedTestSuite.as @@ -0,0 +1,19 @@ +package org.osflash.signals.relaxed +{ + import org.osflash.signals.relaxed.natives.RelaxedNativeMappedSignalTest; + import org.osflash.signals.relaxed.natives.RelaxedNativeRelaySignalTest; + import org.osflash.signals.relaxed.natives.RelaxedNativeSignalTest; + + [Suite] + public class RelaxedTestSuite + { + public var _RelaxedOnceSignalTest : RelaxedOnceSignalTest; + public var _RelaxedDeluxeSignalTest : RelaxedDeluxeSignalTest; + public var _RelaxedMonoSignalTest : RelaxedMonoSignalTest; + public var _RelaxedPrioritySignalTest : RelaxedPrioritySignalTest; + public var _RelaxedSignalTest : RelaxedSignalTest; + public var _RelaxedNativeMappedSignalTest : RelaxedNativeMappedSignalTest; + public var _RelaxedNativeRelaySignalTest : RelaxedNativeRelaySignalTest; + public var _RelaxedNativeSignalTest : RelaxedNativeSignalTest; + } +} \ No newline at end of file diff --git a/tests/org/osflash/signals/relaxed/natives/RelaxedNativeMappedSignalTest.as b/tests/org/osflash/signals/relaxed/natives/RelaxedNativeMappedSignalTest.as new file mode 100644 index 0000000..25be260 --- /dev/null +++ b/tests/org/osflash/signals/relaxed/natives/RelaxedNativeMappedSignalTest.as @@ -0,0 +1,132 @@ +package org.osflash.signals.relaxed.natives +{ + import asunit.asserts.assertEquals; + import asunit.asserts.assertTrue; + + import flash.events.Event; + import flash.events.EventDispatcher; + + public class RelaxedNativeMappedSignalTest + { + + static private const FOO : String = "foo"; + + public function RelaxedNativeMappedSignalTest() + { + } + + private var _signal : RelaxedNativeMappedSignal; + private var _dispatcher : EventDispatcher; + + [Before] + public function setUp():void + { + _dispatcher = new EventDispatcher(); + _signal = new RelaxedNativeMappedSignal( _dispatcher, Event.COMPLETE, Event, String ) + _signal.mapTo( FOO ); + } + + [After] + public function tearDown():void{ + _signal = null; + } + + [Test] + public function testRelaxedDispatchingToOnceAddedListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + _signal.addOnce( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testRelaxedDispatchingToOnceAddedWitPriorityListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + _signal.addOnceWithPriority( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testRelaxedDispatchingToAddedListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + _signal.add( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testRelaxedDispatchingToAddedWithPriorityListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + _signal.addWithPriority( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testListenerDoesntExistAfterAddedOnce():void{ + var handler : Function = function():void{ + } + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + _signal.addOnce( handler ); + assertEquals( 'should have no listeners', 0, _signal.numListeners ); + } + + [Test] + public function testListenerExistsAfterAdded():void{ + var handler : Function = function():void{ + } + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + _signal.add( handler ); + assertEquals( 'should have exactly one listener', 1, _signal.numListeners ); + } + + [Test] + public function testEventIsPassed():void{ + var event : Event = new Event( Event.COMPLETE ); + var passedPayload : String; + var handler : Function =function( payload : String ) : void{ + passedPayload = payload; + } + _dispatcher.dispatchEvent( event ); + _signal.addOnce( handler ); + assertEquals( 'should match', FOO, passedPayload ); + } + + + [Test] + public function testStandardDispatchingStillWorks():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.addOnce( handler ); + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testDirectDispatch():void{ + var event : Event = new Event( Event.COMPLETE ); + var passedPayload : String; + var handler : Function =function( payload : String ) : void{ + passedPayload = payload; + } + _signal.dispatch( event ); + _signal.addOnce( handler ); + assertEquals( 'should match', FOO, passedPayload ); + } + } +} \ No newline at end of file diff --git a/tests/org/osflash/signals/relaxed/natives/RelaxedNativeRelaySignalTest.as b/tests/org/osflash/signals/relaxed/natives/RelaxedNativeRelaySignalTest.as new file mode 100644 index 0000000..0164256 --- /dev/null +++ b/tests/org/osflash/signals/relaxed/natives/RelaxedNativeRelaySignalTest.as @@ -0,0 +1,127 @@ +package org.osflash.signals.relaxed.natives +{ + import asunit.asserts.assertEquals; + import asunit.asserts.assertTrue; + + import flash.events.Event; + import flash.events.EventDispatcher; + + public class RelaxedNativeRelaySignalTest + { + public function RelaxedNativeRelaySignalTest() + { + } + private var _signal : RelaxedNativeRelaySignal; + private var _dispatcher : EventDispatcher; + + [Before] + public function setUp():void + { + _dispatcher = new EventDispatcher(); + _signal = new RelaxedNativeRelaySignal( _dispatcher, Event.COMPLETE, Event ); + } + + [After] + public function tearDown():void{ + _signal = null; + } + + [Test] + public function testRelaxedDispatchingToOnceAddedListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + _signal.addOnce( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testRelaxedDispatchingToOnceAddedWitPriorityListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + _signal.addOnceWithPriority( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testRelaxedDispatchingToAddedListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + _signal.add( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testRelaxedDispatchingToAddedWithPriorityListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + _signal.addWithPriority( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testListenerDoesntExistAfterAddedOnce():void{ + var handler : Function = function():void{ + } + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + _signal.addOnce( handler ); + assertEquals( 'should have no listeners', 0, _signal.numListeners ); + } + + [Test] + public function testListenerExistsAfterAdded():void{ + var handler : Function = function():void{ + } + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + _signal.add( handler ); + assertEquals( 'should have exactly one listener', 1, _signal.numListeners ); + } + + [Test] + public function testEventIsPassed():void{ + var event : Event = new Event( Event.COMPLETE ); + var passedEvent : Event; + var handler : Function =function( event : Event ) : void{ + passedEvent = event; + } + _dispatcher.dispatchEvent( event ); + _signal.addOnce( handler ); + assertEquals( 'should match', event.type, passedEvent.type ); + } + + + [Test] + public function testStandardDispatchingStillWorks():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.addOnce( handler ); + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testDirectDispatch():void{ + var event : Event = new Event( Event.COMPLETE ); + var passedEvent : Event; + var handler : Function =function( event : Event ) : void{ + passedEvent = event; + } + _signal.dispatch( event ); + _signal.addOnce( handler ); + assertEquals( 'should match', event.type, passedEvent.type ); + } + } +} \ No newline at end of file diff --git a/tests/org/osflash/signals/relaxed/natives/RelaxedNativeSignalTest.as b/tests/org/osflash/signals/relaxed/natives/RelaxedNativeSignalTest.as new file mode 100644 index 0000000..f5ece4d --- /dev/null +++ b/tests/org/osflash/signals/relaxed/natives/RelaxedNativeSignalTest.as @@ -0,0 +1,128 @@ +package org.osflash.signals.relaxed.natives +{ + import asunit.asserts.assertEquals; + import asunit.asserts.assertTrue; + + import flash.events.Event; + import flash.events.EventDispatcher; + + public class RelaxedNativeSignalTest + { + public function RelaxedNativeSignalTest() + { + } + private var _signal : RelaxedNativeSignal; + private var _dispatcher : EventDispatcher; + + [Before] + public function setUp():void + { + _dispatcher = new EventDispatcher(); + _signal = new RelaxedNativeSignal( _dispatcher, Event.COMPLETE, Event ); + } + + [After] + public function tearDown():void{ + _signal = null; + } + + [Test] + public function testRelaxedDispatchingToOnceAddedListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + _signal.addOnce( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testRelaxedDispatchingToOnceAddedWitPriorityListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + _signal.addOnceWithPriority( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testRelaxedDispatchingToAddedListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + _signal.add( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testRelaxedDispatchingToAddedWithPriorityListener():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + _signal.addWithPriority( handler ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testListenerDoesntExistAfterAddedOnce():void{ + var handler : Function = function():void{ + } + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + _signal.addOnce( handler ); + assertEquals( 'should have no listeners', 0, _signal.numListeners ); + } + + [Test] + public function testListenerExistsAfterAdded():void{ + var handler : Function = function():void{ + } + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + _signal.add( handler ); + assertEquals( 'should have exactly one listener', 1, _signal.numListeners ); + } + + [Test] + public function testEventIsPassed():void{ + var event : Event = new Event( Event.COMPLETE ); + var passedEvent : Event; + var handler : Function =function( event : Event ) : void{ + passedEvent = event; + } + _dispatcher.dispatchEvent( event ); + _signal.addOnce( handler ); + assertEquals( 'should match', event.type, passedEvent.type ); + } + + + [Test] + public function testStandardDispatchingStillWorks():void{ + var handlerExecuted : Boolean = false; + var handler : Function = function() : void{ + handlerExecuted = true; + } + _signal.addOnce( handler ); + _dispatcher.dispatchEvent( new Event( Event.COMPLETE ) ); + assertTrue( handlerExecuted ); + } + + [Test] + public function testDirectDispatch():void{ + var event : Event = new Event( Event.COMPLETE ); + var passedEvent : Event; + var handler : Function =function( event : Event ) : void{ + passedEvent = event; + } + _signal.dispatch( event ); + _signal.addOnce( handler ); + assertEquals( 'should match', event.type, passedEvent.type ); + } + + } +} \ No newline at end of file diff --git a/tests/org/osflash/signals/relaxed/support/RelaxedSignalTestVO.as b/tests/org/osflash/signals/relaxed/support/RelaxedSignalTestVO.as new file mode 100644 index 0000000..bf45eaa --- /dev/null +++ b/tests/org/osflash/signals/relaxed/support/RelaxedSignalTestVO.as @@ -0,0 +1,9 @@ +package org.osflash.signals.relaxed.support +{ + public class RelaxedSignalTestVO + { + public function RelaxedSignalTestVO() + { + } + } +} \ No newline at end of file