// INTERNAL INCLUDES
#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include "signal-helper.h"
using namespace Dali;
+bool StaticFunctionHandlers::staticFunctionHandled;
+
void utc_dali_signal_templates_startup(void)
{
test_return_value = TET_UNDEF;
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 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
+float StaticFloatCallbackVoid()
{
-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 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;
-};
+ wasStaticFloatCallbackVoidCalled = true;
+ return 7.0f;
+}
-/**
- * A version of TestSlotHandler which disconnects during the callback
- */
-class TestSlotDisconnector : public ConnectionTracker
+void StaticVoidCallbackIntValue( int value )
{
-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;
-};
+ wasStaticVoidCallbackIntValueCalled = true;
+ staticIntValue = value;
+}
-/**
- * A more complicated version of TestSlotDisconnector, which disconnects some but not all callbacks
- */
-class TestSlotMultiDisconnector : public ConnectionTracker
+float StaticFloatCallbackFloatValueFloatValue( float value1, float value2 )
{
-public:
+ wasStaticFloatCallbackFloatValueFloatValueCalled = true;
+ staticFloatValue1 = value1;
+ staticFloatValue2 = value2;
+ return value1 + value2;
+}
- static const int NUM_SLOTS = 10;
+} // anon namespace
- 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 );
- }
+/*******************************************
+ *
+ * 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
+ *
+ */
- void Slot0()
- {
- mSlotHandled[0] = true;
- }
+int UtcDaliSignalEmptyP(void)
+{
+ TestApplication app; // Create core for debug logging
- void Slot1()
- {
- mSlotHandled[1] = true;
- }
+ // Test that Empty() is true, when no slots connected to the signal
- void Slot2()
{
- mSlotHandled[2] = true;
+ TestSignals::VoidRetNoParamSignal signal;
+ DALI_TEST_CHECK( signal.Empty() );
}
- void Slot3()
+ // Test that Empty() is true, when a slot has connected and disconnected
{
- 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 );
+ TestSignals::VoidRetNoParamSignal signal;
+ TestSlotHandler handler;
+ signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
+ signal.Disconnect( &handler, &TestSlotHandler::VoidSlotVoid );
+ DALI_TEST_CHECK( signal.Empty() );
}
- void Slot4()
- {
- mSlotHandled[4] = true;
- }
+ END_TEST;
+}
- void Slot5()
- {
- mSlotHandled[5] = true;
- }
+int UtcDaliSignalEmptyN(void)
+{
+ TestApplication app; // Create core for debug logging
- void Slot6()
- {
- mSlotHandled[6] = true;
- }
+ // Test that Empty() is false after signal connection
+ TestSignals::VoidRetNoParamSignal signal;
+ TestSlotHandler handler;
+ signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
+ DALI_TEST_CHECK( ! signal.Empty() );
- void Slot7()
- {
- mSlotHandled[7] = true;
- }
+ END_TEST;
+}
- void Slot8()
- {
- mSlotHandled[8] = true;
- }
+int UtcDaliSignalGetConnectionCountP(void)
+{
+ TestApplication app; // Create core for debug logging
- void Slot9()
- {
- mSlotHandled[9] = true;
- }
+ TestSignals::VoidRetNoParamSignal signal;
+ TestSlotHandler handler;
+ signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
+ DALI_TEST_CHECK( signal.GetConnectionCount() == 1 );
- TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
+ TestSlotHandler handler2;
+ signal.Connect( &handler2, &TestSlotHandler::VoidSlotVoid );
+ DALI_TEST_CHECK( signal.GetConnectionCount() == 2 );
- bool mSlotHandled[NUM_SLOTS];
-};
+ END_TEST;
+}
+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 TestEmitDuringCallback : public ConnectionTracker
+int UtcDaliSignalConnectP01(void)
{
-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;
- }
+ TestApplication app; // Create core for debug logging
- TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
+ // test static function: void Connect( void (*func)() )
+ TestSignals::VoidRetNoParamSignal signal;
+ signal.Connect( StaticVoidCallbackVoid );
+ DALI_TEST_CHECK( ! signal.Empty() );
- bool mHandled;
-};
+ END_TEST;
+}
-/**
- * A version of TestSlotHandler which uses SlotDelegate
- */
-class TestSlotDelegateHandler // This does not inherit from ConnectionTrackerInterface!
+int UtcDaliSignalConnectN01(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;
- }
+ // 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
- void VoidSlotIntRef( int& p1 )
+ TestSignals::VoidRetNoParamSignal signal;
+ signal.Connect( NULL );
+ try
{
- mIntParam1 = p1;
- mHandled = true;
- ++mHandledCount;
+ signal.Emit();
}
-
- void VoidSlotIntValue( int p1 )
+ catch (Dali::DaliException& e)
{
- mIntParam1 = p1;
- mHandled = true;
- ++mHandledCount;
+ // Tests that a negative test of an assertion succeeds
+ DALI_TEST_PRINT_ASSERT( e );
+ tet_result(TET_PASS);
}
+ END_TEST;
+}
- void VoidDuplicateSlotIntValue( int p1 )
- {
- mIntParam2 = p1;
- mHandled = true;
- ++mHandledCount;
- }
- void VoidSlotIntValueIntValue( int p1, int p2 )
- {
- mIntParam1 = p1;
- mIntParam2 = p2;
- mHandled = true;
- ++mHandledCount;
- }
+int UtcDaliSignalConnectP02(void)
+{
+ TestApplication app; // Create core for debug logging
- bool BoolSlotFloatValue( float p1 )
- {
- mFloatParam1 = p1;
- mHandled = true;
- ++mHandledCount;
- return mBoolReturn;
- }
+ // 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;
+}
- bool BoolSlotFloatValueIntValue( float p1, int p2 )
- {
- mFloatParam1 = p1;
- mIntParam2 = p2;
- mHandled = true;
- ++mHandledCount;
- return mBoolReturn;
- }
+int UtcDaliSignalConnectN02(void)
+{
+ TestApplication app; // Create core for debug logging
- int IntSlotFloatValueIntValue( float p1, int p2 )
+ TestSignals::VoidRetNoParamSignal signal;
+ try
{
- mFloatParam1 = p1;
- mIntParam2 = p2;
- mHandled = true;
- ++mHandledCount;
- return mIntReturn;
+ // test member function: Connect( X* obj, void (X::*func)() )) with NULL object
+ signal.Connect( static_cast<TestSlotHandler*>(NULL), &TestSlotHandler::VoidSlotVoid );
}
-
- float FloatSlotVoid()
+ catch (Dali::DaliException& e)
{
- mHandled = true;
- ++mHandledCount;
- 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;
- ++mHandledCount;
- return mFloatReturn;
- }
- void VoidSlotFloatValue3( float p1, float p2, float p3 )
- {
- mFloatParam1 = p1;
- mFloatParam2 = p2;
- mFloatParam3 = p3;
- mHandled = true;
- ++mHandledCount;
- }
+int UtcDaliSignalConnectP03(void)
+{
+ TestApplication app; // Create core for debug logging
- float FloatSlotFloatValue3( float p1, float p2, float p3 )
- {
- mFloatParam1 = p1;
- mFloatParam2 = p2;
- mFloatParam3 = p3;
- mHandled = true;
- ++mHandledCount;
- return mFloatReturn;
- }
+ // 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 );
- SlotDelegate<TestSlotDelegateHandler> mSlotDelegate;
+ END_TEST;
+}
- int mIntParam1, mIntParam2, mIntParam3;
- float mFloatParam1, mFloatParam2, mFloatParam3;
- bool mBoolReturn;
- int mIntReturn;
- float mFloatReturn;
- bool mHandled;
- int mHandledCount;
-};
+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;
+}
-/**
- * Test that reimplmenting ConnectionTrackerInterface actually works.
- * This basic connection tracker only allows one callback to be connected.
- */
-class TestBasicConnectionTrackerInterface : public ConnectionTrackerInterface
+int UtcDaliSignalConnectP04(void)
{
-public:
+ TestApplication app; // Create core for debug logging
- TestBasicConnectionTrackerInterface()
- : mCallbackHandled( false ),
- mCallback( NULL ),
- mSlotObserver( NULL )
+ // 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 );
+
+ END_TEST;
+}
+
+int UtcDaliSignalConnectN04(void)
+{
+ // for negative test we try to connect a null connection tracker to the signal
+ TestSignals::VoidRetNoParamSignal signal;
+ TestSlotHandler *nullHandler( NULL );
+ try
{
+ signal.Connect( nullHandler , &TestSlotHandler::VoidSlotVoid );
}
-
- ~TestBasicConnectionTrackerInterface()
+ catch (Dali::DaliException& e)
{
- if( mSlotObserver && mCallback )
- {
- // Notify signal since the slot has been destroyed
- mSlotObserver->SlotDisconnected( mCallback );
- // mCallback and mSlotObserver are not owned
- }
+ // Tests that a negative test of an assertion succeeds
+ DALI_TEST_PRINT_ASSERT( e );
+ tet_result( TET_PASS );
}
- /**
- * An example slot
- */
- void VoidSlotVoid()
+ END_TEST;
+
+}
+
+int UtcDaliSignalConnectP05(void)
+{
+ TestApplication app; // Create core for debug logging
+
+ // test function object using FunctorDelegate.
+ // :Connect( ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate )
{
- mCallbackHandled = true;
+ 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 );
}
-
- /**
- * @copydoc ConnectionTrackerInterface::GetConnectionCount
- */
- virtual std::size_t GetConnectionCount() const
{
- if( mCallback )
- {
- return 1u;
- }
-
- return 0u;
+ TestSlotHandler handler;
+ TestSignals::VoidRet1ValueParamSignal signal;
+ bool functorDelegateCalled(false);
+ signal.Connect( &handler, FunctorDelegate::New( VoidFunctorVoid(functorDelegateCalled) ));
+ DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Emit(1);
}
+ END_TEST;
+}
- /**
- * @copydoc ConnectionTrackerInterface::SignalConnected
- */
- virtual void SignalConnected( SlotObserver* slotObserver, CallbackBase* callback )
- {
- DALI_ASSERT_ALWAYS( NULL == mCallback && "Only one connection supported!" );
+int UtcDaliSignalConnectN05(void)
+{
+ TestApplication app; // Create core for debug logging
- mCallback = callback;
- mSlotObserver = slotObserver;
+ // 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
+ {
+ signal.Connect( nullHandler, FunctorDelegate::New( VoidFunctorVoid(functorDelegateCalled) ));
}
-
- /**
- * @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
- }
+ DALI_TEST_PRINT_ASSERT( e );
+ tet_result( TET_PASS );
}
+ END_TEST;
+}
-private:
-
- TestBasicConnectionTrackerInterface( const TestBasicConnectionTrackerInterface& ); ///< undefined copy constructor
- TestBasicConnectionTrackerInterface& operator=( const TestBasicConnectionTrackerInterface& ); ///< undefined assignment operator
-public:
+/**
+ * there 3 different disconnect functions
+ * we go through them here in order of definition in dali-signal.h
+ */
+int UtcDaliSignalDisconnectP01(void)
+{
+ TestApplication app; // Create core for debug logging
- bool mCallbackHandled;
+ // test static function: Disconnect( void (*func)( Arg0 arg0 ) )
-private:
+ TestSignals::VoidRetNoParamSignal signal;
+ signal.Connect( StaticVoidCallbackVoid );
+ DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Disconnect( StaticVoidCallbackVoid );
+ DALI_TEST_CHECK( signal.Empty() );
- CallbackBase* mCallback; ///< callback, has ownership
- SlotObserver* mSlotObserver; ///< a pointer to the slot observer (not owned)
-};
+ END_TEST;
+ }
+int UtcDaliSignalDisconnectN01(void)
+{
+ TestApplication app; // Create core for debug logging
-bool wasStaticVoidCallbackVoidCalled = false;
-bool wasStaticFloatCallbackVoidCalled = false;
-bool wasStaticVoidCallbackIntValueCalled = false;
-int staticIntValue = 0;
-bool wasStaticFloatCallbackFloatValueFloatValueCalled = false;
-float staticFloatValue1 = 0.0f;
-float staticFloatValue2 = 0.0f;
+ // 1. Disconnect using the function
+ TestSignals::VoidRetNoParamSignal signal;
+ signal.Connect( StaticVoidCallbackVoid );
+ DALI_TEST_CHECK( ! signal.Empty() );
-static void StaticVoidCallbackVoid()
-{
- wasStaticVoidCallbackVoidCalled = true;
-}
+ signal.Disconnect( AlternativeVoidCallbackVoid );
-static float StaticFloatCallbackVoid()
-{
- wasStaticFloatCallbackVoidCalled = true;
- return 7.0f;
-}
+ DALI_TEST_CHECK( ! signal.Empty() );
-static void StaticVoidCallbackIntValue( int value )
-{
- wasStaticVoidCallbackIntValueCalled = true;
- staticIntValue = value;
+ END_TEST;
}
-static float StaticFloatCallbackFloatValueFloatValue( float value1, float value2 )
+int UtcDaliSignalDisconnectP02(void)
{
- wasStaticFloatCallbackFloatValueFloatValueCalled = true;
- staticFloatValue1 = value1;
- staticFloatValue2 = value2;
- return value1 + value2;
-}
+ TestApplication app; // Create core for debug logging
-} // anon namespace
+ // 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() );
+ END_TEST;
-int UtcDaliSignalEmptyCheck(void)
+}
+int UtcDaliSignalDisconnectN02(void)
{
- // Test that Empty() check works before & after signal connection
+ TestApplication app; // Create core for debug logging
- {
- TestSignals::VoidRetNoParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
- }
+ // 1. Disconnect using a null connection tracker
+ TestSignals::VoidRetNoParamSignal signal;
+ TestSlotHandler handler;
- {
- TestSignals::VoidRet1ValueParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValue );
- DALI_TEST_CHECK( ! signal.Empty() );
- }
+ signal.Connect( &handler , &TestSlotHandler::VoidSlotVoid );
+ DALI_TEST_CHECK( !signal.Empty() );
+ try
{
- TestSignals::VoidRet1RefParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::VoidSlotIntRef );
- DALI_TEST_CHECK( ! signal.Empty() );
+ TestSlotHandler* nullHandler( NULL );
+ signal.Disconnect( nullHandler , &TestSlotHandler::VoidSlotVoid );
}
-
+ catch(Dali::DaliException& e)
{
- TestSignals::VoidRet2ValueParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValueIntValue );
- DALI_TEST_CHECK( ! signal.Empty() );
+ // Tests that a negative test of an assertion succeeds
+ DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_CHECK( !signal.Empty() );
}
+ END_TEST;
+}
- {
- TestSignals::BoolRet1ValueParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValue );
- DALI_TEST_CHECK( ! signal.Empty() );
- }
+int UtcDaliSignalDisconnectP03(void)
+{
+ 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() );
- }
+ // 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() );
- {
- TestSignals::IntRet2ValueParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::IntSlotFloatValueIntValue );
- DALI_TEST_CHECK( ! signal.Empty() );
- }
+ END_TEST;
+}
- {
- TestSignals::FloatRet0ParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::FloatSlotVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
- }
+int UtcDaliSignalDisconnectN03(void)
+{
+ TestApplication app; // Create core for debug logging
+
+ // try to disconnect from the wrong signal
+ TestSignals::VoidRetNoParamSignal signal;
+ TestSlotDelegateHandler handler;
+ signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
+
+ // use different signal
+ signal.Disconnect( handler.mSlotDelegate , &TestSlotDelegateHandler::AlternativeVoidSlotVoid );
+
+ 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;
{
}
// Positive test case for a method
-int UtcDaliSignalConnectAndEmit(void)
+int UtcDaliSignalConnectAndEmit01P(void)
{
// Test basic signal emission for each slot type
TestSlotHandler handlers;
signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- signals.EmitVoidSignalIntValue(5);
+ signals.EmitVoidSignal1IntValue(5);
DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mIntParam1, 5, TEST_LOCATION );
}
TestSlotHandler handlers;
signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- signals.EmitVoidSignalIntValueIntValue(6, 7);
+ signals.EmitVoidSignal2IntValue(6, 7);
DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mIntParam1, 6, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mIntParam2, 7, TEST_LOCATION );
{
TestSlotHandler handlers;
- signals.FloatSignalFloatValue3().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValue3);
+ signals.SignalFloat3Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValue3);
DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
handlers.mFloatReturn = 27.0f;
- float returnValue = signals.EmitFloatSignalFloatValue3(5, 33.0f, 100.0f);
+ float returnValue = signals.EmitFloat3VSignal(5, 33.0f, 100.0f);
DALI_TEST_EQUALS( returnValue, 27.0f, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
END_TEST;
}
+int UtcDaliSignalConnectAndEmit02P(void)
+{
+ // testing connection of static functions
+ TestSignals signals;
+ StaticFunctionHandlers handlers;
+
+ // void ( void )
+ signals.SignalVoidNone().Connect( &StaticFunctionHandlers::VoidSlotVoid );
+ DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
+ signals.EmitVoidSignalVoid();
+ DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
+
+
+ // void ( p1 )
+ handlers.Reset();
+ signals.SignalVoid1Value().Connect( &StaticFunctionHandlers::VoidSlot1Param );
+ DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
+ signals.EmitVoidSignal1IntValue( 1 );
+ DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
+
+ // void ( p1, p2 )
+ handlers.Reset();
+ signals.SignalVoid2Value().Connect( &StaticFunctionHandlers::VoidSlot2Param );
+ DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
+ signals.EmitVoidSignal2IntValue( 1, 2 );
+ DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
+
+
+ // void ( p1, p2, p3 )
+ handlers.Reset();
+ signals.SignalVoid3Value().Connect( &StaticFunctionHandlers::VoidSlot3Param );
+ DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
+ signals.EmitVoidSignal3IntValue( 1, 2, 3 );
+ DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
+
+ // ret ( )
+ handlers.Reset();
+ signals.SignalFloat0().Connect( &StaticFunctionHandlers::RetSlot0Param );
+ DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
+ signals.EmitFloat0Signal();
+ DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
+
+ // ret ( p1 )
+ handlers.Reset();
+ signals.SignalFloat1Value().Connect( &StaticFunctionHandlers::RetSlot1Param );
+ DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
+ signals.EmitFloat1VSignal( 1.f );
+ DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
+
+ // ret ( p1, p2 )
+ handlers.Reset();
+ signals.SignalFloat2Value().Connect( &StaticFunctionHandlers::RetSlot2Param );
+ DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
+ signals.EmitFloat2VSignal( 1.f, 2.f );
+ DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
+
+
+ // ret ( p1, p2, p3 )
+ handlers.Reset();
+ signals.SignalFloat3Value().Connect( &StaticFunctionHandlers::RetSlot3Param );
+ DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
+ signals.EmitFloat3VSignal( 1.f, 2.f, 3.f );
+ DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
+
+ END_TEST;
+
+}
+
+
int UtcDaliSignalDisconnect(void)
{
// Test that callbacks don't occur if a signal is disconnected before emission
signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
- signals.EmitVoidSignalIntValue(5);
+ signals.EmitVoidSignal1IntValue(5);
DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
}
signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
- signals.EmitVoidSignalIntValueIntValue(5, 10);
+ signals.EmitVoidSignal2IntValue(5, 10);
DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
{
TestSlotHandler handlers;
signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
- signals.EmitVoidSignalIntValue(5);
+ signals.EmitVoidSignal1IntValue(5);
DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
}
{
TestSlotHandler handlers;
signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
- signals.EmitVoidSignalIntValueIntValue(5, 10);
+ signals.EmitVoidSignal2IntValue(5, 10);
DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
DALI_TEST_EQUALS( customTracker2.mCallbackHandled, true, TEST_LOCATION );
}
DALI_TEST_EQUALS( 0u, customTracker2.GetConnectionCount(), TEST_LOCATION );
+
+ // Test for removing a null callback
+ {
+ TestBasicConnectionTrackerInterface customTracker3;
+
+ TestSignals::VoidRetNoParamSignal signal;
+ DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_EQUALS( 0u, customTracker3.GetConnectionCount(), TEST_LOCATION );
+
+ signal.Connect( &customTracker3, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
+ DALI_TEST_CHECK( ! signal.Empty() );
+ DALI_TEST_EQUALS( 1u, customTracker3.GetConnectionCount(), TEST_LOCATION );
+ try
+ {
+ // should assert
+ customTracker3.RemoveNullCallback();
+ tet_result( TET_FAIL );
+ }
+ catch (Dali::DaliException& e)
+ {
+ tet_result( TET_PASS );
+ }
+ }
+
END_TEST;
}
signals.SignalVoid1Value().Connect( &handler3, &TestSlotHandler::VoidSlotIntValue );
DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
- signals.EmitVoidSignalIntValue( 5 );
+ signals.EmitVoidSignal1IntValue( 5 );
DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
DALI_TEST_EQUALS( handler1.mIntParam1, 5, TEST_LOCATION );
DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
handler3.Reset();
signals.SignalVoid1Value().Disconnect( &handler2, &TestSlotHandler::VoidSlotIntValue );
- signals.EmitVoidSignalIntValue( 6 );
+ signals.EmitVoidSignal1IntValue( 6 );
DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
DALI_TEST_EQUALS( handler1.mIntParam1, 6, TEST_LOCATION );
DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
- signals.EmitVoidSignalIntValue( 6 );
+ signals.EmitVoidSignal1IntValue( 6 );
DALI_TEST_EQUALS( handler1.mHandledCount, 1, TEST_LOCATION );
DALI_TEST_EQUALS( handler1.mIntParam1, 6, TEST_LOCATION );
DALI_TEST_CHECK( signals.SignalVoid1Value().Empty() );
handler1.mIntParam1 = 0;
- signals.EmitVoidSignalIntValue( 7 );
+ signals.EmitVoidSignal1IntValue( 7 );
DALI_TEST_EQUALS( handler1.mHandledCount, 1/*not incremented since last check*/, TEST_LOCATION );
DALI_TEST_EQUALS( handler1.mIntParam1, 0, TEST_LOCATION );
}
DALI_TEST_CHECK( signals.SignalBool1Value().Empty() );
// Should be NOOP
- signals.EmitVoidSignalIntValue( 1 );
+ signals.EmitVoidSignal1IntValue( 1 );
signals.EmitBoolSignalFloatValue( 1.0f );
// Test that connecting the same callback 10 times is a NOOP
{
TestApplication app; // Create core for debug logging
- TestSignals::VoidRetNoParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
+ // for coverage purposes we test the emit guard for each signal type (0,1,2,3 params) void / return value
+ {
+ TestSignals::VoidRetNoParamSignal signal;
+ DALI_TEST_CHECK( signal.Empty() );
+
+ TestEmitDuringCallback handler1;
+ handler1.VoidConnectVoid( signal );
+
+ // Test that this does not result in an infinite loop!
+ signal.Emit();
+ }
+ {
+ TestSignals::FloatRet0ParamSignal signal;
+
+ DALI_TEST_CHECK( signal.Empty() );
+
+ TestEmitDuringCallback handler1;
+ handler1.FloatRet0ParamConnect( signal );
+
+ // Test that this does not result in an infinite loop!
+ signal.Emit();
+ }
+ {
+ TestSignals::FloatRet1ParamSignal signal;
+
+ DALI_TEST_CHECK( signal.Empty() );
+
+ TestEmitDuringCallback handler1;
+ handler1.FloatRet1ParamConnect( signal );
+
+ // Test that this does not result in an infinite loop!
+ signal.Emit( 1.f );
+ }
+ {
+ TestSignals::FloatRet2ValueParamSignal signal;
+
+ DALI_TEST_CHECK( signal.Empty() );
+
+ TestEmitDuringCallback handler1;
+ handler1.FloatRet2ParamConnect( signal );
+
+ // Test that this does not result in an infinite loop!
+ signal.Emit( 1.f, 1.f );
+ }
+ {
+ TestSignals::FloatRet3ValueParamSignal signal;
+
+ DALI_TEST_CHECK( signal.Empty() );
+
+ TestEmitDuringCallback handler1;
+ handler1.FloatRet3ParamConnect( signal );
+
+ // Test that this does not result in an infinite loop!
+ signal.Emit( 1.f,1.f,1.f );
+ }
+ END_TEST;
+}
+
+int UtcDaliSignalDeleteDuringEmit(void)
+{
+ // testing a signal deletion during an emit
+ // need to dynamically allocate the signal for this to work
+
+ TestApplication app; // Create core for debug logging
+
+ TestSignals::VoidRetNoParamSignal* signal = new TestSignals::VoidRetNoParamSignal;
TestEmitDuringCallback handler1;
- handler1.VoidConnectVoid( signal );
+ handler1.DeleteDuringEmitConnect( *signal );
+
+ // should just log an error
+ signal->Emit();
+
+ tet_result( TET_PASS );
- // Test that this does not result in an infinite loop!
- signal.Emit();
END_TEST;
}
TestSlotDelegateHandler handlers;
signals.SignalVoid1Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue );
DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- signals.EmitVoidSignalIntValue(5);
+ signals.EmitVoidSignal1IntValue(5);
DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mIntParam1, 5, TEST_LOCATION );
}
TestSlotDelegateHandler handlers;
signals.SignalVoid2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue );
DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- signals.EmitVoidSignalIntValueIntValue(6, 7);
+ signals.EmitVoidSignal2IntValue(6, 7);
DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mIntParam1, 6, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mIntParam2, 7, TEST_LOCATION );
{
TestSlotDelegateHandler handlers;
- signals.FloatSignalFloatValue3().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValue3 );
+ signals.SignalFloat3Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValue3 );
DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
handlers.mFloatReturn = 27.0f;
- float returnValue = signals.EmitFloatSignalFloatValue3(5, 33.0f, 100.0f);
+ float returnValue = signals.EmitFloat3VSignal(5, 33.0f, 100.0f);
DALI_TEST_EQUALS( returnValue, 27.0f, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
signals.SignalVoid1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
signals.SignalVoid1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
- signals.EmitVoidSignalIntValue(5);
+ signals.EmitVoidSignal1IntValue(5);
DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
}
signals.SignalVoid2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
signals.SignalVoid2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
- signals.EmitVoidSignalIntValueIntValue(5, 10);
+ signals.EmitVoidSignal2IntValue(5, 10);
DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
}
END_TEST;
}
+
+
+int UtcDaliCallbackBase(void)
+{
+ // simple constructor for coverage
+ CallbackBase base;
+ tet_result( TET_PASS );
+ END_TEST;
+}
+
+int UtcDaliSlotDelegateMethods(void)
+{
+ TestSignals signals;
+
+ TestSlotDelegateHandler handlers;
+ DALI_TEST_EQUALS( 0, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION );
+ signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
+ DALI_TEST_EQUALS( 1, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION );
+ signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
+ DALI_TEST_EQUALS( 2, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION );
+
+ handlers.mSlotDelegate.DisconnectAll();
+ DALI_TEST_EQUALS( 0, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION );
+
+ END_TEST;
+}
projects / platform / core / uifw / dali-core.git / blobdiff