--- /dev/null
+#ifndef SIGNAL_HELPER
+#define SIGNAL_HELPER
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Helper classes for testing DALi signal and slots
+
+class TestButton
+{
+public:
+
+ TestButton( unsigned int id )
+ : mId(id)
+ {
+ }
+
+ void Press()
+ {
+ mPanelDown.Emit( *this );
+ }
+
+ void Release()
+ {
+ mPanelUp.Emit( *this );
+ }
+
+ typedef Signal< void (TestButton&) > PanelDownSignal;
+ typedef Signal< void (TestButton&) > PanelUpSignal;
+
+ PanelDownSignal& DownSignal()
+ {
+ return mPanelDown;
+ }
+
+ PanelUpSignal& SignalUp()
+ {
+ return mPanelUp;
+ }
+
+ int GetId()
+ {
+ return mId;
+ }
+
+private:
+
+ int mId;
+ PanelDownSignal mPanelDown;
+ PanelUpSignal mPanelUp;
+};
+
+class TestApp : public ConnectionTracker
+{
+public:
+
+ TestApp()
+ : mButtonPressed( false ),
+ mVoidFunctionCalled( false )
+ {
+ }
+
+ void OnButtonPress( TestButton& button )
+ {
+ mButtonPressed = true;
+ mButtonId = button.GetId();
+ }
+
+ void OnButtonRelease( TestButton& button )
+ {
+ mButtonPressed = false;
+ mButtonId = button.GetId();
+ }
+
+ int GetButtonPressedId()
+ {
+ return mButtonId;
+ }
+
+ bool BoolReturnTestFalse()
+ {
+ return false;
+ }
+
+ bool BoolReturnTestTrue()
+ {
+ return true;
+ }
+
+ void VoidFunction()
+ {
+ mVoidFunctionCalled = true;
+ }
+
+ bool mButtonPressed;
+ bool mVoidFunctionCalled;
+ int mButtonId;
+};
+
+class TestSignals
+{
+public:
+
+ // Void return, no parameters
+ typedef Signal<void ()> VoidRetNoParamSignal;
+
+ // Void return, 1 value parameter
+ typedef Signal<void (int)> VoidRet1ValueParamSignal;
+
+ // Void return, 1 reference parameter
+ typedef Signal< void (int&)> VoidRet1RefParamSignal;
+
+ // Void return, 2 value parameters
+ typedef Signal<void (int, int)> VoidRet2ValueParamSignal;
+
+ // bool return, 1 value parameter
+ typedef Signal< bool (float)> BoolRet1ValueParamSignal;
+
+ // bool return, 2 value parameter
+ typedef Signal<bool (float, int) > BoolRet2ValueParamSignal;
+
+ // int return, 2 value parameter
+ typedef Signal<int (float, int)> IntRet2ValueParamSignal;
+
+ // float return, 0 parameters
+ typedef Signal< float () > FloatRet0ParamSignal;
+
+ // float return, 2 value parameters
+ typedef Signal<float (float, float) > FloatRet2ValueParamSignal;
+
+ // void return, 3 value parameters
+ typedef Signal<void (float, float, float) > VoidSignalTypeFloatValue3;
+
+ // float return, 3 value parameters
+ typedef Signal<float (float, float, float) > FloatSignalTypeFloatValue3;
+
+ VoidRetNoParamSignal& SignalVoidNone() { return mSignalVoid0; }
+ VoidRet1RefParamSignal& SignalVoid1Ref() { return mSignalVoid1R; }
+ VoidRet1ValueParamSignal& SignalVoid1Value() { return mSignalVoid1V; }
+ VoidRet2ValueParamSignal& SignalVoid2Value() { return mSignalVoid2V; }
+
+ BoolRet1ValueParamSignal& SignalBool1Value() { return mSignalBool1V; }
+ BoolRet2ValueParamSignal& SignalBool2Value() { return mSignalBool2V; }
+ IntRet2ValueParamSignal& SignalInt2Value() { return mSignalInt2V; }
+ FloatRet0ParamSignal& SignalFloat0() { return mSignalFloat0; }
+ FloatRet2ValueParamSignal& SignalFloat2Value() { return mSignalFloat2V; }
+
+ VoidSignalTypeFloatValue3& VoidSignalFloatValue3() { return mVoidSignalFloatValue3; }
+ FloatSignalTypeFloatValue3& FloatSignalFloatValue3() { return mFloatSignalFloatValue3; }
+
+ TestSignals()
+ {
+ }
+
+ void CheckNoConnections()
+ {
+ DALI_TEST_EQUALS( mSignalVoid0.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS( mSignalVoid1R.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS( mSignalVoid1V.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS( mSignalVoid2V.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS( mSignalBool1V.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS( mSignalBool2V.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS( mSignalInt2V.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS( mSignalFloat0.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS( mSignalFloat2V.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS( mVoidSignalFloatValue3.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS( mFloatSignalFloatValue3.GetConnectionCount(), 0u, TEST_LOCATION );
+ }
+
+ void EmitVoidSignalVoid()
+ {
+ mSignalVoid0.Emit();
+ }
+
+ void EmitVoidSignalIntRef(int& ref)
+ {
+ mSignalVoid1R.Emit(ref);
+ }
+
+ void EmitVoidSignalIntValue(int p1)
+ {
+ mSignalVoid1V.Emit(p1);
+ }
+
+ void EmitVoidSignalIntValueIntValue(int p1, int p2)
+ {
+ mSignalVoid2V.Emit(p1,p2);
+ }
+
+ bool EmitBoolSignalFloatValue(float p1)
+ {
+ return mSignalBool1V.Emit(p1);
+ }
+
+ bool EmitBoolSignalFloatValueIntValue(float p1, int p2)
+ {
+ return mSignalBool2V.Emit(p1, p2);
+ }
+
+ int EmitIntSignalFloatValueIntValue(float p1, int p2)
+ {
+ return mSignalInt2V.Emit(p1, p2);
+ }
+
+ float EmitFloat2VSignal(float p1, float p2)
+ {
+ return mSignalFloat2V.Emit(p1, p2);
+ }
+
+ float EmitFloat0Signal()
+ {
+ return mSignalFloat0.Emit();
+ }
+
+ void EmitVoidSignalFloatValue3(float p1, float p2, float p3)
+ {
+ mVoidSignalFloatValue3.Emit(p1, p2, p3);
+ }
+
+ float EmitFloatSignalFloatValue3(float p1, float p2, float p3)
+ {
+ return mFloatSignalFloatValue3.Emit(p1, p2, p3);
+ }
+
+private:
+
+ VoidRetNoParamSignal mSignalVoid0;
+ VoidRet1RefParamSignal mSignalVoid1R;
+ VoidRet1ValueParamSignal mSignalVoid1V;
+ VoidRet2ValueParamSignal mSignalVoid2V;
+ BoolRet1ValueParamSignal mSignalBool1V;
+ BoolRet2ValueParamSignal mSignalBool2V;
+ IntRet2ValueParamSignal mSignalInt2V;
+ FloatRet0ParamSignal mSignalFloat0;
+ FloatRet2ValueParamSignal mSignalFloat2V;
+ VoidSignalTypeFloatValue3 mVoidSignalFloatValue3;
+ FloatSignalTypeFloatValue3 mFloatSignalFloatValue3;
+};
+
+/**
+ * A helper class with various slots
+ */
+class TestSlotHandler : public ConnectionTracker
+{
+public:
+
+ TestSlotHandler()
+ : mIntParam1( 0 ),
+ mIntParam2( 0 ),
+ mIntParam3( 0 ),
+ mFloatParam1( 0.0f ),
+ mFloatParam2( 0.0f ),
+ mFloatParam3( 0.0f ),
+ mBoolReturn( false ),
+ mIntReturn( 0 ),
+ mFloatReturn( 0.0f ),
+ mHandled( false ),
+ mHandledCount( 0 )
+ {
+ }
+
+ void Reset()
+ {
+ mIntParam1 = 0;
+ mIntParam2 = 0;
+ mIntParam3 = 0;
+ mFloatParam1 = 0.0f;
+ mFloatParam2 = 0.0f;
+ mFloatParam3 = 0.0f;
+ mBoolReturn = false;
+ mIntReturn = 0;
+ mFloatReturn = 0.0f;
+ mHandled = false;
+ }
+
+ void VoidSlotVoid()
+ {
+ mHandled = true;
+ ++mHandledCount;
+ }
+
+ void VoidSlotVoidAlternative()
+ {
+ mHandled = true;
+ ++mHandledCount;
+ }
+
+ void VoidSlotIntRef( int& p1 )
+ {
+ mIntParam1 = p1;
+ mHandled = true;
+ ++mHandledCount;
+ }
+
+ void VoidSlotIntValue( int p1 )
+ {
+ mIntParam1 = p1;
+ mHandled = true;
+ ++mHandledCount;
+ }
+
+ void VoidDuplicateSlotIntValue( int p1 )
+ {
+ mIntParam2 = p1;
+ mHandled = true;
+ ++mHandledCount;
+ }
+
+ void VoidSlotIntValueIntValue( int p1, int p2 )
+ {
+ mIntParam1 = p1;
+ mIntParam2 = p2;
+ mHandled = true;
+ ++mHandledCount;
+ }
+
+ bool BoolSlotFloatValue( float p1 )
+ {
+ mFloatParam1 = p1;
+ mHandled = true;
+ ++mHandledCount;
+ return mBoolReturn;
+ }
+
+ bool BoolSlotFloatValueIntValue( float p1, int p2 )
+ {
+ mFloatParam1 = p1;
+ mIntParam2 = p2;
+ mHandled = true;
+ ++mHandledCount;
+ return mBoolReturn;
+ }
+
+ int IntSlotFloatValueIntValue( float p1, int p2 )
+ {
+ mFloatParam1 = p1;
+ mIntParam2 = p2;
+ mHandled = true;
+ ++mHandledCount;
+ return mIntReturn;
+ }
+
+ float FloatSlotVoid()
+ {
+ mHandled = true;
+ ++mHandledCount;
+ return mFloatReturn;
+ }
+
+ float FloatSlotFloatValueFloatValue( float p1, float p2 )
+ {
+ mFloatParam1 = p1;
+ mFloatParam2 = p2;
+ mHandled = true;
+ ++mHandledCount;
+ return mFloatReturn;
+ }
+
+ void VoidSlotFloatValue3( float p1, float p2, float p3 )
+ {
+ mFloatParam1 = p1;
+ mFloatParam2 = p2;
+ mFloatParam3 = p3;
+ mHandled = true;
+ ++mHandledCount;
+ }
+
+ float FloatSlotFloatValue3( float p1, float p2, float p3 )
+ {
+ mFloatParam1 = p1;
+ mFloatParam2 = p2;
+ mFloatParam3 = p3;
+ mHandled = true;
+ ++mHandledCount;
+ return mFloatReturn;
+ }
+
+ int mIntParam1, mIntParam2, mIntParam3;
+ float mFloatParam1, mFloatParam2, mFloatParam3;
+ bool mBoolReturn;
+ int mIntReturn;
+ float mFloatReturn;
+ bool mHandled;
+ int mHandledCount;
+};
+
+/**
+ * A version of TestSlotHandler which disconnects during the callback
+ */
+class TestSlotDisconnector : public ConnectionTracker
+{
+public:
+
+ TestSlotDisconnector()
+ : mIntParam1( 0 ),
+ mIntParam2( 0 ),
+ mIntParam3( 0 ),
+ mFloatParam1( 0.0f ),
+ mFloatParam2( 0.0f ),
+ mBoolReturn( false ),
+ mIntReturn( 0 ),
+ mFloatReturn( 0.0f ),
+ mHandled( false )
+ {
+ }
+
+ void Reset()
+ {
+ mIntParam1 = 0;
+ mIntParam2 = 0;
+ mIntParam3 = 0;
+ mFloatParam1 = 0.0f;
+ mFloatParam2 = 0.0f;
+ mBoolReturn = false;
+ mIntReturn = 0;
+ mFloatReturn = 0.0f;
+ mHandled = false;
+ }
+
+ void VoidConnectVoid( TestSignals::VoidRetNoParamSignal& signal )
+ {
+ mVoidSignalVoid = &signal;
+ signal.Connect( this, &TestSlotDisconnector::VoidSlotVoid );
+ }
+
+ void VoidSlotVoid()
+ {
+ mVoidSignalVoid->Disconnect( this, &TestSlotDisconnector::VoidSlotVoid );
+ mHandled = true;
+ }
+
+ void VoidConnectIntRef( TestSignals::VoidRet1RefParamSignal& signal )
+ {
+ mVoidSignalIntRef = &signal;
+ signal.Connect( this, &TestSlotDisconnector::VoidSlotIntRef );
+ }
+
+ void VoidSlotIntRef( int& p1 )
+ {
+ mVoidSignalIntRef->Disconnect( this, &TestSlotDisconnector::VoidSlotIntRef );
+ mIntParam1 = p1;
+ mHandled = true;
+ }
+
+ void VoidSlotIntValue( int p1 )
+ {
+ mIntParam1 = p1;
+ mHandled = true;
+ }
+
+ void VoidSlotIntValueIntValue( int p1, int p2 )
+ {
+ mIntParam1 = p1;
+ mIntParam2 = p2;
+ mHandled = true;
+ }
+
+ bool BoolSlotFloatValue( float p1 )
+ {
+ mFloatParam1 = p1;
+ mHandled = true;
+ return mBoolReturn;
+ }
+
+ bool BoolSlotFloatValueIntValue( float p1, int p2 )
+ {
+ mFloatParam1 = p1;
+ mIntParam2 = p2;
+ mHandled = true;
+ return mBoolReturn;
+ }
+
+ int IntSlotFloatValueIntValue( float p1, int p2 )
+ {
+ mFloatParam1 = p1;
+ mIntParam2 = p2;
+ mHandled = true;
+ return mIntReturn;
+ }
+
+ float FloatSlotVoid()
+ {
+ mHandled = true;
+ return mFloatReturn;
+ }
+
+ float FloatSlotFloatValueFloatValue( float p1, float p2 )
+ {
+ mFloatParam1 = p1;
+ mFloatParam2 = p2;
+ mHandled = true;
+ return mFloatReturn;
+ }
+
+ TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
+ TestSignals::VoidRet1RefParamSignal* mVoidSignalIntRef;
+
+ int mIntParam1, mIntParam2, mIntParam3;
+ float mFloatParam1, mFloatParam2;
+ bool mBoolReturn;
+ int mIntReturn;
+ float mFloatReturn;
+ bool mHandled;
+};
+
+/**
+ * A more complicated version of TestSlotDisconnector, which disconnects some but not all callbacks
+ */
+class TestSlotMultiDisconnector : public ConnectionTracker
+{
+public:
+
+ static const int NUM_SLOTS = 10;
+
+ TestSlotMultiDisconnector()
+ : mVoidSignalVoid( NULL )
+ {
+ Reset();
+ }
+
+ void Reset()
+ {
+ for( int i=0; i<NUM_SLOTS; ++i )
+ {
+ mSlotHandled[i] = false;
+ }
+ }
+
+ void ConnectAll( TestSignals::VoidRetNoParamSignal& signal )
+ {
+ mVoidSignalVoid = &signal;
+ signal.Connect( this, &TestSlotMultiDisconnector::Slot0 );
+ signal.Connect( this, &TestSlotMultiDisconnector::Slot1 );
+ signal.Connect( this, &TestSlotMultiDisconnector::Slot2 );
+ signal.Connect( this, &TestSlotMultiDisconnector::Slot3 );
+ signal.Connect( this, &TestSlotMultiDisconnector::Slot4 );
+ signal.Connect( this, &TestSlotMultiDisconnector::Slot5 );
+ signal.Connect( this, &TestSlotMultiDisconnector::Slot6 );
+ signal.Connect( this, &TestSlotMultiDisconnector::Slot7 );
+ signal.Connect( this, &TestSlotMultiDisconnector::Slot8 );
+ signal.Connect( this, &TestSlotMultiDisconnector::Slot9 );
+ }
+
+ void Slot0()
+ {
+ mSlotHandled[0] = true;
+ }
+
+ void Slot1()
+ {
+ mSlotHandled[1] = true;
+ }
+
+ void Slot2()
+ {
+ mSlotHandled[2] = true;
+ }
+
+ void Slot3()
+ {
+ mSlotHandled[3] = true;
+
+ // Disconnect the odd numbered lots, because we can
+ mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot1 );
+ mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot3 );
+ mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot5 );
+ mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot7 );
+ mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot9 );
+ }
+
+ void Slot4()
+ {
+ mSlotHandled[4] = true;
+ }
+
+ void Slot5()
+ {
+ mSlotHandled[5] = true;
+ }
+
+ void Slot6()
+ {
+ mSlotHandled[6] = true;
+ }
+
+ void Slot7()
+ {
+ mSlotHandled[7] = true;
+ }
+
+ void Slot8()
+ {
+ mSlotHandled[8] = true;
+ }
+
+ void Slot9()
+ {
+ mSlotHandled[9] = true;
+ }
+
+ TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
+
+ bool mSlotHandled[NUM_SLOTS];
+};
+
+
+/**
+ * A version of TestSlotHandler which disconnects during the callback
+ */
+class TestEmitDuringCallback : public ConnectionTracker
+{
+public:
+
+ TestEmitDuringCallback()
+ : mVoidSignalVoid( NULL ),
+ mHandled( false )
+ {
+ }
+
+ void VoidConnectVoid( TestSignals::VoidRetNoParamSignal& signal )
+ {
+ mVoidSignalVoid = &signal;
+ signal.Connect( this, &TestEmitDuringCallback::VoidSlotVoid );
+ }
+
+ void VoidSlotVoid()
+ {
+ // Emitting during Emit is very bad!
+ mVoidSignalVoid->Emit();
+
+ mHandled = true;
+ }
+
+ TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
+
+ bool mHandled;
+};
+
+
+/**
+ * A version of TestSlotHandler which uses SlotDelegate
+ */
+class TestSlotDelegateHandler // This does not inherit from ConnectionTrackerInterface!
+{
+public:
+
+ TestSlotDelegateHandler()
+ : mSlotDelegate( this ),
+ mIntParam1( 0 ),
+ mIntParam2( 0 ),
+ mIntParam3( 0 ),
+ mFloatParam1( 0.0f ),
+ mFloatParam2( 0.0f ),
+ mFloatParam3( 0.0f ),
+ mBoolReturn( false ),
+ mIntReturn( 0 ),
+ mFloatReturn( 0.0f ),
+ mHandled( false ),
+ mHandledCount( 0 )
+ {
+ }
+
+ void Reset()
+ {
+ mIntParam1 = 0;
+ mIntParam2 = 0;
+ mIntParam3 = 0;
+ mFloatParam1 = 0.0f;
+ mFloatParam2 = 0.0f;
+ mFloatParam3 = 0.0f;
+ mBoolReturn = false;
+ mIntReturn = 0;
+ mFloatReturn = 0.0f;
+ mHandled = false;
+ }
+
+ void VoidSlotVoid()
+ {
+ mHandled = true;
+ ++mHandledCount;
+ }
+
+ void AlternativeVoidSlotVoid()
+ {
+ mHandled = true;
+ ++mHandledCount;
+ }
+
+ void VoidSlotIntRef( int& p1 )
+ {
+ mIntParam1 = p1;
+ mHandled = true;
+ ++mHandledCount;
+ }
+
+ void VoidSlotIntValue( int p1 )
+ {
+ mIntParam1 = p1;
+ mHandled = true;
+ ++mHandledCount;
+ }
+
+ void VoidDuplicateSlotIntValue( int p1 )
+ {
+ mIntParam2 = p1;
+ mHandled = true;
+ ++mHandledCount;
+ }
+
+ void VoidSlotIntValueIntValue( int p1, int p2 )
+ {
+ mIntParam1 = p1;
+ mIntParam2 = p2;
+ mHandled = true;
+ ++mHandledCount;
+ }
+
+ bool BoolSlotFloatValue( float p1 )
+ {
+ mFloatParam1 = p1;
+ mHandled = true;
+ ++mHandledCount;
+ return mBoolReturn;
+ }
+
+ bool BoolSlotFloatValueIntValue( float p1, int p2 )
+ {
+ mFloatParam1 = p1;
+ mIntParam2 = p2;
+ mHandled = true;
+ ++mHandledCount;
+ return mBoolReturn;
+ }
+
+ int IntSlotFloatValueIntValue( float p1, int p2 )
+ {
+ mFloatParam1 = p1;
+ mIntParam2 = p2;
+ mHandled = true;
+ ++mHandledCount;
+ return mIntReturn;
+ }
+
+ float FloatSlotVoid()
+ {
+ mHandled = true;
+ ++mHandledCount;
+ return mFloatReturn;
+ }
+
+ float FloatSlotFloatValueFloatValue( float p1, float p2 )
+ {
+ mFloatParam1 = p1;
+ mFloatParam2 = p2;
+ mHandled = true;
+ ++mHandledCount;
+ return mFloatReturn;
+ }
+
+ void VoidSlotFloatValue3( float p1, float p2, float p3 )
+ {
+ mFloatParam1 = p1;
+ mFloatParam2 = p2;
+ mFloatParam3 = p3;
+ mHandled = true;
+ ++mHandledCount;
+ }
+
+ float FloatSlotFloatValue3( float p1, float p2, float p3 )
+ {
+ mFloatParam1 = p1;
+ mFloatParam2 = p2;
+ mFloatParam3 = p3;
+ mHandled = true;
+ ++mHandledCount;
+ return mFloatReturn;
+ }
+
+ SlotDelegate<TestSlotDelegateHandler> mSlotDelegate;
+
+ int mIntParam1, mIntParam2, mIntParam3;
+ float mFloatParam1, mFloatParam2, mFloatParam3;
+ bool mBoolReturn;
+ int mIntReturn;
+ float mFloatReturn;
+ bool mHandled;
+ int mHandledCount;
+};
+
+/**
+ * Test that reimplmenting ConnectionTrackerInterface actually works.
+ * This basic connection tracker only allows one callback to be connected.
+ */
+class TestBasicConnectionTrackerInterface : public ConnectionTrackerInterface
+{
+public:
+
+ TestBasicConnectionTrackerInterface()
+ : mCallbackHandled( false ),
+ mCallback( NULL ),
+ mSlotObserver( NULL )
+ {
+ }
+
+ ~TestBasicConnectionTrackerInterface()
+ {
+ if( mSlotObserver && mCallback )
+ {
+ // Notify signal since the slot has been destroyed
+ mSlotObserver->SlotDisconnected( mCallback );
+ // mCallback and mSlotObserver are not owned
+ }
+ }
+
+ /**
+ * An example slot
+ */
+ void VoidSlotVoid()
+ {
+ mCallbackHandled = true;
+ }
+
+ /**
+ * @copydoc ConnectionTrackerInterface::GetConnectionCount
+ */
+ virtual std::size_t GetConnectionCount() const
+ {
+ if( mCallback )
+ {
+ return 1u;
+ }
+
+ return 0u;
+ }
+
+ /**
+ * @copydoc ConnectionTrackerInterface::SignalConnected
+ */
+ virtual void SignalConnected( SlotObserver* slotObserver, CallbackBase* callback )
+ {
+ DALI_ASSERT_ALWAYS( NULL == mCallback && "Only one connection supported!" );
+
+ mCallback = callback;
+ mSlotObserver = slotObserver;
+ }
+
+ /**
+ * @copydoc ConnectionTrackerInterface::SignalDisconnected
+ */
+ virtual void SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback )
+ {
+ if( mSlotObserver == slotObserver )
+ {
+ mSlotObserver = NULL;
+ mCallback = NULL;
+ // mCallback and mSlotObserver are not owned
+ }
+ }
+
+private:
+
+ TestBasicConnectionTrackerInterface( const TestBasicConnectionTrackerInterface& ); ///< undefined copy constructor
+ TestBasicConnectionTrackerInterface& operator=( const TestBasicConnectionTrackerInterface& ); ///< undefined assignment operator
+
+public:
+
+ bool mCallbackHandled;
+
+private:
+
+ CallbackBase* mCallback; ///< callback, has ownership
+ SlotObserver* mSlotObserver; ///< a pointer to the slot observer (not owned)
+};
+
+
+
+
+/**
+ * test functor, we store a reference to a bool which is outside of the functor
+ * so when the functor is copied, the copy can reference the original data
+ */
+struct TestFunctor
+{
+ TestFunctor( bool& functorCalled):
+ mFunctorCalled( functorCalled )
+ {
+ };
+
+ void operator()()
+ {
+ mFunctorCalled = true;
+ }
+
+ bool& mFunctorCalled;
+};
+
+struct VoidFunctorVoid
+{
+ VoidFunctorVoid( bool& functorCalled):
+ mFunctorCalled( functorCalled )
+ {
+
+ }
+
+ void operator()()
+ {
+ mFunctorCalled = true;
+ }
+
+ bool& mFunctorCalled;
+};
+
+#endif // #define SIGNAL_HELPER
// INTERNAL INCLUDES
#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include "signal-helper.h"
using namespace Dali;
namespace {
-class TestButton
-{
-public:
-
- TestButton( unsigned int id )
- : mId(id)
- {
- }
-
- void Press()
- {
- mPanelDown.Emit( *this );
- }
-
- void Release()
- {
- mPanelUp.Emit( *this );
- }
-
- typedef Signal< void (TestButton&) > PanelDownSignal;
- typedef Signal< void (TestButton&) > PanelUpSignal;
-
- PanelDownSignal& DownSignal()
- {
- return mPanelDown;
- }
-
- PanelUpSignal& SignalUp()
- {
- return mPanelUp;
- }
-
- int GetId()
- {
- return mId;
- }
-
-private:
- int mId;
- PanelDownSignal mPanelDown;
- PanelUpSignal mPanelUp;
-};
+bool wasStaticVoidCallbackVoidCalled = false;
+bool wasStaticFloatCallbackVoidCalled = false;
+bool wasStaticVoidCallbackIntValueCalled = false;
+int staticIntValue = 0;
+bool wasStaticFloatCallbackFloatValueFloatValueCalled = false;
+float staticFloatValue1 = 0.0f;
+float staticFloatValue2 = 0.0f;
-class TestApp : public ConnectionTracker
+void StaticVoidCallbackVoid()
{
-public:
-
- TestApp()
- : mButtonPressed( false ),
- mVoidFunctionCalled( false )
- {
- }
-
- void OnButtonPress( TestButton& button )
- {
- mButtonPressed = true;
- mButtonId = button.GetId();
- }
-
- void OnButtonRelease( TestButton& button )
- {
- mButtonPressed = false;
- mButtonId = button.GetId();
- }
-
- int GetButtonPressedId()
- {
- return mButtonId;
- }
-
- bool BoolReturnTestFalse()
- {
- return false;
- }
-
- bool BoolReturnTestTrue()
- {
- return true;
- }
-
- void VoidFunction()
- {
- mVoidFunctionCalled = true;
- }
-
- bool mButtonPressed;
- bool mVoidFunctionCalled;
- int mButtonId;
-};
+ wasStaticVoidCallbackVoidCalled = true;
+}
-class TestSignals
+void AlternativeVoidCallbackVoid()
{
-public:
-
- // Void return, no parameters
- typedef Signal<void ()> VoidRetNoParamSignal;
-
- // Void return, 1 value parameter
- typedef Signal<void (int)> VoidRet1ValueParamSignal;
-
- // Void return, 1 reference parameter
- typedef Signal< void (int&)> VoidRet1RefParamSignal;
-
- // Void return, 2 value parameters
- typedef Signal<void (int, int)> VoidRet2ValueParamSignal;
-
- // bool return, 1 value parameter
- typedef Signal< bool (float)> BoolRet1ValueParamSignal;
-
- // bool return, 2 value parameter
- typedef Signal<bool (float, int) > BoolRet2ValueParamSignal;
-
- // int return, 2 value parameter
- typedef Signal<int (float, int)> IntRet2ValueParamSignal;
-
- // float return, 0 parameters
- typedef Signal< float () > FloatRet0ParamSignal;
-
- // float return, 2 value parameters
- typedef Signal<float (float, float) > FloatRet2ValueParamSignal;
-
- // void return, 3 value parameters
- typedef Signal<void (float, float, float) > VoidSignalTypeFloatValue3;
-
- // float return, 3 value parameters
- typedef Signal<float (float, float, float) > FloatSignalTypeFloatValue3;
-
- VoidRetNoParamSignal& SignalVoidNone() { return mSignalVoid0; }
- VoidRet1RefParamSignal& SignalVoid1Ref() { return mSignalVoid1R; }
- VoidRet1ValueParamSignal& SignalVoid1Value() { return mSignalVoid1V; }
- VoidRet2ValueParamSignal& SignalVoid2Value() { return mSignalVoid2V; }
-
- BoolRet1ValueParamSignal& SignalBool1Value() { return mSignalBool1V; }
- BoolRet2ValueParamSignal& SignalBool2Value() { return mSignalBool2V; }
- IntRet2ValueParamSignal& SignalInt2Value() { return mSignalInt2V; }
- FloatRet0ParamSignal& SignalFloat0() { return mSignalFloat0; }
- FloatRet2ValueParamSignal& SignalFloat2Value() { return mSignalFloat2V; }
-
- VoidSignalTypeFloatValue3& VoidSignalFloatValue3() { return mVoidSignalFloatValue3; }
- FloatSignalTypeFloatValue3& FloatSignalFloatValue3() { return mFloatSignalFloatValue3; }
-
- TestSignals()
- {
- }
-
- void CheckNoConnections()
- {
- DALI_TEST_EQUALS( mSignalVoid0.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mSignalVoid1R.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mSignalVoid1V.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mSignalVoid2V.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mSignalBool1V.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mSignalBool2V.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mSignalInt2V.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mSignalFloat0.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mSignalFloat2V.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mVoidSignalFloatValue3.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mFloatSignalFloatValue3.GetConnectionCount(), 0u, TEST_LOCATION );
- }
-
- void EmitVoidSignalVoid()
- {
- mSignalVoid0.Emit();
- }
-
- void EmitVoidSignalIntRef(int& ref)
- {
- mSignalVoid1R.Emit(ref);
- }
-
- void EmitVoidSignalIntValue(int p1)
- {
- mSignalVoid1V.Emit(p1);
- }
-
- void EmitVoidSignalIntValueIntValue(int p1, int p2)
- {
- mSignalVoid2V.Emit(p1,p2);
- }
-
- bool EmitBoolSignalFloatValue(float p1)
- {
- return mSignalBool1V.Emit(p1);
- }
-
- bool EmitBoolSignalFloatValueIntValue(float p1, int p2)
- {
- return mSignalBool2V.Emit(p1, p2);
- }
-
- int EmitIntSignalFloatValueIntValue(float p1, int p2)
- {
- return mSignalInt2V.Emit(p1, p2);
- }
+}
- float EmitFloat2VSignal(float p1, float p2)
- {
- return mSignalFloat2V.Emit(p1, p2);
- }
+float StaticFloatCallbackVoid()
+{
+ wasStaticFloatCallbackVoidCalled = true;
+ return 7.0f;
+}
- float EmitFloat0Signal()
- {
- return mSignalFloat0.Emit();
- }
+void StaticVoidCallbackIntValue( int value )
+{
+ wasStaticVoidCallbackIntValueCalled = true;
+ staticIntValue = value;
+}
- void EmitVoidSignalFloatValue3(float p1, float p2, float p3)
- {
- mVoidSignalFloatValue3.Emit(p1, p2, p3);
- }
+float StaticFloatCallbackFloatValueFloatValue( float value1, float value2 )
+{
+ wasStaticFloatCallbackFloatValueFloatValueCalled = true;
+ staticFloatValue1 = value1;
+ staticFloatValue2 = value2;
+ return value1 + value2;
+}
- float EmitFloatSignalFloatValue3(float p1, float p2, float p3)
- {
- return mFloatSignalFloatValue3.Emit(p1, p2, p3);
- }
+} // anon namespace
-private:
- VoidRetNoParamSignal mSignalVoid0;
- VoidRet1RefParamSignal mSignalVoid1R;
- VoidRet1ValueParamSignal mSignalVoid1V;
- VoidRet2ValueParamSignal mSignalVoid2V;
- BoolRet1ValueParamSignal mSignalBool1V;
- BoolRet2ValueParamSignal mSignalBool2V;
- IntRet2ValueParamSignal mSignalInt2V;
- FloatRet0ParamSignal mSignalFloat0;
- FloatRet2ValueParamSignal mSignalFloat2V;
- VoidSignalTypeFloatValue3 mVoidSignalFloatValue3;
- FloatSignalTypeFloatValue3 mFloatSignalFloatValue3;
-};
-/**
- * A helper class with various slots
+/*******************************************
+ *
+ * Start of Utc test cases.
+ * Test cases performed in order of API listed in dali-signal.h
+ * UtcDaliSignal + FunctionName + P=positive test, N = Negative test
+ *
*/
-class TestSlotHandler : public ConnectionTracker
-{
-public:
-
- TestSlotHandler()
- : mIntParam1( 0 ),
- mIntParam2( 0 ),
- mIntParam3( 0 ),
- mFloatParam1( 0.0f ),
- mFloatParam2( 0.0f ),
- mFloatParam3( 0.0f ),
- mBoolReturn( false ),
- mIntReturn( 0 ),
- mFloatReturn( 0.0f ),
- mHandled( false ),
- mHandledCount( 0 )
- {
- }
-
- void Reset()
- {
- mIntParam1 = 0;
- mIntParam2 = 0;
- mIntParam3 = 0;
- mFloatParam1 = 0.0f;
- mFloatParam2 = 0.0f;
- mFloatParam3 = 0.0f;
- mBoolReturn = false;
- mIntReturn = 0;
- mFloatReturn = 0.0f;
- mHandled = false;
- }
- void VoidSlotVoid()
- {
- mHandled = true;
- ++mHandledCount;
- }
+int UtcDaliSignalEmptyP(void)
+{
+ TestApplication app; // Create core for debug logging
- void VoidSlotIntRef( int& p1 )
- {
- mIntParam1 = p1;
- mHandled = true;
- ++mHandledCount;
- }
+ // Test that Empty() is true, when no slots connected to the signal
- void VoidSlotIntValue( int p1 )
{
- mIntParam1 = p1;
- mHandled = true;
- ++mHandledCount;
+ TestSignals::VoidRetNoParamSignal signal;
+ DALI_TEST_CHECK( signal.Empty() );
}
- void VoidDuplicateSlotIntValue( int p1 )
+ // Test that Empty() is true, when a slot has connected and disconnected
{
- mIntParam2 = p1;
- mHandled = true;
- ++mHandledCount;
+ TestSignals::VoidRetNoParamSignal signal;
+ TestSlotHandler handler;
+ signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
+ signal.Disconnect( &handler, &TestSlotHandler::VoidSlotVoid );
+ DALI_TEST_CHECK( signal.Empty() );
}
- void VoidSlotIntValueIntValue( int p1, int p2 )
- {
- mIntParam1 = p1;
- mIntParam2 = p2;
- mHandled = true;
- ++mHandledCount;
- }
+ END_TEST;
+}
- bool BoolSlotFloatValue( float p1 )
- {
- mFloatParam1 = p1;
- mHandled = true;
- ++mHandledCount;
- return mBoolReturn;
- }
+int UtcDaliSignalEmptyN(void)
+{
+ TestApplication app; // Create core for debug logging
- bool BoolSlotFloatValueIntValue( float p1, int p2 )
- {
- mFloatParam1 = p1;
- mIntParam2 = p2;
- mHandled = true;
- ++mHandledCount;
- return mBoolReturn;
- }
+ // Test that Empty() is false after signal connection
+ TestSignals::VoidRetNoParamSignal signal;
+ TestSlotHandler handler;
+ signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
+ DALI_TEST_CHECK( ! signal.Empty() );
- int IntSlotFloatValueIntValue( float p1, int p2 )
- {
- mFloatParam1 = p1;
- mIntParam2 = p2;
- mHandled = true;
- ++mHandledCount;
- return mIntReturn;
- }
+ END_TEST;
+}
- float FloatSlotVoid()
- {
- mHandled = true;
- ++mHandledCount;
- return mFloatReturn;
- }
+int UtcDaliSignalGetConnectionCountP(void)
+{
+ TestApplication app; // Create core for debug logging
- float FloatSlotFloatValueFloatValue( float p1, float p2 )
- {
- mFloatParam1 = p1;
- mFloatParam2 = p2;
- mHandled = true;
- ++mHandledCount;
- return mFloatReturn;
- }
+ TestSignals::VoidRetNoParamSignal signal;
+ TestSlotHandler handler;
+ signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
+ DALI_TEST_CHECK( signal.GetConnectionCount() == 1 );
- void VoidSlotFloatValue3( float p1, float p2, float p3 )
- {
- mFloatParam1 = p1;
- mFloatParam2 = p2;
- mFloatParam3 = p3;
- mHandled = true;
- ++mHandledCount;
- }
+ TestSlotHandler handler2;
+ signal.Connect( &handler2, &TestSlotHandler::VoidSlotVoid );
+ DALI_TEST_CHECK( signal.GetConnectionCount() == 2 );
- float FloatSlotFloatValue3( float p1, float p2, float p3 )
- {
- mFloatParam1 = p1;
- mFloatParam2 = p2;
- mFloatParam3 = p3;
- mHandled = true;
- ++mHandledCount;
- return mFloatReturn;
- }
+ END_TEST;
+}
- int mIntParam1, mIntParam2, mIntParam3;
- float mFloatParam1, mFloatParam2, mFloatParam3;
- bool mBoolReturn;
- int mIntReturn;
- float mFloatReturn;
- bool mHandled;
- int mHandledCount;
-};
+int UtcDaliSignalGetConnectionCountN(void)
+{
+ TestApplication app; // Create core for debug logging
+ TestSignals::VoidRetNoParamSignal signal;
+ DALI_TEST_CHECK( signal.GetConnectionCount() == 0 );
+ END_TEST;
+}
/**
- * A version of TestSlotHandler which disconnects during the callback
+ * there are 5 different connection functions
+ * we go through them here in order of definition in dali-signal.h
*/
-class TestSlotDisconnector : public ConnectionTracker
+int UtcDaliSignalConnectP01(void)
{
-public:
-
- TestSlotDisconnector()
- : mIntParam1( 0 ),
- mIntParam2( 0 ),
- mIntParam3( 0 ),
- mFloatParam1( 0.0f ),
- mFloatParam2( 0.0f ),
- mBoolReturn( false ),
- mIntReturn( 0 ),
- mFloatReturn( 0.0f ),
- mHandled( false )
- {
- }
-
- void Reset()
- {
- mIntParam1 = 0;
- mIntParam2 = 0;
- mIntParam3 = 0;
- mFloatParam1 = 0.0f;
- mFloatParam2 = 0.0f;
- mBoolReturn = false;
- mIntReturn = 0;
- mFloatReturn = 0.0f;
- mHandled = false;
- }
-
- void VoidConnectVoid( TestSignals::VoidRetNoParamSignal& signal )
- {
- mVoidSignalVoid = &signal;
- signal.Connect( this, &TestSlotDisconnector::VoidSlotVoid );
- }
-
- void VoidSlotVoid()
- {
- mVoidSignalVoid->Disconnect( this, &TestSlotDisconnector::VoidSlotVoid );
- mHandled = true;
- }
-
- void VoidConnectIntRef( TestSignals::VoidRet1RefParamSignal& signal )
- {
- mVoidSignalIntRef = &signal;
- signal.Connect( this, &TestSlotDisconnector::VoidSlotIntRef );
- }
+ TestApplication app; // Create core for debug logging
- void VoidSlotIntRef( int& p1 )
- {
- mVoidSignalIntRef->Disconnect( this, &TestSlotDisconnector::VoidSlotIntRef );
- mIntParam1 = p1;
- mHandled = true;
- }
+ // test static function: void Connect( void (*func)() )
+ TestSignals::VoidRetNoParamSignal signal;
+ signal.Connect( StaticVoidCallbackVoid );
+ DALI_TEST_CHECK( ! signal.Empty() );
- void VoidSlotIntValue( int p1 )
- {
- mIntParam1 = p1;
- mHandled = true;
- }
- void VoidSlotIntValueIntValue( int p1, int p2 )
- {
- mIntParam1 = p1;
- mIntParam2 = p2;
- mHandled = true;
- }
+ END_TEST;
+}
- bool BoolSlotFloatValue( float p1 )
- {
- mFloatParam1 = p1;
- mHandled = true;
- return mBoolReturn;
- }
+int UtcDaliSignalConnectN01(void)
+{
+ // difficult to perform a negative test on Connect as no checks are performed
+ // when creating a callback for a null function ( during Connect).
+ // so we test an assert on Emit
+ TestApplication app; // Create core for debug logging
- bool BoolSlotFloatValueIntValue( float p1, int p2 )
+ TestSignals::VoidRetNoParamSignal signal;
+ signal.Connect( NULL );
+ try
{
- mFloatParam1 = p1;
- mIntParam2 = p2;
- mHandled = true;
- return mBoolReturn;
+ signal.Emit();
}
-
- int IntSlotFloatValueIntValue( float p1, int p2 )
+ catch (Dali::DaliException& e)
{
- mFloatParam1 = p1;
- mIntParam2 = p2;
- mHandled = true;
- return mIntReturn;
- }
-
- float FloatSlotVoid()
- {
- mHandled = true;
- return mFloatReturn;
+ // Tests that a negative test of an assertion succeeds
+ DALI_TEST_PRINT_ASSERT( e );
+ tet_result(TET_PASS);
}
+ END_TEST;
+}
- float FloatSlotFloatValueFloatValue( float p1, float p2 )
- {
- mFloatParam1 = p1;
- mFloatParam2 = p2;
- mHandled = true;
- return mFloatReturn;
- }
- TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
- TestSignals::VoidRet1RefParamSignal* mVoidSignalIntRef;
+int UtcDaliSignalConnectP02(void)
+{
+ TestApplication app; // Create core for debug logging
- int mIntParam1, mIntParam2, mIntParam3;
- float mFloatParam1, mFloatParam2;
- bool mBoolReturn;
- int mIntReturn;
- float mFloatReturn;
- bool mHandled;
-};
+ // test member function: Connect( X* obj, void (X::*func)() ))
+ TestSignals::VoidRetNoParamSignal signal;
+ TestSlotHandler handler;
+ signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
+ DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Emit();
+ DALI_TEST_CHECK( handler.mHandled == true );
+ END_TEST;
+}
-/**
- * A more complicated version of TestSlotDisconnector, which disconnects some but not all callbacks
- */
-class TestSlotMultiDisconnector : public ConnectionTracker
+int UtcDaliSignalConnectN02(void)
{
-public:
-
- static const int NUM_SLOTS = 10;
+ TestApplication app; // Create core for debug logging
- TestSlotMultiDisconnector()
- : mVoidSignalVoid( NULL )
+ TestSignals::VoidRetNoParamSignal signal;
+ try
{
- Reset();
+ // test member function: Connect( X* obj, void (X::*func)() )) with NULL object
+ signal.Connect( static_cast<TestSlotHandler*>(NULL), &TestSlotHandler::VoidSlotVoid );
}
-
- void Reset()
+ catch (Dali::DaliException& e)
{
- for( int i=0; i<NUM_SLOTS; ++i )
- {
- mSlotHandled[i] = false;
- }
+ // Tests that a negative test of an assertion succeeds
+ DALI_TEST_PRINT_ASSERT( e );
+ tet_result(TET_PASS);
}
+ END_TEST;
+}
- void ConnectAll( TestSignals::VoidRetNoParamSignal& signal )
- {
- mVoidSignalVoid = &signal;
- signal.Connect( this, &TestSlotMultiDisconnector::Slot0 );
- signal.Connect( this, &TestSlotMultiDisconnector::Slot1 );
- signal.Connect( this, &TestSlotMultiDisconnector::Slot2 );
- signal.Connect( this, &TestSlotMultiDisconnector::Slot3 );
- signal.Connect( this, &TestSlotMultiDisconnector::Slot4 );
- signal.Connect( this, &TestSlotMultiDisconnector::Slot5 );
- signal.Connect( this, &TestSlotMultiDisconnector::Slot6 );
- signal.Connect( this, &TestSlotMultiDisconnector::Slot7 );
- signal.Connect( this, &TestSlotMultiDisconnector::Slot8 );
- signal.Connect( this, &TestSlotMultiDisconnector::Slot9 );
- }
- void Slot0()
- {
- mSlotHandled[0] = true;
- }
+int UtcDaliSignalConnectP03(void)
+{
+ TestApplication app; // Create core for debug logging
- void Slot1()
- {
- mSlotHandled[1] = true;
- }
+ // test slot delegate: Connect( SlotDelegate<X>& delegate, void (X::*func)() )
+ TestSignals::VoidRetNoParamSignal signal;
+ TestSlotDelegateHandler handler;
+ signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
+ DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Emit();
+ DALI_TEST_CHECK( handler.mHandled == true );
- void Slot2()
- {
- mSlotHandled[2] = true;
- }
+ END_TEST;
+}
- void Slot3()
- {
- mSlotHandled[3] = true;
+int UtcDaliSignalConnectN03(void)
+{
+ TestApplication app; // Create core for debug logging
+ // the delegate is passed by reference, so you can't pass null.
+ tet_result( TET_PASS );
+ END_TEST;
+}
- // Disconnect the odd numbered lots, because we can
- mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot1 );
- mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot3 );
- mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot5 );
- mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot7 );
- mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot9 );
- }
+int UtcDaliSignalConnectP04(void)
+{
+ TestApplication app; // Create core for debug logging
- void Slot4()
- {
- mSlotHandled[4] = true;
- }
+ // test function object: Connect( ConnectionTrackerInterface* connectionTracker, const X& func )
+ TestSlotHandler handler;
+ TestSignals::VoidRetNoParamSignal signal;
+ bool functorCalled(false);
+ TestFunctor functor( functorCalled );
+ signal.Connect( &handler, functor );
+ DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Emit();
+ DALI_TEST_CHECK( functorCalled == true );
- void Slot5()
- {
- mSlotHandled[5] = true;
- }
+ END_TEST;
+}
- void Slot6()
+int UtcDaliSignalConnectN04(void)
+{
+ // for negative test we try to connect a null connection tracker to the signal
+ TestSignals::VoidRetNoParamSignal signal;
+ TestSlotHandler *nullHandler( NULL );
+ try
{
- mSlotHandled[6] = true;
+ signal.Connect( nullHandler , &TestSlotHandler::VoidSlotVoid );
}
-
- void Slot7()
+ catch (Dali::DaliException& e)
{
- mSlotHandled[7] = true;
+ // Tests that a negative test of an assertion succeeds
+ DALI_TEST_PRINT_ASSERT( e );
+ tet_result( TET_PASS );
}
- void Slot8()
- {
- mSlotHandled[8] = true;
- }
+ END_TEST;
- void Slot9()
- {
- mSlotHandled[9] = true;
- }
+}
- TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
+int UtcDaliSignalConnectP05(void)
+{
+ TestApplication app; // Create core for debug logging
- bool mSlotHandled[NUM_SLOTS];
-};
+ // test function object using FunctorDelegate.
+ // :Connect( ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate )
+ TestSlotHandler handler;
+ TestSignals::VoidRetNoParamSignal signal;
+ bool functorDelegateCalled(false);
+ signal.Connect( &handler, FunctorDelegate::New( VoidFunctorVoid(functorDelegateCalled) ));
+ DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Emit();
+ DALI_TEST_CHECK( functorDelegateCalled == true );
+ END_TEST;
+}
-/**
- * A version of TestSlotHandler which disconnects during the callback
- */
-class TestEmitDuringCallback : public ConnectionTracker
+int UtcDaliSignalConnectN05(void)
{
-public:
-
- TestEmitDuringCallback()
- : mVoidSignalVoid( NULL ),
- mHandled( false )
- {
- }
+ TestApplication app; // Create core for debug logging
- void VoidConnectVoid( TestSignals::VoidRetNoParamSignal& signal )
+ // for negative test we try to connect a null connection tracker to the signal
+ // :Connect( ConnectionTrackerInterface == NULL, FunctorDelegate* delegate )
+ TestSlotHandler *nullHandler( NULL );
+ TestSignals::VoidRetNoParamSignal signal;
+ bool functorDelegateCalled(false);
+ try
{
- mVoidSignalVoid = &signal;
- signal.Connect( this, &TestEmitDuringCallback::VoidSlotVoid );
+ signal.Connect( nullHandler, FunctorDelegate::New( VoidFunctorVoid(functorDelegateCalled) ));
}
-
- void VoidSlotVoid()
+ catch (Dali::DaliException& e)
{
- // Emitting during Emit is very bad!
- mVoidSignalVoid->Emit();
-
- mHandled = true;
+ DALI_TEST_PRINT_ASSERT( e );
+ tet_result( TET_PASS );
}
-
- TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
-
- bool mHandled;
-};
+ END_TEST;
+}
/**
- * A version of TestSlotHandler which uses SlotDelegate
+ * there 3 different disconnect functions
+ * we go through them here in order of definition in dali-signal.h
*/
-class TestSlotDelegateHandler // This does not inherit from ConnectionTrackerInterface!
+int UtcDaliSignalDisconnectP01(void)
{
-public:
-
- TestSlotDelegateHandler()
- : mSlotDelegate( this ),
- mIntParam1( 0 ),
- mIntParam2( 0 ),
- mIntParam3( 0 ),
- mFloatParam1( 0.0f ),
- mFloatParam2( 0.0f ),
- mFloatParam3( 0.0f ),
- mBoolReturn( false ),
- mIntReturn( 0 ),
- mFloatReturn( 0.0f ),
- mHandled( false ),
- mHandledCount( 0 )
- {
- }
-
- void Reset()
- {
- mIntParam1 = 0;
- mIntParam2 = 0;
- mIntParam3 = 0;
- mFloatParam1 = 0.0f;
- mFloatParam2 = 0.0f;
- mFloatParam3 = 0.0f;
- mBoolReturn = false;
- mIntReturn = 0;
- mFloatReturn = 0.0f;
- mHandled = false;
- }
-
- void VoidSlotVoid()
- {
- mHandled = true;
- ++mHandledCount;
- }
-
- void VoidSlotIntRef( int& p1 )
- {
- mIntParam1 = p1;
- mHandled = true;
- ++mHandledCount;
- }
-
- void VoidSlotIntValue( int p1 )
- {
- mIntParam1 = p1;
- mHandled = true;
- ++mHandledCount;
- }
-
- void VoidDuplicateSlotIntValue( int p1 )
- {
- mIntParam2 = p1;
- mHandled = true;
- ++mHandledCount;
- }
-
- void VoidSlotIntValueIntValue( int p1, int p2 )
- {
- mIntParam1 = p1;
- mIntParam2 = p2;
- mHandled = true;
- ++mHandledCount;
- }
-
- bool BoolSlotFloatValue( float p1 )
- {
- mFloatParam1 = p1;
- mHandled = true;
- ++mHandledCount;
- return mBoolReturn;
- }
+ TestApplication app; // Create core for debug logging
- bool BoolSlotFloatValueIntValue( float p1, int p2 )
- {
- mFloatParam1 = p1;
- mIntParam2 = p2;
- mHandled = true;
- ++mHandledCount;
- return mBoolReturn;
- }
+ // test static function: Disconnect( void (*func)( Arg0 arg0 ) )
- int IntSlotFloatValueIntValue( float p1, int p2 )
- {
- mFloatParam1 = p1;
- mIntParam2 = p2;
- mHandled = true;
- ++mHandledCount;
- return mIntReturn;
- }
+ TestSignals::VoidRetNoParamSignal signal;
+ signal.Connect( StaticVoidCallbackVoid );
+ DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Disconnect( StaticVoidCallbackVoid );
+ DALI_TEST_CHECK( signal.Empty() );
- float FloatSlotVoid()
- {
- mHandled = true;
- ++mHandledCount;
- return mFloatReturn;
- }
+ END_TEST;
- float FloatSlotFloatValueFloatValue( float p1, float p2 )
- {
- mFloatParam1 = p1;
- mFloatParam2 = p2;
- mHandled = true;
- ++mHandledCount;
- return mFloatReturn;
- }
+ }
+int UtcDaliSignalDisconnectN01(void)
+{
+ TestApplication app; // Create core for debug logging
- void VoidSlotFloatValue3( float p1, float p2, float p3 )
- {
- mFloatParam1 = p1;
- mFloatParam2 = p2;
- mFloatParam3 = p3;
- mHandled = true;
- ++mHandledCount;
- }
+ // 1. Disconnect using the function
+ TestSignals::VoidRetNoParamSignal signal;
+ signal.Connect( StaticVoidCallbackVoid );
+ DALI_TEST_CHECK( ! signal.Empty() );
- float FloatSlotFloatValue3( float p1, float p2, float p3 )
- {
- mFloatParam1 = p1;
- mFloatParam2 = p2;
- mFloatParam3 = p3;
- mHandled = true;
- ++mHandledCount;
- return mFloatReturn;
- }
+ signal.Disconnect( AlternativeVoidCallbackVoid );
- SlotDelegate<TestSlotDelegateHandler> mSlotDelegate;
+ DALI_TEST_CHECK( ! signal.Empty() );
- int mIntParam1, mIntParam2, mIntParam3;
- float mFloatParam1, mFloatParam2, mFloatParam3;
- bool mBoolReturn;
- int mIntReturn;
- float mFloatReturn;
- bool mHandled;
- int mHandledCount;
-};
+ END_TEST;
+}
-/**
- * Test that reimplmenting ConnectionTrackerInterface actually works.
- * This basic connection tracker only allows one callback to be connected.
- */
-class TestBasicConnectionTrackerInterface : public ConnectionTrackerInterface
+int UtcDaliSignalDisconnectP02(void)
{
-public:
+ TestApplication app; // Create core for debug logging
- TestBasicConnectionTrackerInterface()
- : mCallbackHandled( false ),
- mCallback( NULL ),
- mSlotObserver( NULL )
- {
- }
+ // test member function: Disconnect( X* obj, void (X::*func)( Arg0 arg0 ) )
+ TestSignals::VoidRetNoParamSignal signal;
+ TestSlotHandler handler;
+ signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
+ DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Disconnect( &handler, &TestSlotHandler::VoidSlotVoid );
+ DALI_TEST_CHECK( signal.Empty() );
- ~TestBasicConnectionTrackerInterface()
- {
- if( mSlotObserver && mCallback )
- {
- // Notify signal since the slot has been destroyed
- mSlotObserver->SlotDisconnected( mCallback );
- // mCallback and mSlotObserver are not owned
- }
- }
+ END_TEST;
- /**
- * An example slot
- */
- void VoidSlotVoid()
- {
- mCallbackHandled = true;
- }
+}
+int UtcDaliSignalDisconnectN02(void)
+{
+ TestApplication app; // Create core for debug logging
- /**
- * @copydoc ConnectionTrackerInterface::GetConnectionCount
- */
- virtual std::size_t GetConnectionCount() const
- {
- if( mCallback )
- {
- return 1u;
- }
+ // 1. Disconnect using a null connection tracker
+ TestSignals::VoidRetNoParamSignal signal;
+ TestSlotHandler handler;
- return 0u;
- }
+ signal.Connect( &handler , &TestSlotHandler::VoidSlotVoid );
+ DALI_TEST_CHECK( !signal.Empty() );
- /**
- * @copydoc ConnectionTrackerInterface::SignalConnected
- */
- virtual void SignalConnected( SlotObserver* slotObserver, CallbackBase* callback )
+ try
{
- DALI_ASSERT_ALWAYS( NULL == mCallback && "Only one connection supported!" );
-
- mCallback = callback;
- mSlotObserver = slotObserver;
+ TestSlotHandler* nullHandler( NULL );
+ signal.Disconnect( nullHandler , &TestSlotHandler::VoidSlotVoid );
}
-
- /**
- * @copydoc ConnectionTrackerInterface::SignalDisconnected
- */
- virtual void SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback )
+ catch(Dali::DaliException& e)
{
- if( mSlotObserver == slotObserver )
- {
- mSlotObserver = NULL;
- mCallback = NULL;
- // mCallback and mSlotObserver are not owned
- }
+ // Tests that a negative test of an assertion succeeds
+ DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_CHECK( !signal.Empty() );
}
-
-private:
-
- TestBasicConnectionTrackerInterface( const TestBasicConnectionTrackerInterface& ); ///< undefined copy constructor
- TestBasicConnectionTrackerInterface& operator=( const TestBasicConnectionTrackerInterface& ); ///< undefined assignment operator
-
-public:
-
- bool mCallbackHandled;
-
-private:
-
- CallbackBase* mCallback; ///< callback, has ownership
- SlotObserver* mSlotObserver; ///< a pointer to the slot observer (not owned)
-};
-
-
-bool wasStaticVoidCallbackVoidCalled = false;
-bool wasStaticFloatCallbackVoidCalled = false;
-bool wasStaticVoidCallbackIntValueCalled = false;
-int staticIntValue = 0;
-bool wasStaticFloatCallbackFloatValueFloatValueCalled = false;
-float staticFloatValue1 = 0.0f;
-float staticFloatValue2 = 0.0f;
-
-static void StaticVoidCallbackVoid()
-{
- wasStaticVoidCallbackVoidCalled = true;
+ END_TEST;
}
-static float StaticFloatCallbackVoid()
+int UtcDaliSignalDisconnectP03(void)
{
- wasStaticFloatCallbackVoidCalled = true;
- return 7.0f;
-}
+ TestApplication app; // Create core for debug logging
-static void StaticVoidCallbackIntValue( int value )
-{
- wasStaticVoidCallbackIntValueCalled = true;
- staticIntValue = value;
-}
+ // test slot delegate: Disconnect( SlotDelegate<X>& delegate, void (X::*func)( Arg0 arg0 ) )
+ TestSignals::VoidRetNoParamSignal signal;
+ TestSlotDelegateHandler handler;
+ signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
+ DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Disconnect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
+ DALI_TEST_CHECK( signal.Empty() );
-static float StaticFloatCallbackFloatValueFloatValue( float value1, float value2 )
-{
- wasStaticFloatCallbackFloatValueFloatValueCalled = true;
- staticFloatValue1 = value1;
- staticFloatValue2 = value2;
- return value1 + value2;
+ END_TEST;
}
-} // anon namespace
-
-
-int UtcDaliSignalEmptyCheck(void)
+int UtcDaliSignalDisconnectN03(void)
{
- // Test that Empty() check works before & after signal connection
-
- {
- TestSignals::VoidRetNoParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
- }
-
- {
- TestSignals::VoidRet1ValueParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValue );
- DALI_TEST_CHECK( ! signal.Empty() );
- }
-
- {
- TestSignals::VoidRet1RefParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::VoidSlotIntRef );
- DALI_TEST_CHECK( ! signal.Empty() );
- }
-
- {
- TestSignals::VoidRet2ValueParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValueIntValue );
- DALI_TEST_CHECK( ! signal.Empty() );
- }
-
- {
- TestSignals::BoolRet1ValueParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValue );
- DALI_TEST_CHECK( ! signal.Empty() );
- }
+ TestApplication app; // Create core for debug logging
- {
- TestSignals::BoolRet2ValueParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValueIntValue );
- DALI_TEST_CHECK( ! signal.Empty() );
- }
+ // try to disconnect from the wrong signal
+ TestSignals::VoidRetNoParamSignal signal;
+ TestSlotDelegateHandler handler;
+ signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
- {
- TestSignals::IntRet2ValueParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::IntSlotFloatValueIntValue );
- DALI_TEST_CHECK( ! signal.Empty() );
- }
+ // use different signal
+ signal.Disconnect( handler.mSlotDelegate , &TestSlotDelegateHandler::AlternativeVoidSlotVoid );
- {
- TestSignals::FloatRet0ParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::FloatSlotVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
- }
+ DALI_TEST_CHECK( !signal.Empty() );
- {
- TestSignals::FloatRet2ValueParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
- TestSlotHandler handler;
- signal.Connect(&handler, &TestSlotHandler::FloatSlotFloatValueFloatValue);
- DALI_TEST_CHECK( ! signal.Empty() );
- }
END_TEST;
+
}
+/*******************************************
+ *
+ * End of Utc test cases for the individual API's of Signals
+ * The following testing Signals functionality as a whole
+ *
+ *
+ */
+
int UtcDaliSignalEmptyCheckSlotDestruction(void)
{
// Test that signal disconnect works when slot is destroyed (goes out of scope)
-
{
TestSignals::VoidRetNoParamSignal signal;
{
projects / platform / core / uifw / dali-core.git / commitdiff