public void TestFourArgSignal()
{
Signal<int, int, int, int> signal = new Signal<int, int, int, int>();
int intendedResult = ((testInt + testIntTwo) * testIntThree) - testIntFour;
signal.AddListener(FourArgSignalCallback);
signal.Dispatch(testInt, testIntTwo, testIntThree, testIntFour);
Assert.AreEqual(intendedResult, testValue);
signal.RemoveListener(FourArgSignalCallback);
signal.Dispatch(testInt, testIntTwo, testIntThree, testIntFour);
Assert.AreEqual(intendedResult, testValue); //no-op due to remove
intendedResult += testInt;
intendedResult += testIntTwo;
intendedResult *= testIntThree;
intendedResult -= testIntFour;
signal.AddOnce(FourArgSignalCallback);
signal.Dispatch(testInt, testIntTwo, testIntThree, testIntFour);
Assert.AreEqual(intendedResult, testValue);
signal.Dispatch(testInt, testIntTwo, testIntThree, testIntFour);
Assert.AreEqual(intendedResult, testValue); //Add once should result in no-op
}
public void TestNoArgSignal()
{
Signal signal = new Signal();
signal.AddListener(NoArgSignalCallback);
signal.Dispatch();
Assert.AreEqual(1, testValue);
}
public void TestOneArgSignal()
{
Signal<int> signal = new Signal<int>();
signal.AddListener(OneArgSignalCallback);
signal.Dispatch(testInt);
Assert.AreEqual(testInt, testValue);
}
protected override void OnDestroy()
{
base.OnDestroy();
_onRelease.RemoveAllListeners();
_onRelease = null;
StopListenGestures();
_releaseGesture = null;
}
protected override void OnDestroy()
{
base.OnDestroy();
_onPressed.RemoveAllListeners();
_onPressed = null;
StopListenGestures();
_pressGesture = null;
}
protected override void Awake()
{
//Create signal for ITapGestureActor interface
_onTapped = new Signal<Vector3>();
//Get Gesture
_tapGesture = GetComponent<global::TouchScript.Gestures.TapGesture>();
base.Awake();
}
public void TestOnce()
{
Signal<int> signal = new Signal<int>();
signal.AddOnce(OneArgSignalCallback);
signal.Dispatch(testInt);
Assert.AreEqual(testInt, testValue);
signal.Dispatch(testInt);
Assert.AreEqual(testInt, testValue); //should not fire a second time
}
public void SetUp()
{
injectionBinder = new InjectionBinder ();
injectionBinder.Bind<IInjectionBinder>().Bind<IInstanceProvider>().ToValue(injectionBinder);
injectionBinder.Bind<ICommandBinder> ().To<SignalCommandBinder> ().ToSingleton();
commandBinder = injectionBinder.GetInstance<ICommandBinder> ();
pooledCommandBinder = commandBinder as IPooledCommandBinder;
singleSignal = new Signal<int>();
doubleSignal = new Signal<int, string>();
tripleSignal = new Signal<int, string, SimpleInterfaceImplementer>();
}
protected override void Awake()
{
//Create signal for ITransformGestureActor interface
_onStarted = new Signal<TransformInfos>();
_onTransformed = new Signal<TransformInfos>();
_onCompleted = new Signal<TransformInfos>();
_onCancelled = new Signal<TransformInfos>();
_onStateChanged = new Signal<TransformInfos>();
//Get Gesture
_transformGesture = GetComponent<global::TouchScript.Gestures.TransformGesture>();
base.Awake();
}
protected override void Awake()
{
//Create signal for ITransformGestureActor interface
_onFlickGesture = new Signal<FlickGestureInfo>();
//Get Gesture
_flickGesture = GetComponent<global::TouchScript.Gestures.FlickGesture>();
//Create gesture VO
gestureInfos = new FlickGestureInfo();
base.Awake();
}
protected override void OnDestroy()
{
base.OnDestroy();
//Destroy ITapGestureActor interface 's signals
_onTapped.RemoveAllListeners();
_onTapped = null;
//Destroy gesture reference
StopListenGestures();
_tapGesture = null;
}
protected override void OnDestroy()
{
base.OnDestroy();
//Destroy ITransformGestureActor interface 's signal
_onFlickGesture.RemoveAllListeners();
_onFlickGesture = null;
//Destroy gesture reference
StopListenGestures();
_flickGesture = null;
//Destroy gesture VO
gestureInfos = null;
}
protected override void mapBindings()
{
base.mapBindings();
//Injection binding.
//Map a mock model and a mock service, both as Singletons
//Example
//injectionBinder.Bind<IExampleModel>().To<ExampleModel>().ToSingleton();
//injectionBinder.Bind<IExampleService>().To<ExampleService>().ToSingleton();
var signalA = new Signal<string>();
var signalB = new Signal<string>();
injectionBinder.Bind<Signal<string>>().ToName(SignalEnumA.FromOutSide).ToValue(signalB).CrossContext();
injectionBinder.Bind<Signal<string>>().ToName(SignalEnumA.MySignalA).ToValue(signalA).CrossContext();
injectionBinder.Bind<Signal<string>>().ToName(SignalEnumB.FromOutSide).ToValue(signalA).CrossContext();
injectionBinder.Bind<Signal<string>>().ToName(SignalEnumB.MySignalB).ToValue(signalB).CrossContext();
}
public void TestTwoArgSignal()
{
Signal<int, int> signal = new Signal<int, int>();
signal.AddListener(TwoArgSignalCallback);
signal.Dispatch(testInt, testIntTwo);
Assert.AreEqual(testInt + testIntTwo, testValue);
signal.RemoveListener(TwoArgSignalCallback);
signal.Dispatch(testInt, testIntTwo);
Assert.AreEqual(testInt + testIntTwo, testValue); //Removed listener should have no-op
signal.AddOnce(TwoArgSignalCallback);
signal.Dispatch(testInt, testIntTwo);
Assert.AreEqual((testInt + testIntTwo) * 2, testValue);
signal.Dispatch(testInt, testIntTwo);
Assert.AreEqual((testInt + testIntTwo) * 2, testValue); //addonce should result in no-op
}
public void AddOnce_SignalWithFourTypesGivenSameCallbackMultipleTimes_ExpectsDelegateCalledOnlyOnce()
{
Signal<int, int, int, int> signal = new Signal<int, int, int, int>();
this.CreateFourInts();
signal.AddOnce(FourArgCallback);
signal.AddOnce(FourArgCallback);
signal.Dispatch(testInt, testIntTwo, testIntThree, testIntFour);
int expected = this.GetFourIntExpected();
Assert.AreEqual(expected, this.testValue);
}
public void TestRemoveAllListenersOne()
{
Signal<int> signal = new Signal<int>();
signal.AddListener(OneArgSignalCallback);
signal.AddListener(OneArgSignalCallbackTwo);
signal.RemoveAllListeners();
signal.Dispatch(testInt);
Assert.AreEqual(0, testValue);
}
public void AddListener_SignalWithTwoTypesGivenSameCallbackMultipleTimes_ExpectsDelegateCalledOnlyOnce()
{
Signal<int, int> signal = new Signal<int, int>();
this.CreateTwoInts();
signal.AddListener(TwoArgCallback);
signal.AddListener(TwoArgCallback);
signal.Dispatch(testInt, testIntTwo);
int expected = this.GetTwoIntExpected();
Assert.AreEqual(expected, this.testValue);
}
public void AddOnce_SignalWithOneTypeGivenSameCallbackMultipleTimes_ExpectsDelegateCalledOnlyOnce()
{
Signal<int> signal = new Signal<int>();
testInt = 42;
signal.AddOnce(OneArgSignalCallback);
signal.AddOnce(OneArgSignalCallback);
signal.Dispatch(testInt);
Assert.AreEqual(testInt, testValue);
}
public void AddOnce_SignalWithNoTypeGivenSameCallbackMultipleTimes_ExpectsDelegateCalledOnlyOnce()
{
Signal signal = new Signal();
intToIncrement = 0;
signal.AddOnce(SimpleSignalCallback);
signal.AddOnce(SimpleSignalCallback);
signal.Dispatch();
Assert.AreEqual(1, intToIncrement);
}
public void TestRemoveListenerDoesntBlowUp()
{
Signal signal = new Signal();
signal.RemoveListener(NoArgSignalCallback);
}
public void TestRemoveAllListenersFour()
{
Signal<int, int, int, int> signal = new Signal<int, int, int, int>();
signal.AddListener(FourArgSignalCallback);
signal.AddListener(FourArgSignalCallbackTwo);
signal.RemoveAllListeners();
signal.Dispatch(testInt, testIntTwo, testIntThree, testIntFour);
Assert.AreEqual(0, testValue);
}
protected override void Awake()
{
_onPressed = new Signal<Vector3>();
_pressGesture = GetComponent<global::TouchScript.Gestures.PressGesture>();
base.Awake();
}
public void TestRemoveListenerDoesntBlowUpFour()
{
Signal<int,int,int,int> signal = new Signal<int,int,int,int>();
signal.RemoveListener(FourArgSignalCallback);
}
public void TestRemoveListenerDoesntBlowUpOne()
{
Signal<int> signal = new Signal<int>();
signal.RemoveListener(OneArgSignalCallback);
}
public void TestFactoryInjectionGivesUniqueInstances()
{
injectionBinder.Bind<ISimpleInterface> ().To<SimpleInterfaceImplementer> ();
//This signal we dispatch
Signal<Signal<SimpleInterfaceImplementer>> senderSignal = new Signal<Signal<SimpleInterfaceImplementer>> ();
//This one is payload
Signal<SimpleInterfaceImplementer> payloadSignal = new Signal<SimpleInterfaceImplementer> ();
commandBinder.Bind (senderSignal).To<CommandWithInjectionAndSignal> ().Pooled();
payloadSignal.AddListener (cb);
//Dispatch the senderSignal twice, each time carrying the payloadSignal
senderSignal.Dispatch(payloadSignal);
senderSignal.Dispatch(payloadSignal);
Assert.AreEqual (2, instanceList.Count);
Assert.AreNotSame (instanceList [0], instanceList [1]);
}
public void GetTypes_ThreeType_ExpectsTypesReturnedInList()
{
Signal<int, string, float> signal = new Signal<int, string, float>();
var actual = signal.GetTypes();
var expected = this.GetThreeExpectedTypes();
Assert.AreEqual(expected, actual);
}
public void RemoveListener_NoType_ExpectsListenerRemoved()
{
Signal signal = new Signal();
signal.AddListener(NoArgSignalCallback);
signal.Dispatch();
Assert.AreEqual(1, testValue);
signal.RemoveListener(NoArgSignalCallback);
signal.Dispatch();
Assert.AreEqual(1, testValue);
}
public void GetTypes_FourType_ExpectsTypesReturnedInList()
{
Signal<int, string, float, Signal> signal = new Signal<int, string, float, Signal>();
var actual = signal.GetTypes();
var expected = this.GetThreeExpectedTypes();
expected.Add(typeof(Signal));
Assert.AreEqual(expected, actual);
}
// PRIVATE STATIC
//--------------------------------------
// Methods
//--------------------------------------
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
/// CONSTRUCTOR / DESTRUCTOR
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
///<summary>
/// Constructor
///</summary>
public CustomViewUI( )
{
//Debug.Log ("CustomViewUI.constructor()");
clearMessageClickSignal = new Signal();
loadMessageClickSignal = new Signal();
}
public void TestRemoveAllRemovesOnce()
{
Signal signal = new Signal();
signal.AddOnce(NoArgSignalCallback);
signal.AddOnce(NoArgSignalCallbackTwo);
signal.RemoveAllListeners();
signal.Dispatch();
Assert.AreEqual(0, testValue);
}
