2 * Copyright (c) 2014 Samsung Electronics Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
23 #include <dali/public-api/dali-core.h>
24 #include <dali-test-suite-utils.h>
28 void utc_dali_signal_templates_startup(void)
30 test_return_value = TET_UNDEF;
33 void utc_dali_signal_templates_cleanup(void)
35 test_return_value = TET_PASS;
44 TestButton( unsigned int id )
51 mPanelDown.Emit( *this );
56 mPanelUp.Emit( *this );
59 typedef Signal< void (TestButton&) > PanelDownSignal;
60 typedef Signal< void (TestButton&) > PanelUpSignal;
62 PanelDownSignal& DownSignal()
67 PanelUpSignal& SignalUp()
80 PanelDownSignal mPanelDown;
81 PanelUpSignal mPanelUp;
84 class TestApp : public ConnectionTracker
89 : mButtonPressed( false ),
90 mVoidFunctionCalled( false )
94 void OnButtonPress( TestButton& button )
96 mButtonPressed = true;
97 mButtonId = button.GetId();
100 void OnButtonRelease( TestButton& button )
102 mButtonPressed = false;
103 mButtonId = button.GetId();
106 int GetButtonPressedId()
111 bool BoolReturnTestFalse()
116 bool BoolReturnTestTrue()
123 mVoidFunctionCalled = true;
127 bool mVoidFunctionCalled;
135 // Void return, no parameters
136 typedef Signal<void ()> VoidRetNoParamSignal;
138 // Void return, 1 value parameter
139 typedef Signal<void (int)> VoidRet1ValueParamSignal;
141 // Void return, 1 reference parameter
142 typedef Signal< void (int&)> VoidRet1RefParamSignal;
144 // Void return, 2 value parameters
145 typedef Signal<void (int, int)> VoidRet2ValueParamSignal;
147 // bool return, 1 value parameter
148 typedef Signal< bool (float)> BoolRet1ValueParamSignal;
150 // bool return, 2 value parameter
151 typedef Signal<bool (float, int) > BoolRet2ValueParamSignal;
153 // int return, 2 value parameter
154 typedef Signal<int (float, int)> IntRet2ValueParamSignal;
156 // float return, 0 parameters
157 typedef Signal< float () > FloatRet0ParamSignal;
159 // float return, 2 value parameters
160 typedef Signal<float (float, float) > FloatRet2ValueParamSignal;
162 // void return, 3 value parameters
163 typedef Signal<void (float, float, float) > VoidSignalTypeFloatValue3;
165 // float return, 3 value parameters
166 typedef Signal<float (float, float, float) > FloatSignalTypeFloatValue3;
168 VoidRetNoParamSignal& SignalVoidNone() { return mSignalVoid0; }
169 VoidRet1RefParamSignal& SignalVoid1Ref() { return mSignalVoid1R; }
170 VoidRet1ValueParamSignal& SignalVoid1Value() { return mSignalVoid1V; }
171 VoidRet2ValueParamSignal& SignalVoid2Value() { return mSignalVoid2V; }
173 BoolRet1ValueParamSignal& SignalBool1Value() { return mSignalBool1V; }
174 BoolRet2ValueParamSignal& SignalBool2Value() { return mSignalBool2V; }
175 IntRet2ValueParamSignal& SignalInt2Value() { return mSignalInt2V; }
176 FloatRet0ParamSignal& SignalFloat0() { return mSignalFloat0; }
177 FloatRet2ValueParamSignal& SignalFloat2Value() { return mSignalFloat2V; }
179 VoidSignalTypeFloatValue3& VoidSignalFloatValue3() { return mVoidSignalFloatValue3; }
180 FloatSignalTypeFloatValue3& FloatSignalFloatValue3() { return mFloatSignalFloatValue3; }
186 void CheckNoConnections()
188 DALI_TEST_EQUALS( mSignalVoid0.GetConnectionCount(), 0u, TEST_LOCATION );
189 DALI_TEST_EQUALS( mSignalVoid1R.GetConnectionCount(), 0u, TEST_LOCATION );
190 DALI_TEST_EQUALS( mSignalVoid1V.GetConnectionCount(), 0u, TEST_LOCATION );
191 DALI_TEST_EQUALS( mSignalVoid2V.GetConnectionCount(), 0u, TEST_LOCATION );
192 DALI_TEST_EQUALS( mSignalBool1V.GetConnectionCount(), 0u, TEST_LOCATION );
193 DALI_TEST_EQUALS( mSignalBool2V.GetConnectionCount(), 0u, TEST_LOCATION );
194 DALI_TEST_EQUALS( mSignalInt2V.GetConnectionCount(), 0u, TEST_LOCATION );
195 DALI_TEST_EQUALS( mSignalFloat0.GetConnectionCount(), 0u, TEST_LOCATION );
196 DALI_TEST_EQUALS( mSignalFloat2V.GetConnectionCount(), 0u, TEST_LOCATION );
197 DALI_TEST_EQUALS( mVoidSignalFloatValue3.GetConnectionCount(), 0u, TEST_LOCATION );
198 DALI_TEST_EQUALS( mFloatSignalFloatValue3.GetConnectionCount(), 0u, TEST_LOCATION );
201 void EmitVoidSignalVoid()
206 void EmitVoidSignalIntRef(int& ref)
208 mSignalVoid1R.Emit(ref);
211 void EmitVoidSignalIntValue(int p1)
213 mSignalVoid1V.Emit(p1);
216 void EmitVoidSignalIntValueIntValue(int p1, int p2)
218 mSignalVoid2V.Emit(p1,p2);
221 bool EmitBoolSignalFloatValue(float p1)
223 return mSignalBool1V.Emit(p1);
226 bool EmitBoolSignalFloatValueIntValue(float p1, int p2)
228 return mSignalBool2V.Emit(p1, p2);
231 int EmitIntSignalFloatValueIntValue(float p1, int p2)
233 return mSignalInt2V.Emit(p1, p2);
236 float EmitFloat2VSignal(float p1, float p2)
238 return mSignalFloat2V.Emit(p1, p2);
241 float EmitFloat0Signal()
243 return mSignalFloat0.Emit();
246 void EmitVoidSignalFloatValue3(float p1, float p2, float p3)
248 mVoidSignalFloatValue3.Emit(p1, p2, p3);
251 float EmitFloatSignalFloatValue3(float p1, float p2, float p3)
253 return mFloatSignalFloatValue3.Emit(p1, p2, p3);
258 VoidRetNoParamSignal mSignalVoid0;
259 VoidRet1RefParamSignal mSignalVoid1R;
260 VoidRet1ValueParamSignal mSignalVoid1V;
261 VoidRet2ValueParamSignal mSignalVoid2V;
262 BoolRet1ValueParamSignal mSignalBool1V;
263 BoolRet2ValueParamSignal mSignalBool2V;
264 IntRet2ValueParamSignal mSignalInt2V;
265 FloatRet0ParamSignal mSignalFloat0;
266 FloatRet2ValueParamSignal mSignalFloat2V;
267 VoidSignalTypeFloatValue3 mVoidSignalFloatValue3;
268 FloatSignalTypeFloatValue3 mFloatSignalFloatValue3;
272 * A helper class with various slots
274 class TestSlotHandler : public ConnectionTracker
282 mFloatParam1( 0.0f ),
283 mFloatParam2( 0.0f ),
284 mFloatParam3( 0.0f ),
285 mBoolReturn( false ),
287 mFloatReturn( 0.0f ),
313 void VoidSlotIntRef( int& p1 )
320 void VoidSlotIntValue( int p1 )
327 void VoidDuplicateSlotIntValue( int p1 )
334 void VoidSlotIntValueIntValue( int p1, int p2 )
342 bool BoolSlotFloatValue( float p1 )
350 bool BoolSlotFloatValueIntValue( float p1, int p2 )
359 int IntSlotFloatValueIntValue( float p1, int p2 )
368 float FloatSlotVoid()
375 float FloatSlotFloatValueFloatValue( float p1, float p2 )
384 void VoidSlotFloatValue3( float p1, float p2, float p3 )
393 float FloatSlotFloatValue3( float p1, float p2, float p3 )
403 int mIntParam1, mIntParam2, mIntParam3;
404 float mFloatParam1, mFloatParam2, mFloatParam3;
413 * A version of TestSlotHandler which disconnects during the callback
415 class TestSlotDisconnector : public ConnectionTracker
419 TestSlotDisconnector()
423 mFloatParam1( 0.0f ),
424 mFloatParam2( 0.0f ),
425 mBoolReturn( false ),
427 mFloatReturn( 0.0f ),
445 void VoidConnectVoid( TestSignals::VoidRetNoParamSignal& signal )
447 mVoidSignalVoid = &signal;
448 signal.Connect( this, &TestSlotDisconnector::VoidSlotVoid );
453 mVoidSignalVoid->Disconnect( this, &TestSlotDisconnector::VoidSlotVoid );
457 void VoidConnectIntRef( TestSignals::VoidRet1RefParamSignal& signal )
459 mVoidSignalIntRef = &signal;
460 signal.Connect( this, &TestSlotDisconnector::VoidSlotIntRef );
463 void VoidSlotIntRef( int& p1 )
465 mVoidSignalIntRef->Disconnect( this, &TestSlotDisconnector::VoidSlotIntRef );
470 void VoidSlotIntValue( int p1 )
476 void VoidSlotIntValueIntValue( int p1, int p2 )
483 bool BoolSlotFloatValue( float p1 )
490 bool BoolSlotFloatValueIntValue( float p1, int p2 )
498 int IntSlotFloatValueIntValue( float p1, int p2 )
506 float FloatSlotVoid()
512 float FloatSlotFloatValueFloatValue( float p1, float p2 )
520 TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
521 TestSignals::VoidRet1RefParamSignal* mVoidSignalIntRef;
523 int mIntParam1, mIntParam2, mIntParam3;
524 float mFloatParam1, mFloatParam2;
532 * A more complicated version of TestSlotDisconnector, which disconnects some but not all callbacks
534 class TestSlotMultiDisconnector : public ConnectionTracker
538 static const int NUM_SLOTS = 10;
540 TestSlotMultiDisconnector()
541 : mVoidSignalVoid( NULL )
548 for( int i=0; i<NUM_SLOTS; ++i )
550 mSlotHandled[i] = false;
554 void ConnectAll( TestSignals::VoidRetNoParamSignal& signal )
556 mVoidSignalVoid = &signal;
557 signal.Connect( this, &TestSlotMultiDisconnector::Slot0 );
558 signal.Connect( this, &TestSlotMultiDisconnector::Slot1 );
559 signal.Connect( this, &TestSlotMultiDisconnector::Slot2 );
560 signal.Connect( this, &TestSlotMultiDisconnector::Slot3 );
561 signal.Connect( this, &TestSlotMultiDisconnector::Slot4 );
562 signal.Connect( this, &TestSlotMultiDisconnector::Slot5 );
563 signal.Connect( this, &TestSlotMultiDisconnector::Slot6 );
564 signal.Connect( this, &TestSlotMultiDisconnector::Slot7 );
565 signal.Connect( this, &TestSlotMultiDisconnector::Slot8 );
566 signal.Connect( this, &TestSlotMultiDisconnector::Slot9 );
571 mSlotHandled[0] = true;
576 mSlotHandled[1] = true;
581 mSlotHandled[2] = true;
586 mSlotHandled[3] = true;
588 // Disconnect the odd numbered lots, because we can
589 mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot1 );
590 mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot3 );
591 mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot5 );
592 mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot7 );
593 mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot9 );
598 mSlotHandled[4] = true;
603 mSlotHandled[5] = true;
608 mSlotHandled[6] = true;
613 mSlotHandled[7] = true;
618 mSlotHandled[8] = true;
623 mSlotHandled[9] = true;
626 TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
628 bool mSlotHandled[NUM_SLOTS];
633 * A version of TestSlotHandler which disconnects during the callback
635 class TestEmitDuringCallback : public ConnectionTracker
639 TestEmitDuringCallback()
640 : mVoidSignalVoid( NULL ),
645 void VoidConnectVoid( TestSignals::VoidRetNoParamSignal& signal )
647 mVoidSignalVoid = &signal;
648 signal.Connect( this, &TestEmitDuringCallback::VoidSlotVoid );
653 // Emitting during Emit is very bad!
654 mVoidSignalVoid->Emit();
659 TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
666 * A version of TestSlotHandler which uses SlotDelegate
668 class TestSlotDelegateHandler // This does not inherit from ConnectionTrackerInterface!
672 TestSlotDelegateHandler()
673 : mSlotDelegate( this ),
677 mFloatParam1( 0.0f ),
678 mFloatParam2( 0.0f ),
679 mFloatParam3( 0.0f ),
680 mBoolReturn( false ),
682 mFloatReturn( 0.0f ),
708 void VoidSlotIntRef( int& p1 )
715 void VoidSlotIntValue( int p1 )
722 void VoidDuplicateSlotIntValue( int p1 )
729 void VoidSlotIntValueIntValue( int p1, int p2 )
737 bool BoolSlotFloatValue( float p1 )
745 bool BoolSlotFloatValueIntValue( float p1, int p2 )
754 int IntSlotFloatValueIntValue( float p1, int p2 )
763 float FloatSlotVoid()
770 float FloatSlotFloatValueFloatValue( float p1, float p2 )
779 void VoidSlotFloatValue3( float p1, float p2, float p3 )
788 float FloatSlotFloatValue3( float p1, float p2, float p3 )
798 SlotDelegate<TestSlotDelegateHandler> mSlotDelegate;
800 int mIntParam1, mIntParam2, mIntParam3;
801 float mFloatParam1, mFloatParam2, mFloatParam3;
810 * Test that reimplmenting ConnectionTrackerInterface actually works.
811 * This basic connection tracker only allows one callback to be connected.
813 class TestBasicConnectionTrackerInterface : public ConnectionTrackerInterface
817 TestBasicConnectionTrackerInterface()
818 : mCallbackHandled( false ),
820 mSlotObserver( NULL )
824 ~TestBasicConnectionTrackerInterface()
826 if( mSlotObserver && mCallback )
828 // Notify signal since the slot has been destroyed
829 mSlotObserver->SlotDisconnected( mCallback );
830 // mCallback and mSlotObserver are not owned
839 mCallbackHandled = true;
843 * @copydoc ConnectionTrackerInterface::GetConnectionCount
845 virtual std::size_t GetConnectionCount() const
856 * @copydoc ConnectionTrackerInterface::SignalConnected
858 virtual void SignalConnected( SlotObserver* slotObserver, CallbackBase* callback )
860 DALI_ASSERT_ALWAYS( NULL == mCallback && "Only one connection supported!" );
862 mCallback = callback;
863 mSlotObserver = slotObserver;
867 * @copydoc ConnectionTrackerInterface::SignalDisconnected
869 virtual void SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback )
871 if( mSlotObserver == slotObserver )
873 mSlotObserver = NULL;
875 // mCallback and mSlotObserver are not owned
881 TestBasicConnectionTrackerInterface( const TestBasicConnectionTrackerInterface& ); ///< undefined copy constructor
882 TestBasicConnectionTrackerInterface& operator=( const TestBasicConnectionTrackerInterface& ); ///< undefined assignment operator
886 bool mCallbackHandled;
890 CallbackBase* mCallback; ///< callback, has ownership
891 SlotObserver* mSlotObserver; ///< a pointer to the slot observer (not owned)
895 bool wasStaticVoidCallbackVoidCalled = false;
896 bool wasStaticFloatCallbackVoidCalled = false;
897 bool wasStaticVoidCallbackIntValueCalled = false;
898 int staticIntValue = 0;
899 bool wasStaticFloatCallbackFloatValueFloatValueCalled = false;
900 float staticFloatValue1 = 0.0f;
901 float staticFloatValue2 = 0.0f;
903 static void StaticVoidCallbackVoid()
905 wasStaticVoidCallbackVoidCalled = true;
908 static float StaticFloatCallbackVoid()
910 wasStaticFloatCallbackVoidCalled = true;
914 static void StaticVoidCallbackIntValue( int value )
916 wasStaticVoidCallbackIntValueCalled = true;
917 staticIntValue = value;
920 static float StaticFloatCallbackFloatValueFloatValue( float value1, float value2 )
922 wasStaticFloatCallbackFloatValueFloatValueCalled = true;
923 staticFloatValue1 = value1;
924 staticFloatValue2 = value2;
925 return value1 + value2;
931 int UtcDaliSignalEmptyCheck(void)
933 // Test that Empty() check works before & after signal connection
936 TestSignals::VoidRetNoParamSignal signal;
937 DALI_TEST_CHECK( signal.Empty() );
938 TestSlotHandler handler;
939 signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
940 DALI_TEST_CHECK( ! signal.Empty() );
944 TestSignals::VoidRet1ValueParamSignal signal;
945 DALI_TEST_CHECK( signal.Empty() );
946 TestSlotHandler handler;
947 signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValue );
948 DALI_TEST_CHECK( ! signal.Empty() );
952 TestSignals::VoidRet1RefParamSignal signal;
953 DALI_TEST_CHECK( signal.Empty() );
954 TestSlotHandler handler;
955 signal.Connect( &handler, &TestSlotHandler::VoidSlotIntRef );
956 DALI_TEST_CHECK( ! signal.Empty() );
960 TestSignals::VoidRet2ValueParamSignal signal;
961 DALI_TEST_CHECK( signal.Empty() );
962 TestSlotHandler handler;
963 signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValueIntValue );
964 DALI_TEST_CHECK( ! signal.Empty() );
968 TestSignals::BoolRet1ValueParamSignal signal;
969 DALI_TEST_CHECK( signal.Empty() );
970 TestSlotHandler handler;
971 signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValue );
972 DALI_TEST_CHECK( ! signal.Empty() );
976 TestSignals::BoolRet2ValueParamSignal signal;
977 DALI_TEST_CHECK( signal.Empty() );
978 TestSlotHandler handler;
979 signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValueIntValue );
980 DALI_TEST_CHECK( ! signal.Empty() );
984 TestSignals::IntRet2ValueParamSignal signal;
985 DALI_TEST_CHECK( signal.Empty() );
986 TestSlotHandler handler;
987 signal.Connect( &handler, &TestSlotHandler::IntSlotFloatValueIntValue );
988 DALI_TEST_CHECK( ! signal.Empty() );
992 TestSignals::FloatRet0ParamSignal signal;
993 DALI_TEST_CHECK( signal.Empty() );
994 TestSlotHandler handler;
995 signal.Connect( &handler, &TestSlotHandler::FloatSlotVoid );
996 DALI_TEST_CHECK( ! signal.Empty() );
1000 TestSignals::FloatRet2ValueParamSignal signal;
1001 DALI_TEST_CHECK( signal.Empty() );
1002 TestSlotHandler handler;
1003 signal.Connect(&handler, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1004 DALI_TEST_CHECK( ! signal.Empty() );
1009 int UtcDaliSignalEmptyCheckSlotDestruction(void)
1011 // Test that signal disconnect works when slot is destroyed (goes out of scope)
1014 TestSignals::VoidRetNoParamSignal signal;
1016 DALI_TEST_CHECK( signal.Empty() );
1017 TestSlotHandler handler;
1018 signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
1019 DALI_TEST_CHECK( ! signal.Empty() );
1021 // End of slot lifetime
1022 DALI_TEST_CHECK( signal.Empty() );
1024 // Signal emission should be a NOOP
1029 TestSignals::VoidRet1ValueParamSignal signal;
1031 DALI_TEST_CHECK( signal.Empty() );
1032 TestSlotHandler handler;
1033 signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValue );
1034 DALI_TEST_CHECK( ! signal.Empty() );
1036 // End of slot lifetime
1037 DALI_TEST_CHECK( signal.Empty() );
1039 // Signal emission should be a NOOP
1044 TestSignals::VoidRet1RefParamSignal signal;
1046 DALI_TEST_CHECK( signal.Empty() );
1047 TestSlotHandler handler;
1048 signal.Connect( &handler, &TestSlotHandler::VoidSlotIntRef );
1049 DALI_TEST_CHECK( ! signal.Empty() );
1051 // End of slot lifetime
1052 DALI_TEST_CHECK( signal.Empty() );
1054 // Signal emission should be a NOOP
1056 signal.Emit( temp );
1060 TestSignals::VoidRet2ValueParamSignal signal;
1062 DALI_TEST_CHECK( signal.Empty() );
1063 TestSlotHandler handler;
1064 signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValueIntValue );
1065 DALI_TEST_CHECK( ! signal.Empty() );
1067 // End of slot lifetime
1068 DALI_TEST_CHECK( signal.Empty() );
1070 // Signal emission should be a NOOP
1071 signal.Emit( 1, 2 );
1075 TestSignals::BoolRet1ValueParamSignal signal;
1077 DALI_TEST_CHECK( signal.Empty() );
1078 TestSlotHandler handler;
1079 signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValue );
1080 DALI_TEST_CHECK( ! signal.Empty() );
1082 // End of slot lifetime
1083 DALI_TEST_CHECK( signal.Empty() );
1085 // Signal emission should be a NOOP
1086 bool blah = signal.Emit( 1.0f );
1087 DALI_TEST_CHECK( ! blah );
1091 TestSignals::BoolRet2ValueParamSignal signal;
1093 DALI_TEST_CHECK( signal.Empty() );
1094 TestSlotHandler handler;
1095 signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValueIntValue );
1096 DALI_TEST_CHECK( ! signal.Empty() );
1098 // End of slot lifetime
1099 DALI_TEST_CHECK( signal.Empty() );
1101 // Signal emission should be a NOOP
1102 bool blah = signal.Emit( 1.0f, 2 );
1103 DALI_TEST_CHECK( ! blah );
1107 TestSignals::IntRet2ValueParamSignal signal;
1109 DALI_TEST_CHECK( signal.Empty() );
1110 TestSlotHandler handler;
1111 signal.Connect( &handler, &TestSlotHandler::IntSlotFloatValueIntValue );
1112 DALI_TEST_CHECK( ! signal.Empty() );
1114 // End of slot lifetime
1115 DALI_TEST_CHECK( signal.Empty() );
1117 // Signal emission should be a NOOP
1118 int blah = signal.Emit( 10.0f, 100 );
1119 DALI_TEST_CHECK( 0 == blah );
1123 TestSignals::FloatRet0ParamSignal signal;
1125 DALI_TEST_CHECK( signal.Empty() );
1126 TestSlotHandler handler;
1127 signal.Connect( &handler, &TestSlotHandler::FloatSlotVoid );
1128 DALI_TEST_CHECK( ! signal.Empty() );
1130 // End of slot lifetime
1131 DALI_TEST_CHECK( signal.Empty() );
1133 // Signal emission should be a NOOP
1134 float blah = signal.Emit();
1135 DALI_TEST_CHECK( 0.0f == blah );
1139 TestSignals::FloatRet2ValueParamSignal signal;
1141 DALI_TEST_CHECK( signal.Empty() );
1142 TestSlotHandler handler;
1143 signal.Connect(&handler, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1144 DALI_TEST_CHECK( ! signal.Empty() );
1146 // End of slot lifetime
1147 DALI_TEST_CHECK( signal.Empty() );
1149 // Signal emission should be a NOOP
1150 float blah = signal.Emit( 3.0f, 4.0f );
1151 DALI_TEST_CHECK( 0.0f == blah );
1156 // Positive test case for a method
1157 int UtcDaliSignalConnectAndEmit(void)
1159 // Test basic signal emission for each slot type
1161 TestSignals signals;
1164 TestSlotHandler handlers;
1165 signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
1166 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1167 signals.EmitVoidSignalVoid();
1168 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1170 // Test double emission
1171 handlers.mHandled = false;
1172 signals.EmitVoidSignalVoid();
1173 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1175 signals.CheckNoConnections();
1178 TestSlotHandler handlers;
1179 signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1180 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1182 signals.EmitVoidSignalIntRef(x);
1183 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1184 DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
1186 signals.CheckNoConnections();
1189 TestSlotHandler handlers;
1190 signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
1191 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1192 signals.EmitVoidSignalIntValue(5);
1193 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1194 DALI_TEST_EQUALS( handlers.mIntParam1, 5, TEST_LOCATION );
1196 signals.CheckNoConnections();
1199 TestSlotHandler handlers;
1200 signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
1201 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1202 signals.EmitVoidSignalIntValueIntValue(6, 7);
1203 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1204 DALI_TEST_EQUALS( handlers.mIntParam1, 6, TEST_LOCATION );
1205 DALI_TEST_EQUALS( handlers.mIntParam2, 7, TEST_LOCATION );
1207 signals.CheckNoConnections();
1210 TestSlotHandler handlers;
1211 signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
1212 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1214 handlers.mBoolReturn = true;
1215 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION );
1216 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1217 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1219 // repeat with opposite return value
1220 handlers.mBoolReturn = false;
1221 handlers.mHandled = false;
1222 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION );
1223 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1224 DALI_TEST_EQUALS( handlers.mFloatParam1, 6.0f, TEST_LOCATION );
1226 signals.CheckNoConnections();
1229 TestSlotHandler handlers;
1230 signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
1231 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1232 handlers.mBoolReturn = true;
1233 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION );
1234 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1235 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1236 DALI_TEST_EQUALS( handlers.mIntParam2, 10, TEST_LOCATION );
1238 signals.CheckNoConnections();
1241 TestSlotHandler handlers;
1242 signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
1243 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1244 handlers.mIntReturn = 27;
1245 int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
1246 DALI_TEST_EQUALS( x, 27, TEST_LOCATION );
1247 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1248 DALI_TEST_EQUALS( handlers.mFloatParam1, 33.5f, TEST_LOCATION );
1249 DALI_TEST_EQUALS( handlers.mIntParam2, 5, TEST_LOCATION );
1251 signals.CheckNoConnections();
1254 TestSlotHandler handlers;
1255 signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
1256 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1257 handlers.mFloatReturn = 27.0f;
1258 float f = signals.EmitFloat0Signal();
1259 DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
1260 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1261 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1262 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1264 signals.CheckNoConnections();
1267 TestSlotHandler handlers;
1268 signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1269 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1270 handlers.mFloatReturn = 27.0f;
1271 float f = signals.EmitFloat2VSignal(5, 33.0f);
1272 DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
1273 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1274 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1275 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1277 signals.CheckNoConnections();
1280 TestSlotHandler handlers;
1281 signals.VoidSignalFloatValue3().Connect(&handlers, &TestSlotHandler::VoidSlotFloatValue3);
1282 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1283 signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
1284 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1285 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1286 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1287 DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
1289 signals.CheckNoConnections();
1292 TestSlotHandler handlers;
1293 signals.FloatSignalFloatValue3().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValue3);
1294 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1295 handlers.mFloatReturn = 27.0f;
1296 float returnValue = signals.EmitFloatSignalFloatValue3(5, 33.0f, 100.0f);
1297 DALI_TEST_EQUALS( returnValue, 27.0f, TEST_LOCATION );
1298 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1299 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1300 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1301 DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
1303 signals.CheckNoConnections();
1307 int UtcDaliSignalDisconnect(void)
1309 // Test that callbacks don't occur if a signal is disconnected before emission
1311 TestSignals signals;
1314 TestSlotHandler handlers;
1315 signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
1316 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1317 signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
1318 signals.EmitVoidSignalVoid();
1319 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1323 TestSlotHandler handlers;
1324 signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1325 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1327 handlers.mIntReturn = 5;
1328 signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1329 signals.EmitVoidSignalIntRef(r);
1330 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1331 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1332 DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
1336 TestSlotHandler handlers;
1337 signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
1338 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1339 signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
1340 signals.EmitVoidSignalIntValue(5);
1341 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1342 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1346 TestSlotHandler handlers;
1347 signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
1348 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1349 signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
1350 signals.EmitVoidSignalIntValueIntValue(5, 10);
1351 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1352 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1353 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
1357 TestSlotHandler handlers;
1358 signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
1359 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1360 handlers.mBoolReturn = true;
1361 signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
1362 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
1363 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1364 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1368 TestSlotHandler handlers;
1369 signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
1370 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1371 handlers.mBoolReturn = true;
1372 signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
1373 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
1374 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1375 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1376 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
1380 TestSlotHandler handlers;
1381 signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
1382 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1383 handlers.mIntReturn = 27;
1384 signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
1385 signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
1386 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1387 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1388 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1392 TestSlotHandler handlers;
1393 signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
1394 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1395 handlers.mFloatReturn = 27.0f;
1396 signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
1397 signals.EmitFloat0Signal();
1398 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1399 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
1400 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1404 TestSlotHandler handlers;
1405 signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1406 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1407 handlers.mFloatReturn = 27.0f;
1408 signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1409 signals.EmitFloat2VSignal(5, 33.0f);
1410 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1411 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
1412 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1417 int UtcDaliSignalDisconnect2(void)
1419 // Test that nothing happens when attempting to disconnect an unconnected slot
1421 TestSignals signals;
1423 TestSlotHandler handlers;
1424 signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
1425 signals.EmitVoidSignalVoid();
1426 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1430 TestSlotHandler handlers;
1432 signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1433 signals.EmitVoidSignalIntRef(r);
1434 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1435 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1436 DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
1440 TestSlotHandler handlers;
1441 signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
1442 signals.EmitVoidSignalIntValue(5);
1443 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1444 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1448 TestSlotHandler handlers;
1449 signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
1450 signals.EmitVoidSignalIntValueIntValue(5, 10);
1451 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1452 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1453 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
1457 TestSlotHandler handlers;
1458 handlers.mBoolReturn = true;
1459 signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
1460 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
1461 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1462 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1466 TestSlotHandler handlers;
1467 handlers.mBoolReturn = true;
1468 signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
1469 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
1470 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1471 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1472 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
1476 TestSlotHandler handlers;
1477 handlers.mIntReturn = 27;
1478 signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
1479 signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
1480 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1481 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1482 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1486 TestSlotHandler handlers;
1487 handlers.mFloatReturn = 27.0f;
1488 signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1489 signals.EmitFloat2VSignal(5, 33.0f);
1490 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1491 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
1492 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1496 TestSlotHandler handlers;
1497 handlers.mFloatReturn = 27.0f;
1498 signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
1499 signals.EmitFloat0Signal();
1500 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1501 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
1502 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1507 int UtcDaliSignalDisconnect3(void)
1509 // Test that callbacks stop after a signal is disconnected
1511 TestSignals signals;
1514 TestSlotHandler handlers;
1515 signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
1516 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1519 signals.EmitVoidSignalVoid();
1520 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1522 // Disconnect and emit again
1523 handlers.mHandled = false;
1524 signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
1525 signals.EmitVoidSignalVoid();
1526 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1530 TestSlotHandler handlers;
1531 signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1532 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1536 signals.EmitVoidSignalIntRef(r);
1537 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1538 DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
1540 // Disconnect and emit again
1541 handlers.mHandled = false;
1542 handlers.mIntParam1 = 0;
1543 signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1544 signals.EmitVoidSignalIntRef(r);
1545 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1546 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1547 DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
1552 int UtcDaliSignalCustomConnectionTracker(void)
1554 // Test slot destruction
1556 TestSignals::VoidRetNoParamSignal signal;
1558 DALI_TEST_CHECK( signal.Empty() );
1559 TestBasicConnectionTrackerInterface customTracker;
1560 signal.Connect( &customTracker, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
1561 DALI_TEST_CHECK( ! signal.Empty() );
1563 // End of slot lifetime
1564 DALI_TEST_CHECK( signal.Empty() );
1566 // Signal emission should be a NOOP
1570 TestBasicConnectionTrackerInterface customTracker2;
1572 // Test signal emission & destruction
1574 TestSignals::VoidRetNoParamSignal signal;
1575 DALI_TEST_CHECK( signal.Empty() );
1576 DALI_TEST_EQUALS( 0u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1578 signal.Connect( &customTracker2, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
1579 DALI_TEST_CHECK( ! signal.Empty() );
1580 DALI_TEST_EQUALS( 1u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1582 DALI_TEST_EQUALS( customTracker2.mCallbackHandled, false, TEST_LOCATION );
1584 DALI_TEST_EQUALS( customTracker2.mCallbackHandled, true, TEST_LOCATION );
1586 DALI_TEST_EQUALS( 0u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1590 int UtcDaliSignalMultipleConnections(void)
1592 // Test that multiple callbacks can be connected to the same signal
1594 TestSignals signals;
1597 TestSlotHandler handler1;
1598 signals.SignalVoidNone().Connect( &handler1, &TestSlotHandler::VoidSlotVoid );
1599 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1601 TestSlotHandler handler2;
1602 signals.SignalVoidNone().Connect( &handler2, &TestSlotHandler::VoidSlotVoid );
1603 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1605 signals.EmitVoidSignalVoid();
1606 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1607 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1609 // Remove first connection and repeat
1612 signals.SignalVoidNone().Disconnect( &handler1, &TestSlotHandler::VoidSlotVoid );
1614 signals.EmitVoidSignalVoid();
1615 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1616 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1620 TestSlotHandler handler1;
1621 signals.SignalVoid1Ref().Connect( &handler1, &TestSlotHandler::VoidSlotIntRef );
1622 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1624 TestSlotHandler handler2;
1625 signals.SignalVoid1Ref().Connect( &handler2, &TestSlotHandler::VoidSlotIntRef );
1626 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1629 signals.EmitVoidSignalIntRef(x);
1630 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1631 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1632 DALI_TEST_EQUALS( handler1.mIntParam1, 7, TEST_LOCATION );
1633 DALI_TEST_EQUALS( handler2.mIntParam1, 7, TEST_LOCATION );
1635 // Remove second connection and repeat
1639 signals.SignalVoid1Ref().Disconnect( &handler2, &TestSlotHandler::VoidSlotIntRef );
1641 signals.EmitVoidSignalIntRef(x);
1642 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1643 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1644 DALI_TEST_EQUALS( handler1.mIntParam1, 8, TEST_LOCATION );
1645 DALI_TEST_EQUALS( handler2.mIntParam1, 0, TEST_LOCATION );
1649 TestSlotHandler handler1;
1650 signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1651 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1653 TestSlotHandler handler2;
1654 signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1655 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1657 TestSlotHandler handler3;
1658 signals.SignalVoid1Value().Connect( &handler3, &TestSlotHandler::VoidSlotIntValue );
1659 DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
1661 signals.EmitVoidSignalIntValue( 5 );
1662 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1663 DALI_TEST_EQUALS( handler1.mIntParam1, 5, TEST_LOCATION );
1664 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1665 DALI_TEST_EQUALS( handler2.mIntParam1, 5, TEST_LOCATION );
1666 DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1667 DALI_TEST_EQUALS( handler3.mIntParam1, 5, TEST_LOCATION );
1669 // Remove middle connection and repeat
1673 signals.SignalVoid1Value().Disconnect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1675 signals.EmitVoidSignalIntValue( 6 );
1676 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1677 DALI_TEST_EQUALS( handler1.mIntParam1, 6, TEST_LOCATION );
1678 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1679 DALI_TEST_EQUALS( handler2.mIntParam1, 0, TEST_LOCATION );
1680 DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1681 DALI_TEST_EQUALS( handler3.mIntParam1, 6, TEST_LOCATION );
1684 // Test that multiple callbacks are disconnected when a signal is destroyed
1686 TestSlotHandler handler4;
1687 TestSlotHandler handler5;
1688 TestSlotHandler handler6;
1691 TestSignals::VoidRet1ValueParamSignal tempSignal;
1693 DALI_TEST_EQUALS( handler4.GetConnectionCount(), 0u, TEST_LOCATION );
1694 DALI_TEST_EQUALS( handler5.GetConnectionCount(), 0u, TEST_LOCATION );
1695 DALI_TEST_EQUALS( handler6.GetConnectionCount(), 0u, TEST_LOCATION );
1697 tempSignal.Connect( &handler4, &TestSlotHandler::VoidSlotIntValue );
1698 tempSignal.Connect( &handler5, &TestSlotHandler::VoidSlotIntValue );
1699 tempSignal.Connect( &handler6, &TestSlotHandler::VoidSlotIntValue );
1701 DALI_TEST_EQUALS( handler4.GetConnectionCount(), 1u, TEST_LOCATION );
1702 DALI_TEST_EQUALS( handler5.GetConnectionCount(), 1u, TEST_LOCATION );
1703 DALI_TEST_EQUALS( handler6.GetConnectionCount(), 1u, TEST_LOCATION );
1705 // End of tempSignal lifetime
1707 DALI_TEST_EQUALS( handler4.GetConnectionCount(), 0u, TEST_LOCATION );
1708 DALI_TEST_EQUALS( handler5.GetConnectionCount(), 0u, TEST_LOCATION );
1709 DALI_TEST_EQUALS( handler6.GetConnectionCount(), 0u, TEST_LOCATION );
1713 int UtcDaliSignalMultipleConnections2(void)
1715 TestSignals signals;
1717 // Test that connecting the same callback twice is a NOOP
1719 TestSlotHandler handler1;
1721 // Note the double connection is intentional
1722 signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1723 signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1724 DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1726 signals.EmitVoidSignalIntValue( 6 );
1727 DALI_TEST_EQUALS( handler1.mHandledCount, 1, TEST_LOCATION );
1728 DALI_TEST_EQUALS( handler1.mIntParam1, 6, TEST_LOCATION );
1730 // Calling Disconnect once should be enough
1731 signals.SignalVoid1Value().Disconnect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1732 DALI_TEST_CHECK( signals.SignalVoid1Value().Empty() );
1733 handler1.mIntParam1 = 0;
1735 signals.EmitVoidSignalIntValue( 7 );
1736 DALI_TEST_EQUALS( handler1.mHandledCount, 1/*not incremented since last check*/, TEST_LOCATION );
1737 DALI_TEST_EQUALS( handler1.mIntParam1, 0, TEST_LOCATION );
1740 // Test automatic disconnect after multiple Connect() calls
1742 TestSlotHandler handler2;
1743 signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1744 signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1746 TestSlotHandler handler3;
1747 signals.SignalBool1Value().Connect( &handler3, &TestSlotHandler::BoolSlotFloatValue );
1748 signals.SignalBool1Value().Connect( &handler3, &TestSlotHandler::BoolSlotFloatValue );
1750 DALI_TEST_EQUALS( handler2.mHandledCount, 0, TEST_LOCATION );
1751 DALI_TEST_EQUALS( handler3.mHandledCount, 0, TEST_LOCATION );
1752 DALI_TEST_CHECK( ! signals.SignalVoid1Value().Empty() );
1753 DALI_TEST_CHECK( ! signals.SignalBool1Value().Empty() );
1755 DALI_TEST_CHECK( signals.SignalVoid1Value().Empty() );
1756 DALI_TEST_CHECK( signals.SignalBool1Value().Empty() );
1759 signals.EmitVoidSignalIntValue( 1 );
1760 signals.EmitBoolSignalFloatValue( 1.0f );
1762 // Test that connecting the same callback 10 times is a NOOP
1763 TestSlotHandler handler4;
1764 DALI_TEST_EQUALS( handler4.mHandledCount, 0, TEST_LOCATION );
1765 DALI_TEST_EQUALS( handler4.mFloatParam1, 0.0f, TEST_LOCATION );
1767 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1768 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1769 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1770 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1771 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1772 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1773 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1774 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1775 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1776 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1778 signals.EmitBoolSignalFloatValue( 2.0f );
1779 DALI_TEST_EQUALS( handler4.mHandledCount, 1, TEST_LOCATION );
1780 DALI_TEST_EQUALS( handler4.mFloatParam1, 2.0f, TEST_LOCATION );
1782 // Calling Disconnect once should be enough
1783 signals.SignalBool1Value().Disconnect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1784 DALI_TEST_CHECK( signals.SignalBool1Value().Empty() );
1786 signals.EmitBoolSignalFloatValue( 3.0f );
1787 DALI_TEST_EQUALS( handler4.mHandledCount, 1/*not incremented since last check*/, TEST_LOCATION );
1788 DALI_TEST_EQUALS( handler4.mFloatParam1, 2.0f, TEST_LOCATION );
1792 int UtcDaliSignalMultipleConnections3(void)
1794 TestSignals signals;
1796 // Test connecting two difference callbacks for the same ConnectionTracker
1798 TestSlotHandler handler1;
1801 TestSignals::VoidRet1ValueParamSignal tempSignal;
1803 DALI_TEST_EQUALS( handler1.GetConnectionCount(), 0u, TEST_LOCATION );
1804 DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1805 DALI_TEST_EQUALS( handler1.mIntParam1, 0, TEST_LOCATION );
1807 // Note that the duplicate connection is deliberate
1808 tempSignal.Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1809 tempSignal.Connect( &handler1, &TestSlotHandler::VoidDuplicateSlotIntValue );
1811 DALI_TEST_EQUALS( handler1.GetConnectionCount(), 2u, TEST_LOCATION );
1812 DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1814 tempSignal.Emit( 10 );
1816 DALI_TEST_EQUALS( handler1.mHandledCount, 2, TEST_LOCATION );
1817 DALI_TEST_EQUALS( handler1.mIntParam1, 10, TEST_LOCATION );
1818 DALI_TEST_EQUALS( handler1.mIntParam2, 10, TEST_LOCATION );
1820 // End of tempSignal lifetime
1822 DALI_TEST_EQUALS( handler1.GetConnectionCount(), 0u, TEST_LOCATION );
1827 int UtcDaliSignalDisconnectStatic(void)
1832 TestSignals::VoidRetNoParamSignal signal;
1833 DALI_TEST_CHECK( signal.Empty() );
1835 signal.Connect( StaticVoidCallbackVoid );
1836 DALI_TEST_CHECK( ! signal.Empty() );
1838 wasStaticVoidCallbackVoidCalled = false;
1840 DALI_TEST_EQUALS( wasStaticVoidCallbackVoidCalled, true, TEST_LOCATION );
1842 signal.Disconnect( StaticVoidCallbackVoid );
1843 DALI_TEST_CHECK( signal.Empty() );
1845 wasStaticVoidCallbackVoidCalled = false;
1847 DALI_TEST_EQUALS( wasStaticVoidCallbackVoidCalled, false, TEST_LOCATION );
1853 TestSignals::FloatRet0ParamSignal signal;
1854 DALI_TEST_CHECK( signal.Empty() );
1856 signal.Connect( StaticFloatCallbackVoid );
1857 DALI_TEST_CHECK( ! signal.Empty() );
1859 wasStaticFloatCallbackVoidCalled = false;
1860 float result = signal.Emit();
1861 DALI_TEST_EQUALS( wasStaticFloatCallbackVoidCalled, true, TEST_LOCATION );
1862 DALI_TEST_EQUALS( result, 7.0f, TEST_LOCATION );
1864 signal.Disconnect( StaticFloatCallbackVoid );
1865 DALI_TEST_CHECK( signal.Empty() );
1867 wasStaticFloatCallbackVoidCalled = false;
1868 result = signal.Emit();
1869 DALI_TEST_EQUALS( wasStaticFloatCallbackVoidCalled, false, TEST_LOCATION );
1870 DALI_TEST_EQUALS( result, 0.0f, TEST_LOCATION );
1876 TestSignals::VoidRet1ValueParamSignal signal;
1877 DALI_TEST_CHECK( signal.Empty() );
1879 signal.Connect( StaticVoidCallbackIntValue );
1880 DALI_TEST_CHECK( ! signal.Empty() );
1882 wasStaticVoidCallbackIntValueCalled = false;
1885 DALI_TEST_EQUALS( wasStaticVoidCallbackIntValueCalled, true, TEST_LOCATION );
1886 DALI_TEST_EQUALS( staticIntValue, 10, TEST_LOCATION );
1888 signal.Disconnect( StaticVoidCallbackIntValue );
1889 DALI_TEST_CHECK( signal.Empty() );
1891 wasStaticVoidCallbackIntValueCalled = false;
1894 DALI_TEST_EQUALS( wasStaticVoidCallbackIntValueCalled, false, TEST_LOCATION );
1895 DALI_TEST_EQUALS( staticIntValue, 0, TEST_LOCATION );
1898 // float Func( float, float )
1901 TestSignals::FloatRet2ValueParamSignal signal;
1902 DALI_TEST_CHECK( signal.Empty() );
1904 signal.Connect( StaticFloatCallbackFloatValueFloatValue );
1905 DALI_TEST_CHECK( ! signal.Empty() );
1907 wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1908 staticFloatValue1 = 0.0f;
1909 staticFloatValue2 = 0.0f;
1910 float result = signal.Emit( 5.0f, 6.0f );
1911 DALI_TEST_EQUALS( wasStaticFloatCallbackFloatValueFloatValueCalled, true, TEST_LOCATION );
1912 DALI_TEST_EQUALS( staticFloatValue1, 5.0f, TEST_LOCATION );
1913 DALI_TEST_EQUALS( staticFloatValue2, 6.0f, TEST_LOCATION );
1914 DALI_TEST_EQUALS( result, 5.0f+6.0f, TEST_LOCATION );
1916 signal.Disconnect( StaticFloatCallbackFloatValueFloatValue );
1917 DALI_TEST_CHECK( signal.Empty() );
1919 wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1920 staticFloatValue1 = 0.0f;
1921 staticFloatValue2 = 0.0f;
1922 result = signal.Emit( 7.0f, 8.0f );
1923 DALI_TEST_EQUALS( wasStaticFloatCallbackFloatValueFloatValueCalled, false, TEST_LOCATION );
1924 DALI_TEST_EQUALS( staticFloatValue1, 0.0f, TEST_LOCATION );
1925 DALI_TEST_EQUALS( staticFloatValue2, 0.0f, TEST_LOCATION );
1926 DALI_TEST_EQUALS( result, 0.0f, TEST_LOCATION );
1931 int UtcDaliSignalDisconnectDuringCallback(void)
1933 // Test disconnection during each callback
1935 TestSignals::VoidRetNoParamSignal signal;
1936 DALI_TEST_CHECK( signal.Empty() );
1938 TestSlotDisconnector handler1;
1939 handler1.VoidConnectVoid( signal );
1940 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1941 DALI_TEST_CHECK( ! signal.Empty() );
1944 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1945 DALI_TEST_CHECK( signal.Empty() );
1947 // Repeat with 2 callbacks
1949 handler1.mHandled = false;
1951 TestSlotDisconnector handler2;
1952 handler1.VoidConnectVoid( signal );
1953 handler2.VoidConnectVoid( signal );
1954 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1955 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1956 DALI_TEST_CHECK( ! signal.Empty() );
1959 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1960 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1961 DALI_TEST_CHECK( signal.Empty() );
1963 // Repeat with no callbacks
1965 handler1.mHandled = false;
1966 handler2.mHandled = false;
1969 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1970 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1972 // Repeat with 3 callbacks
1974 TestSlotDisconnector handler3;
1975 handler1.VoidConnectVoid( signal );
1976 handler2.VoidConnectVoid( signal );
1977 handler3.VoidConnectVoid( signal );
1978 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1979 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1980 DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
1981 DALI_TEST_CHECK( ! signal.Empty() );
1984 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1985 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1986 DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1987 DALI_TEST_CHECK( signal.Empty() );
1989 // Repeat with no callbacks
1991 handler1.mHandled = false;
1992 handler2.mHandled = false;
1993 handler3.mHandled = false;
1996 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1997 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1998 DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
2002 int UtcDaliSignalDisconnectDuringCallback2(void)
2004 // Test disconnection of some (but not all) callbacks during sigmal emission
2006 TestSignals::VoidRetNoParamSignal signal;
2007 DALI_TEST_CHECK( signal.Empty() );
2009 TestSlotMultiDisconnector handler;
2010 handler.ConnectAll( signal );
2011 DALI_TEST_EQUALS( handler.mSlotHandled[0], false, TEST_LOCATION );
2012 DALI_TEST_EQUALS( handler.mSlotHandled[1], false, TEST_LOCATION );
2013 DALI_TEST_EQUALS( handler.mSlotHandled[2], false, TEST_LOCATION );
2014 DALI_TEST_EQUALS( handler.mSlotHandled[3], false, TEST_LOCATION );
2015 DALI_TEST_EQUALS( handler.mSlotHandled[4], false, TEST_LOCATION );
2016 DALI_TEST_EQUALS( handler.mSlotHandled[5], false, TEST_LOCATION );
2017 DALI_TEST_EQUALS( handler.mSlotHandled[6], false, TEST_LOCATION );
2018 DALI_TEST_EQUALS( handler.mSlotHandled[7], false, TEST_LOCATION );
2019 DALI_TEST_EQUALS( handler.mSlotHandled[8], false, TEST_LOCATION );
2020 DALI_TEST_EQUALS( handler.mSlotHandled[9], false, TEST_LOCATION );
2021 DALI_TEST_CHECK( ! signal.Empty() );
2025 // Slots 5, 7, & 9 should be disconnected before being called
2026 DALI_TEST_EQUALS( handler.mSlotHandled[0], true, TEST_LOCATION );
2027 DALI_TEST_EQUALS( handler.mSlotHandled[1], true, TEST_LOCATION );
2028 DALI_TEST_EQUALS( handler.mSlotHandled[2], true, TEST_LOCATION );
2029 DALI_TEST_EQUALS( handler.mSlotHandled[3], true, TEST_LOCATION );
2030 DALI_TEST_EQUALS( handler.mSlotHandled[4], true, TEST_LOCATION );
2031 DALI_TEST_EQUALS( handler.mSlotHandled[5], false, TEST_LOCATION );
2032 DALI_TEST_EQUALS( handler.mSlotHandled[6], true, TEST_LOCATION );
2033 DALI_TEST_EQUALS( handler.mSlotHandled[7], false, TEST_LOCATION );
2034 DALI_TEST_EQUALS( handler.mSlotHandled[8], true, TEST_LOCATION );
2035 DALI_TEST_EQUALS( handler.mSlotHandled[9], false, TEST_LOCATION );
2036 DALI_TEST_CHECK( ! signal.Empty() );
2038 // Odd slots are disconnected
2039 DALI_TEST_EQUALS( handler.GetConnectionCount(), 5u, TEST_LOCATION );
2043 int UtcDaliSignalEmitDuringCallback(void)
2045 TestApplication app; // Create core for debug logging
2047 TestSignals::VoidRetNoParamSignal signal;
2048 DALI_TEST_CHECK( signal.Empty() );
2050 TestEmitDuringCallback handler1;
2051 handler1.VoidConnectVoid( signal );
2053 // Test that this does not result in an infinite loop!
2058 int UtcDaliSignalTestApp01(void)
2060 // Test 1 signal connected to 1 Slot.
2061 // Signal dies first.
2063 TestButton* button = new TestButton(1);
2065 button->DownSignal().Connect(&app,&TestApp::OnButtonPress);
2067 // check we have both the button, and the app have 1 connection
2068 DALI_TEST_EQUALS( app.GetConnectionCount(), 1u, TEST_LOCATION );
2069 DALI_TEST_EQUALS( button->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2071 delete button; // should automatically destroy the connection
2073 // check we have a 0 connections
2074 DALI_TEST_EQUALS( app.GetConnectionCount(), 0u, TEST_LOCATION );
2079 int UtcDaliSignalTestApp02(void)
2081 // Test 1 signal connected to 1 Slot.
2082 // Slot owning object dies first.
2084 TestButton button(1);
2085 TestApp *app = new TestApp;
2086 button.DownSignal().Connect( app, &TestApp::OnButtonPress);
2088 // check we have a 1 connection
2089 DALI_TEST_EQUALS( app->GetConnectionCount(), 1u, TEST_LOCATION );
2090 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2092 delete app; // should automatically destroy the connection
2094 // check we have a 0 connections
2095 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION );
2099 int UtcDaliSignalTestApp03(void)
2101 // Test 1 Signal connect to 2 slots
2102 // 1 of the slot owners dies. Then the second slot owner dies
2104 TestButton button(1);
2105 TestApp *app1 = new TestApp;
2106 TestApp *app2 = new TestApp;
2108 button.DownSignal().Connect( app1, &TestApp::OnButtonPress);
2109 button.DownSignal().Connect( app2, &TestApp::OnButtonPress);
2111 // check we have a 2 connections to the signal
2112 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 2u, TEST_LOCATION );
2114 // kill the first slot
2115 delete app1; // should automatically destroy the connection
2117 // check we have 1 connection left
2118 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2120 button.Press(); // emit the signal (to ensure it doesn't seg fault)
2122 // kill the second slot
2123 delete app2; // should automatically destroy the connection
2125 // check we have 1 connection left
2126 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION );
2131 int UtcDaliSignalTestApp04(void)
2133 // Test 1 Signal connected to 2 slots (with different owners)
2134 // The Signal dies, check the 2 slots disconnect automatically
2136 TestButton* button = new TestButton(1);
2140 button->DownSignal().Connect(&app1,&TestApp::OnButtonPress);
2141 button->DownSignal().Connect(&app2,&TestApp::OnButtonPress);
2143 // check the connection counts
2144 DALI_TEST_EQUALS( app1.GetConnectionCount(), 1u, TEST_LOCATION );
2145 DALI_TEST_EQUALS( app2.GetConnectionCount(), 1u, TEST_LOCATION );
2146 DALI_TEST_EQUALS( button->DownSignal().GetConnectionCount(), 2u, TEST_LOCATION );
2148 delete button; // should automatically destroy the connection
2150 // check both slot owners have zero connections
2151 DALI_TEST_EQUALS( app1.GetConnectionCount(), 0u, TEST_LOCATION );
2152 DALI_TEST_EQUALS( app2.GetConnectionCount(), 0u, TEST_LOCATION );
2156 int UtcDaliSignalTestApp05(void)
2158 // Test 2 Signals (with different owners) connected to 1 slots
2159 // 1 Signal dies, check that the remaining connection is valid
2161 TestButton* button1 = new TestButton(1); // use for signal 1
2162 TestButton* button2 = new TestButton(2); // use for signal 2
2166 button1->DownSignal().Connect(&app,&TestApp::OnButtonPress);
2167 button2->DownSignal().Connect(&app,&TestApp::OnButtonPress);
2169 // check the connection counts
2170 DALI_TEST_EQUALS( app.GetConnectionCount(), 2u, TEST_LOCATION );
2171 DALI_TEST_EQUALS( button1->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2172 DALI_TEST_EQUALS( button2->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2174 // make sure both signals emit ok
2176 DALI_TEST_EQUALS( app.GetButtonPressedId() , 2 , TEST_LOCATION );
2179 DALI_TEST_EQUALS( app.GetButtonPressedId() , 1 , TEST_LOCATION );
2181 delete button1; // should automatically destroy 1 connection
2183 // check both slot owners have zero connections
2184 DALI_TEST_EQUALS( app.GetConnectionCount(), 1u, TEST_LOCATION );
2186 // check remaining connection still works
2188 DALI_TEST_EQUALS( app.GetButtonPressedId() , 2 , TEST_LOCATION );
2190 // kill the last signal
2192 DALI_TEST_EQUALS( app.GetConnectionCount(), 0u, TEST_LOCATION );
2196 int UtcDaliSignalTestApp06(void)
2198 Signal< bool () > boolSignal;
2202 // connect a slot which will return false
2203 boolSignal.Connect( &app, &TestApp::BoolReturnTestFalse);
2204 result = boolSignal.Emit();
2205 DALI_TEST_EQUALS( result, false, TEST_LOCATION );
2207 // disconnect last slot, and connect a slot which returns true
2208 boolSignal.Disconnect( &app, &TestApp::BoolReturnTestFalse);
2209 boolSignal.Connect( &app, &TestApp::BoolReturnTestTrue);
2210 result = boolSignal.Emit();
2211 DALI_TEST_EQUALS( result, true, TEST_LOCATION );
2215 int UtcDaliSlotDelegateConnection(void)
2217 TestSignals signals;
2220 TestSlotDelegateHandler handlers;
2221 signals.SignalVoidNone().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
2222 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2223 signals.EmitVoidSignalVoid();
2224 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2226 // Test double emission
2227 handlers.mHandled = false;
2228 signals.EmitVoidSignalVoid();
2229 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2231 signals.CheckNoConnections();
2234 TestSlotDelegateHandler handlers;
2235 signals.SignalVoid1Ref().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef );
2236 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2238 signals.EmitVoidSignalIntRef(x);
2239 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2240 DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
2242 signals.CheckNoConnections();
2245 TestSlotDelegateHandler handlers;
2246 signals.SignalVoid1Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue );
2247 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2248 signals.EmitVoidSignalIntValue(5);
2249 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2250 DALI_TEST_EQUALS( handlers.mIntParam1, 5, TEST_LOCATION );
2252 signals.CheckNoConnections();
2255 TestSlotDelegateHandler handlers;
2256 signals.SignalVoid2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue );
2257 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2258 signals.EmitVoidSignalIntValueIntValue(6, 7);
2259 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2260 DALI_TEST_EQUALS( handlers.mIntParam1, 6, TEST_LOCATION );
2261 DALI_TEST_EQUALS( handlers.mIntParam2, 7, TEST_LOCATION );
2263 signals.CheckNoConnections();
2266 TestSlotDelegateHandler handlers;
2267 signals.SignalBool1Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue );
2268 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2270 handlers.mBoolReturn = true;
2271 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION );
2272 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2273 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2275 // repeat with opposite return value
2276 handlers.mBoolReturn = false;
2277 handlers.mHandled = false;
2278 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION );
2279 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2280 DALI_TEST_EQUALS( handlers.mFloatParam1, 6.0f, TEST_LOCATION );
2282 signals.CheckNoConnections();
2285 TestSlotDelegateHandler handlers;
2286 signals.SignalBool2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue );
2287 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2288 handlers.mBoolReturn = true;
2289 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION );
2290 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2291 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2292 DALI_TEST_EQUALS( handlers.mIntParam2, 10, TEST_LOCATION );
2294 signals.CheckNoConnections();
2297 TestSlotDelegateHandler handlers;
2298 signals.SignalInt2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue );
2299 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2300 handlers.mIntReturn = 27;
2301 int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
2302 DALI_TEST_EQUALS( x, 27, TEST_LOCATION );
2303 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2304 DALI_TEST_EQUALS( handlers.mFloatParam1, 33.5f, TEST_LOCATION );
2305 DALI_TEST_EQUALS( handlers.mIntParam2, 5, TEST_LOCATION );
2307 signals.CheckNoConnections();
2310 TestSlotDelegateHandler handlers;
2311 signals.SignalFloat0().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid );
2312 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2313 handlers.mFloatReturn = 27.0f;
2314 float f = signals.EmitFloat0Signal();
2315 DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
2316 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2317 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
2318 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2320 signals.CheckNoConnections();
2323 TestSlotDelegateHandler handlers;
2324 signals.SignalFloat2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue );
2325 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2326 handlers.mFloatReturn = 27.0f;
2327 float f = signals.EmitFloat2VSignal(5, 33.0f);
2328 DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
2329 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2330 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2331 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
2333 signals.CheckNoConnections();
2336 TestSlotDelegateHandler handlers;
2337 signals.VoidSignalFloatValue3().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotFloatValue3 );
2338 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2339 signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
2340 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2341 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2342 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
2343 DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
2345 signals.CheckNoConnections();
2348 TestSlotDelegateHandler handlers;
2349 signals.FloatSignalFloatValue3().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValue3 );
2350 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2351 handlers.mFloatReturn = 27.0f;
2352 float returnValue = signals.EmitFloatSignalFloatValue3(5, 33.0f, 100.0f);
2353 DALI_TEST_EQUALS( returnValue, 27.0f, TEST_LOCATION );
2354 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2355 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2356 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
2357 DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
2359 signals.CheckNoConnections();
2363 int UtcDaliSignalSlotDelegateDestruction(void)
2365 // Test that signal disconnect works when slot-delegate is destroyed (goes out of scope)
2368 TestSignals::VoidRetNoParamSignal signal;
2370 DALI_TEST_CHECK( signal.Empty() );
2371 TestSlotDelegateHandler handler;
2372 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
2373 DALI_TEST_CHECK( ! signal.Empty() );
2375 // End of slot lifetime
2376 DALI_TEST_CHECK( signal.Empty() );
2378 // Signal emission should be a NOOP
2383 TestSignals::VoidRet1ValueParamSignal signal;
2385 DALI_TEST_CHECK( signal.Empty() );
2386 TestSlotDelegateHandler handler;
2387 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue );
2388 DALI_TEST_CHECK( ! signal.Empty() );
2390 // End of slot lifetime
2391 DALI_TEST_CHECK( signal.Empty() );
2393 // Signal emission should be a NOOP
2398 TestSignals::VoidRet1RefParamSignal signal;
2400 DALI_TEST_CHECK( signal.Empty() );
2401 TestSlotDelegateHandler handler;
2402 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef );
2403 DALI_TEST_CHECK( ! signal.Empty() );
2405 // End of slot lifetime
2406 DALI_TEST_CHECK( signal.Empty() );
2408 // Signal emission should be a NOOP
2410 signal.Emit( temp );
2414 TestSignals::VoidRet2ValueParamSignal signal;
2416 DALI_TEST_CHECK( signal.Empty() );
2417 TestSlotDelegateHandler handler;
2418 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue );
2419 DALI_TEST_CHECK( ! signal.Empty() );
2421 // End of slot lifetime
2422 DALI_TEST_CHECK( signal.Empty() );
2424 // Signal emission should be a NOOP
2425 signal.Emit( 1, 2 );
2429 TestSignals::BoolRet1ValueParamSignal signal;
2431 DALI_TEST_CHECK( signal.Empty() );
2432 TestSlotDelegateHandler handler;
2433 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue );
2434 DALI_TEST_CHECK( ! signal.Empty() );
2436 // End of slot lifetime
2437 DALI_TEST_CHECK( signal.Empty() );
2439 // Signal emission should be a NOOP
2440 bool blah = signal.Emit( 1.0f );
2441 DALI_TEST_CHECK( ! blah );
2445 TestSignals::BoolRet2ValueParamSignal signal;
2447 DALI_TEST_CHECK( signal.Empty() );
2448 TestSlotDelegateHandler handler;
2449 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue );
2450 DALI_TEST_CHECK( ! signal.Empty() );
2452 // End of slot lifetime
2453 DALI_TEST_CHECK( signal.Empty() );
2455 // Signal emission should be a NOOP
2456 bool blah = signal.Emit( 1.0f, 2 );
2457 DALI_TEST_CHECK( ! blah );
2461 TestSignals::IntRet2ValueParamSignal signal;
2463 DALI_TEST_CHECK( signal.Empty() );
2464 TestSlotDelegateHandler handler;
2465 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue );
2466 DALI_TEST_CHECK( ! signal.Empty() );
2468 // End of slot lifetime
2469 DALI_TEST_CHECK( signal.Empty() );
2471 // Signal emission should be a NOOP
2472 int blah = signal.Emit( 10.0f, 100 );
2473 DALI_TEST_CHECK( 0 == blah );
2477 TestSignals::FloatRet0ParamSignal signal;
2479 DALI_TEST_CHECK( signal.Empty() );
2480 TestSlotDelegateHandler handler;
2481 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid );
2482 DALI_TEST_CHECK( ! signal.Empty() );
2484 // End of slot lifetime
2485 DALI_TEST_CHECK( signal.Empty() );
2487 // Signal emission should be a NOOP
2488 float blah = signal.Emit();
2489 DALI_TEST_CHECK( 0.0f == blah );
2493 TestSignals::FloatRet2ValueParamSignal signal;
2495 DALI_TEST_CHECK( signal.Empty() );
2496 TestSlotDelegateHandler handler;
2497 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2498 DALI_TEST_CHECK( ! signal.Empty() );
2500 // End of slot lifetime
2501 DALI_TEST_CHECK( signal.Empty() );
2503 // Signal emission should be a NOOP
2504 float blah = signal.Emit( 3.0f, 4.0f );
2505 DALI_TEST_CHECK( 0.0f == blah );
2510 int UtcDaliSlotHandlerDisconnect(void)
2512 // Test that callbacks don't occur if a signal is disconnected before emission
2514 TestSignals signals;
2517 TestSlotDelegateHandler handlers;
2518 signals.SignalVoidNone().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
2519 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2520 signals.SignalVoidNone().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
2521 signals.EmitVoidSignalVoid();
2522 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2526 TestSlotDelegateHandler handlers;
2527 signals.SignalVoid1Ref().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
2528 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2530 handlers.mIntReturn = 5;
2531 signals.SignalVoid1Ref().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
2532 signals.EmitVoidSignalIntRef(r);
2533 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2534 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2535 DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
2539 TestSlotDelegateHandler handlers;
2540 signals.SignalVoid1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
2541 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2542 signals.SignalVoid1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
2543 signals.EmitVoidSignalIntValue(5);
2544 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2545 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2549 TestSlotDelegateHandler handlers;
2550 signals.SignalVoid2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
2551 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2552 signals.SignalVoid2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
2553 signals.EmitVoidSignalIntValueIntValue(5, 10);
2554 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2555 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2556 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
2560 TestSlotDelegateHandler handlers;
2561 signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2562 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2563 handlers.mBoolReturn = true;
2564 signals.SignalBool1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2565 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
2566 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2567 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
2571 TestSlotDelegateHandler handlers;
2572 signals.SignalBool2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2573 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2574 handlers.mBoolReturn = true;
2575 signals.SignalBool2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2576 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
2577 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2578 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
2579 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
2583 TestSlotDelegateHandler handlers;
2584 signals.SignalInt2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2585 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2586 handlers.mIntReturn = 27;
2587 signals.SignalInt2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2588 signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
2589 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2590 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2591 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2595 TestSlotDelegateHandler handlers;
2596 signals.SignalFloat0().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2597 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2598 handlers.mFloatReturn = 27.0f;
2599 signals.SignalFloat0().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2600 signals.EmitFloat0Signal();
2601 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2602 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
2603 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2607 TestSlotDelegateHandler handlers;
2608 signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2609 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2610 handlers.mFloatReturn = 27.0f;
2611 signals.SignalFloat2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2612 signals.EmitFloat2VSignal(5, 33.0f);
2613 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2614 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
2615 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );