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 SignalV2< void (TestButton&) > PanelDownSignal;
60 typedef SignalV2< 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 SignalV2<void ()> VoidRetNoParamSignal;
138 // Void return, 1 value parameter
139 typedef SignalV2<void (int)> VoidRet1ValueParamSignal;
141 // Void return, 1 reference parameter
142 typedef SignalV2< void (int&)> VoidRet1RefParamSignal;
144 // Void return, 2 value parameters
145 typedef SignalV2<void (int, int)> VoidRet2ValueParamSignal;
147 // bool return, 1 value parameter
148 typedef SignalV2< bool (float)> BoolRet1ValueParamSignal;
150 // bool return, 2 value parameter
151 typedef SignalV2<bool (float, int) > BoolRet2ValueParamSignal;
153 // int return, 2 value parameter
154 typedef SignalV2<int (float, int)> IntRet2ValueParamSignal;
156 // float return, 0 parameters
157 typedef SignalV2< float () > FloatRet0ParamSignal;
159 // float return, 2 value parameters
160 typedef SignalV2<float (float, float) > FloatRet2ValueParamSignal;
162 // void return, 3 value parameters
163 typedef SignalV2<void (float, float, float) > VoidSignalTypeFloatValue3;
165 // float return, 3 value parameters
166 typedef SignalV2<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()
828 // Notify signal since the slot has been destroyed
829 mSlotObserver->SlotDisconnected( mCallback );
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;
882 TestBasicConnectionTrackerInterface( const TestBasicConnectionTrackerInterface& ); ///< undefined copy constructor
883 TestBasicConnectionTrackerInterface& operator=( const TestBasicConnectionTrackerInterface& ); ///< undefined assignment operator
887 bool mCallbackHandled;
891 CallbackBase* mCallback; ///< callback, has ownership
892 SlotObserver* mSlotObserver; ///< a pointer to the slot observer (not owned)
896 bool wasStaticVoidCallbackVoidCalled = false;
897 bool wasStaticFloatCallbackVoidCalled = false;
898 bool wasStaticVoidCallbackIntValueCalled = false;
899 int staticIntValue = 0;
900 bool wasStaticFloatCallbackFloatValueFloatValueCalled = false;
901 float staticFloatValue1 = 0.0f;
902 float staticFloatValue2 = 0.0f;
904 static void StaticVoidCallbackVoid()
906 wasStaticVoidCallbackVoidCalled = true;
909 static float StaticFloatCallbackVoid()
911 wasStaticFloatCallbackVoidCalled = true;
915 static void StaticVoidCallbackIntValue( int value )
917 wasStaticVoidCallbackIntValueCalled = true;
918 staticIntValue = value;
921 static float StaticFloatCallbackFloatValueFloatValue( float value1, float value2 )
923 wasStaticFloatCallbackFloatValueFloatValueCalled = true;
924 staticFloatValue1 = value1;
925 staticFloatValue2 = value2;
926 return value1 + value2;
932 int UtcDaliSignalEmptyCheck(void)
934 // Test that Empty() check works before & after signal connection
937 TestSignals::VoidRetNoParamSignal signal;
938 DALI_TEST_CHECK( signal.Empty() );
939 TestSlotHandler handler;
940 signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
941 DALI_TEST_CHECK( ! signal.Empty() );
945 TestSignals::VoidRet1ValueParamSignal signal;
946 DALI_TEST_CHECK( signal.Empty() );
947 TestSlotHandler handler;
948 signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValue );
949 DALI_TEST_CHECK( ! signal.Empty() );
953 TestSignals::VoidRet1RefParamSignal signal;
954 DALI_TEST_CHECK( signal.Empty() );
955 TestSlotHandler handler;
956 signal.Connect( &handler, &TestSlotHandler::VoidSlotIntRef );
957 DALI_TEST_CHECK( ! signal.Empty() );
961 TestSignals::VoidRet2ValueParamSignal signal;
962 DALI_TEST_CHECK( signal.Empty() );
963 TestSlotHandler handler;
964 signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValueIntValue );
965 DALI_TEST_CHECK( ! signal.Empty() );
969 TestSignals::BoolRet1ValueParamSignal signal;
970 DALI_TEST_CHECK( signal.Empty() );
971 TestSlotHandler handler;
972 signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValue );
973 DALI_TEST_CHECK( ! signal.Empty() );
977 TestSignals::BoolRet2ValueParamSignal signal;
978 DALI_TEST_CHECK( signal.Empty() );
979 TestSlotHandler handler;
980 signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValueIntValue );
981 DALI_TEST_CHECK( ! signal.Empty() );
985 TestSignals::IntRet2ValueParamSignal signal;
986 DALI_TEST_CHECK( signal.Empty() );
987 TestSlotHandler handler;
988 signal.Connect( &handler, &TestSlotHandler::IntSlotFloatValueIntValue );
989 DALI_TEST_CHECK( ! signal.Empty() );
993 TestSignals::FloatRet0ParamSignal signal;
994 DALI_TEST_CHECK( signal.Empty() );
995 TestSlotHandler handler;
996 signal.Connect( &handler, &TestSlotHandler::FloatSlotVoid );
997 DALI_TEST_CHECK( ! signal.Empty() );
1001 TestSignals::FloatRet2ValueParamSignal signal;
1002 DALI_TEST_CHECK( signal.Empty() );
1003 TestSlotHandler handler;
1004 signal.Connect(&handler, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1005 DALI_TEST_CHECK( ! signal.Empty() );
1010 int UtcDaliSignalEmptyCheckSlotDestruction(void)
1012 // Test that signal disconnect works when slot is destroyed (goes out of scope)
1015 TestSignals::VoidRetNoParamSignal signal;
1017 DALI_TEST_CHECK( signal.Empty() );
1018 TestSlotHandler handler;
1019 signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
1020 DALI_TEST_CHECK( ! signal.Empty() );
1022 // End of slot lifetime
1023 DALI_TEST_CHECK( signal.Empty() );
1025 // Signal emission should be a NOOP
1030 TestSignals::VoidRet1ValueParamSignal signal;
1032 DALI_TEST_CHECK( signal.Empty() );
1033 TestSlotHandler handler;
1034 signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValue );
1035 DALI_TEST_CHECK( ! signal.Empty() );
1037 // End of slot lifetime
1038 DALI_TEST_CHECK( signal.Empty() );
1040 // Signal emission should be a NOOP
1045 TestSignals::VoidRet1RefParamSignal signal;
1047 DALI_TEST_CHECK( signal.Empty() );
1048 TestSlotHandler handler;
1049 signal.Connect( &handler, &TestSlotHandler::VoidSlotIntRef );
1050 DALI_TEST_CHECK( ! signal.Empty() );
1052 // End of slot lifetime
1053 DALI_TEST_CHECK( signal.Empty() );
1055 // Signal emission should be a NOOP
1057 signal.Emit( temp );
1061 TestSignals::VoidRet2ValueParamSignal signal;
1063 DALI_TEST_CHECK( signal.Empty() );
1064 TestSlotHandler handler;
1065 signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValueIntValue );
1066 DALI_TEST_CHECK( ! signal.Empty() );
1068 // End of slot lifetime
1069 DALI_TEST_CHECK( signal.Empty() );
1071 // Signal emission should be a NOOP
1072 signal.Emit( 1, 2 );
1076 TestSignals::BoolRet1ValueParamSignal signal;
1078 DALI_TEST_CHECK( signal.Empty() );
1079 TestSlotHandler handler;
1080 signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValue );
1081 DALI_TEST_CHECK( ! signal.Empty() );
1083 // End of slot lifetime
1084 DALI_TEST_CHECK( signal.Empty() );
1086 // Signal emission should be a NOOP
1087 bool blah = signal.Emit( 1.0f );
1088 DALI_TEST_CHECK( ! blah );
1092 TestSignals::BoolRet2ValueParamSignal signal;
1094 DALI_TEST_CHECK( signal.Empty() );
1095 TestSlotHandler handler;
1096 signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValueIntValue );
1097 DALI_TEST_CHECK( ! signal.Empty() );
1099 // End of slot lifetime
1100 DALI_TEST_CHECK( signal.Empty() );
1102 // Signal emission should be a NOOP
1103 bool blah = signal.Emit( 1.0f, 2 );
1104 DALI_TEST_CHECK( ! blah );
1108 TestSignals::IntRet2ValueParamSignal signal;
1110 DALI_TEST_CHECK( signal.Empty() );
1111 TestSlotHandler handler;
1112 signal.Connect( &handler, &TestSlotHandler::IntSlotFloatValueIntValue );
1113 DALI_TEST_CHECK( ! signal.Empty() );
1115 // End of slot lifetime
1116 DALI_TEST_CHECK( signal.Empty() );
1118 // Signal emission should be a NOOP
1119 int blah = signal.Emit( 10.0f, 100 );
1120 DALI_TEST_CHECK( 0 == blah );
1124 TestSignals::FloatRet0ParamSignal signal;
1126 DALI_TEST_CHECK( signal.Empty() );
1127 TestSlotHandler handler;
1128 signal.Connect( &handler, &TestSlotHandler::FloatSlotVoid );
1129 DALI_TEST_CHECK( ! signal.Empty() );
1131 // End of slot lifetime
1132 DALI_TEST_CHECK( signal.Empty() );
1134 // Signal emission should be a NOOP
1135 float blah = signal.Emit();
1136 DALI_TEST_CHECK( 0.0f == blah );
1140 TestSignals::FloatRet2ValueParamSignal signal;
1142 DALI_TEST_CHECK( signal.Empty() );
1143 TestSlotHandler handler;
1144 signal.Connect(&handler, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1145 DALI_TEST_CHECK( ! signal.Empty() );
1147 // End of slot lifetime
1148 DALI_TEST_CHECK( signal.Empty() );
1150 // Signal emission should be a NOOP
1151 float blah = signal.Emit( 3.0f, 4.0f );
1152 DALI_TEST_CHECK( 0.0f == blah );
1157 // Positive test case for a method
1158 int UtcDaliSignalConnectAndEmit(void)
1160 // Test basic signal emission for each slot type
1162 TestSignals signals;
1165 TestSlotHandler handlers;
1166 signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
1167 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1168 signals.EmitVoidSignalVoid();
1169 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1171 // Test double emission
1172 handlers.mHandled = false;
1173 signals.EmitVoidSignalVoid();
1174 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1176 signals.CheckNoConnections();
1179 TestSlotHandler handlers;
1180 signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1181 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1183 signals.EmitVoidSignalIntRef(x);
1184 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1185 DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
1187 signals.CheckNoConnections();
1190 TestSlotHandler handlers;
1191 signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
1192 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1193 signals.EmitVoidSignalIntValue(5);
1194 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1195 DALI_TEST_EQUALS( handlers.mIntParam1, 5, TEST_LOCATION );
1197 signals.CheckNoConnections();
1200 TestSlotHandler handlers;
1201 signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
1202 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1203 signals.EmitVoidSignalIntValueIntValue(6, 7);
1204 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1205 DALI_TEST_EQUALS( handlers.mIntParam1, 6, TEST_LOCATION );
1206 DALI_TEST_EQUALS( handlers.mIntParam2, 7, TEST_LOCATION );
1208 signals.CheckNoConnections();
1211 TestSlotHandler handlers;
1212 signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
1213 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1215 handlers.mBoolReturn = true;
1216 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION );
1217 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1218 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1220 // repeat with opposite return value
1221 handlers.mBoolReturn = false;
1222 handlers.mHandled = false;
1223 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION );
1224 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1225 DALI_TEST_EQUALS( handlers.mFloatParam1, 6.0f, TEST_LOCATION );
1227 signals.CheckNoConnections();
1230 TestSlotHandler handlers;
1231 signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
1232 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1233 handlers.mBoolReturn = true;
1234 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION );
1235 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1236 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1237 DALI_TEST_EQUALS( handlers.mIntParam2, 10, TEST_LOCATION );
1239 signals.CheckNoConnections();
1242 TestSlotHandler handlers;
1243 signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
1244 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1245 handlers.mIntReturn = 27;
1246 int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
1247 DALI_TEST_EQUALS( x, 27, TEST_LOCATION );
1248 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1249 DALI_TEST_EQUALS( handlers.mFloatParam1, 33.5f, TEST_LOCATION );
1250 DALI_TEST_EQUALS( handlers.mIntParam2, 5, TEST_LOCATION );
1252 signals.CheckNoConnections();
1255 TestSlotHandler handlers;
1256 signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
1257 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1258 handlers.mFloatReturn = 27.0f;
1259 float f = signals.EmitFloat0Signal();
1260 DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
1261 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1262 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1263 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1265 signals.CheckNoConnections();
1268 TestSlotHandler handlers;
1269 signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1270 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1271 handlers.mFloatReturn = 27.0f;
1272 float f = signals.EmitFloat2VSignal(5, 33.0f);
1273 DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
1274 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1275 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1276 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1278 signals.CheckNoConnections();
1281 TestSlotHandler handlers;
1282 signals.VoidSignalFloatValue3().Connect(&handlers, &TestSlotHandler::VoidSlotFloatValue3);
1283 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1284 signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
1285 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1286 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1287 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1288 DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
1290 signals.CheckNoConnections();
1293 TestSlotHandler handlers;
1294 signals.FloatSignalFloatValue3().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValue3);
1295 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1296 handlers.mFloatReturn = 27.0f;
1297 float returnValue = signals.EmitFloatSignalFloatValue3(5, 33.0f, 100.0f);
1298 DALI_TEST_EQUALS( returnValue, 27.0f, TEST_LOCATION );
1299 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1300 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1301 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1302 DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
1304 signals.CheckNoConnections();
1308 int UtcDaliSignalDisconnect(void)
1310 // Test that callbacks don't occur if a signal is disconnected before emission
1312 TestSignals signals;
1315 TestSlotHandler handlers;
1316 signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
1317 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1318 signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
1319 signals.EmitVoidSignalVoid();
1320 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1324 TestSlotHandler handlers;
1325 signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1326 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1328 handlers.mIntReturn = 5;
1329 signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1330 signals.EmitVoidSignalIntRef(r);
1331 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1332 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1333 DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
1337 TestSlotHandler handlers;
1338 signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
1339 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1340 signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
1341 signals.EmitVoidSignalIntValue(5);
1342 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1343 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1347 TestSlotHandler handlers;
1348 signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
1349 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1350 signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
1351 signals.EmitVoidSignalIntValueIntValue(5, 10);
1352 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1353 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1354 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
1358 TestSlotHandler handlers;
1359 signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
1360 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1361 handlers.mBoolReturn = true;
1362 signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
1363 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
1364 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1365 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1369 TestSlotHandler handlers;
1370 signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
1371 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1372 handlers.mBoolReturn = true;
1373 signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
1374 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
1375 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1376 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1377 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
1381 TestSlotHandler handlers;
1382 signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
1383 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1384 handlers.mIntReturn = 27;
1385 signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
1386 signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
1387 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1388 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1389 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1393 TestSlotHandler handlers;
1394 signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
1395 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1396 handlers.mFloatReturn = 27.0f;
1397 signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
1398 signals.EmitFloat0Signal();
1399 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1400 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
1401 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1405 TestSlotHandler handlers;
1406 signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1407 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1408 handlers.mFloatReturn = 27.0f;
1409 signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1410 signals.EmitFloat2VSignal(5, 33.0f);
1411 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1412 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
1413 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1418 int UtcDaliSignalDisconnect2(void)
1420 // Test that nothing happens when attempting to disconnect an unconnected slot
1422 TestSignals signals;
1424 TestSlotHandler handlers;
1425 signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
1426 signals.EmitVoidSignalVoid();
1427 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1431 TestSlotHandler handlers;
1433 signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1434 signals.EmitVoidSignalIntRef(r);
1435 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1436 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1437 DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
1441 TestSlotHandler handlers;
1442 signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
1443 signals.EmitVoidSignalIntValue(5);
1444 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1445 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1449 TestSlotHandler handlers;
1450 signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
1451 signals.EmitVoidSignalIntValueIntValue(5, 10);
1452 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1453 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1454 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
1458 TestSlotHandler handlers;
1459 handlers.mBoolReturn = true;
1460 signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
1461 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
1462 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1463 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1467 TestSlotHandler handlers;
1468 handlers.mBoolReturn = true;
1469 signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
1470 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
1471 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1472 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1473 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
1477 TestSlotHandler handlers;
1478 handlers.mIntReturn = 27;
1479 signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
1480 signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
1481 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1482 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1483 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1487 TestSlotHandler handlers;
1488 handlers.mFloatReturn = 27.0f;
1489 signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1490 signals.EmitFloat2VSignal(5, 33.0f);
1491 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1492 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
1493 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1497 TestSlotHandler handlers;
1498 handlers.mFloatReturn = 27.0f;
1499 signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
1500 signals.EmitFloat0Signal();
1501 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1502 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
1503 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1508 int UtcDaliSignalDisconnect3(void)
1510 // Test that callbacks stop after a signal is disconnected
1512 TestSignals signals;
1515 TestSlotHandler handlers;
1516 signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
1517 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1520 signals.EmitVoidSignalVoid();
1521 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1523 // Disconnect and emit again
1524 handlers.mHandled = false;
1525 signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
1526 signals.EmitVoidSignalVoid();
1527 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1531 TestSlotHandler handlers;
1532 signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1533 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1537 signals.EmitVoidSignalIntRef(r);
1538 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1539 DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
1541 // Disconnect and emit again
1542 handlers.mHandled = false;
1543 handlers.mIntParam1 = 0;
1544 signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1545 signals.EmitVoidSignalIntRef(r);
1546 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1547 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1548 DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
1553 int UtcDaliSignalCustomConnectionTracker(void)
1555 // Test slot destruction
1557 TestSignals::VoidRetNoParamSignal signal;
1559 DALI_TEST_CHECK( signal.Empty() );
1560 TestBasicConnectionTrackerInterface customTracker;
1561 signal.Connect( &customTracker, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
1562 DALI_TEST_CHECK( ! signal.Empty() );
1564 // End of slot lifetime
1565 DALI_TEST_CHECK( signal.Empty() );
1567 // Signal emission should be a NOOP
1571 TestBasicConnectionTrackerInterface customTracker2;
1573 // Test signal emission & destruction
1575 TestSignals::VoidRetNoParamSignal signal;
1576 DALI_TEST_CHECK( signal.Empty() );
1577 DALI_TEST_EQUALS( 0u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1579 signal.Connect( &customTracker2, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
1580 DALI_TEST_CHECK( ! signal.Empty() );
1581 DALI_TEST_EQUALS( 1u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1583 DALI_TEST_EQUALS( customTracker2.mCallbackHandled, false, TEST_LOCATION );
1585 DALI_TEST_EQUALS( customTracker2.mCallbackHandled, true, TEST_LOCATION );
1587 DALI_TEST_EQUALS( 0u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1591 int UtcDaliSignalMultipleConnections(void)
1593 // Test that multiple callbacks can be connected to the same signal
1595 TestSignals signals;
1598 TestSlotHandler handler1;
1599 signals.SignalVoidNone().Connect( &handler1, &TestSlotHandler::VoidSlotVoid );
1600 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1602 TestSlotHandler handler2;
1603 signals.SignalVoidNone().Connect( &handler2, &TestSlotHandler::VoidSlotVoid );
1604 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1606 signals.EmitVoidSignalVoid();
1607 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1608 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1610 // Remove first connection and repeat
1613 signals.SignalVoidNone().Disconnect( &handler1, &TestSlotHandler::VoidSlotVoid );
1615 signals.EmitVoidSignalVoid();
1616 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1617 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1621 TestSlotHandler handler1;
1622 signals.SignalVoid1Ref().Connect( &handler1, &TestSlotHandler::VoidSlotIntRef );
1623 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1625 TestSlotHandler handler2;
1626 signals.SignalVoid1Ref().Connect( &handler2, &TestSlotHandler::VoidSlotIntRef );
1627 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1630 signals.EmitVoidSignalIntRef(x);
1631 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1632 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1633 DALI_TEST_EQUALS( handler1.mIntParam1, 7, TEST_LOCATION );
1634 DALI_TEST_EQUALS( handler2.mIntParam1, 7, TEST_LOCATION );
1636 // Remove second connection and repeat
1640 signals.SignalVoid1Ref().Disconnect( &handler2, &TestSlotHandler::VoidSlotIntRef );
1642 signals.EmitVoidSignalIntRef(x);
1643 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1644 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1645 DALI_TEST_EQUALS( handler1.mIntParam1, 8, TEST_LOCATION );
1646 DALI_TEST_EQUALS( handler2.mIntParam1, 0, TEST_LOCATION );
1650 TestSlotHandler handler1;
1651 signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1652 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1654 TestSlotHandler handler2;
1655 signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1656 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1658 TestSlotHandler handler3;
1659 signals.SignalVoid1Value().Connect( &handler3, &TestSlotHandler::VoidSlotIntValue );
1660 DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
1662 signals.EmitVoidSignalIntValue( 5 );
1663 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1664 DALI_TEST_EQUALS( handler1.mIntParam1, 5, TEST_LOCATION );
1665 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1666 DALI_TEST_EQUALS( handler2.mIntParam1, 5, TEST_LOCATION );
1667 DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1668 DALI_TEST_EQUALS( handler3.mIntParam1, 5, TEST_LOCATION );
1670 // Remove middle connection and repeat
1674 signals.SignalVoid1Value().Disconnect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1676 signals.EmitVoidSignalIntValue( 6 );
1677 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1678 DALI_TEST_EQUALS( handler1.mIntParam1, 6, TEST_LOCATION );
1679 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1680 DALI_TEST_EQUALS( handler2.mIntParam1, 0, TEST_LOCATION );
1681 DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1682 DALI_TEST_EQUALS( handler3.mIntParam1, 6, TEST_LOCATION );
1685 // Test that multiple callbacks are disconnected when a signal is destroyed
1687 TestSlotHandler handler4;
1688 TestSlotHandler handler5;
1689 TestSlotHandler handler6;
1692 TestSignals::VoidRet1ValueParamSignal tempSignal;
1694 DALI_TEST_EQUALS( handler4.GetConnectionCount(), 0u, TEST_LOCATION );
1695 DALI_TEST_EQUALS( handler5.GetConnectionCount(), 0u, TEST_LOCATION );
1696 DALI_TEST_EQUALS( handler6.GetConnectionCount(), 0u, TEST_LOCATION );
1698 tempSignal.Connect( &handler4, &TestSlotHandler::VoidSlotIntValue );
1699 tempSignal.Connect( &handler5, &TestSlotHandler::VoidSlotIntValue );
1700 tempSignal.Connect( &handler6, &TestSlotHandler::VoidSlotIntValue );
1702 DALI_TEST_EQUALS( handler4.GetConnectionCount(), 1u, TEST_LOCATION );
1703 DALI_TEST_EQUALS( handler5.GetConnectionCount(), 1u, TEST_LOCATION );
1704 DALI_TEST_EQUALS( handler6.GetConnectionCount(), 1u, TEST_LOCATION );
1706 // End of tempSignal lifetime
1708 DALI_TEST_EQUALS( handler4.GetConnectionCount(), 0u, TEST_LOCATION );
1709 DALI_TEST_EQUALS( handler5.GetConnectionCount(), 0u, TEST_LOCATION );
1710 DALI_TEST_EQUALS( handler6.GetConnectionCount(), 0u, TEST_LOCATION );
1714 int UtcDaliSignalMultipleConnections2(void)
1716 TestSignals signals;
1718 // Test that connecting the same callback twice is a NOOP
1720 TestSlotHandler handler1;
1722 // Note the double connection is intentional
1723 signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1724 signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1725 DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1727 signals.EmitVoidSignalIntValue( 6 );
1728 DALI_TEST_EQUALS( handler1.mHandledCount, 1, TEST_LOCATION );
1729 DALI_TEST_EQUALS( handler1.mIntParam1, 6, TEST_LOCATION );
1731 // Calling Disconnect once should be enough
1732 signals.SignalVoid1Value().Disconnect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1733 DALI_TEST_CHECK( signals.SignalVoid1Value().Empty() );
1734 handler1.mIntParam1 = 0;
1736 signals.EmitVoidSignalIntValue( 7 );
1737 DALI_TEST_EQUALS( handler1.mHandledCount, 1/*not incremented since last check*/, TEST_LOCATION );
1738 DALI_TEST_EQUALS( handler1.mIntParam1, 0, TEST_LOCATION );
1741 // Test automatic disconnect after multiple Connect() calls
1743 TestSlotHandler handler2;
1744 signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1745 signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1747 TestSlotHandler handler3;
1748 signals.SignalBool1Value().Connect( &handler3, &TestSlotHandler::BoolSlotFloatValue );
1749 signals.SignalBool1Value().Connect( &handler3, &TestSlotHandler::BoolSlotFloatValue );
1751 DALI_TEST_EQUALS( handler2.mHandledCount, 0, TEST_LOCATION );
1752 DALI_TEST_EQUALS( handler3.mHandledCount, 0, TEST_LOCATION );
1753 DALI_TEST_CHECK( ! signals.SignalVoid1Value().Empty() );
1754 DALI_TEST_CHECK( ! signals.SignalBool1Value().Empty() );
1756 DALI_TEST_CHECK( signals.SignalVoid1Value().Empty() );
1757 DALI_TEST_CHECK( signals.SignalBool1Value().Empty() );
1760 signals.EmitVoidSignalIntValue( 1 );
1761 signals.EmitBoolSignalFloatValue( 1.0f );
1763 // Test that connecting the same callback 10 times is a NOOP
1764 TestSlotHandler handler4;
1765 DALI_TEST_EQUALS( handler4.mHandledCount, 0, TEST_LOCATION );
1766 DALI_TEST_EQUALS( handler4.mFloatParam1, 0.0f, TEST_LOCATION );
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 );
1777 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1779 signals.EmitBoolSignalFloatValue( 2.0f );
1780 DALI_TEST_EQUALS( handler4.mHandledCount, 1, TEST_LOCATION );
1781 DALI_TEST_EQUALS( handler4.mFloatParam1, 2.0f, TEST_LOCATION );
1783 // Calling Disconnect once should be enough
1784 signals.SignalBool1Value().Disconnect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1785 DALI_TEST_CHECK( signals.SignalBool1Value().Empty() );
1787 signals.EmitBoolSignalFloatValue( 3.0f );
1788 DALI_TEST_EQUALS( handler4.mHandledCount, 1/*not incremented since last check*/, TEST_LOCATION );
1789 DALI_TEST_EQUALS( handler4.mFloatParam1, 2.0f, TEST_LOCATION );
1793 int UtcDaliSignalMultipleConnections3(void)
1795 TestSignals signals;
1797 // Test connecting two difference callbacks for the same ConnectionTracker
1799 TestSlotHandler handler1;
1802 TestSignals::VoidRet1ValueParamSignal tempSignal;
1804 DALI_TEST_EQUALS( handler1.GetConnectionCount(), 0u, TEST_LOCATION );
1805 DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1806 DALI_TEST_EQUALS( handler1.mIntParam1, 0, TEST_LOCATION );
1808 // Note that the duplicate connection is deliberate
1809 tempSignal.Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1810 tempSignal.Connect( &handler1, &TestSlotHandler::VoidDuplicateSlotIntValue );
1812 DALI_TEST_EQUALS( handler1.GetConnectionCount(), 2u, TEST_LOCATION );
1813 DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1815 tempSignal.Emit( 10 );
1817 DALI_TEST_EQUALS( handler1.mHandledCount, 2, TEST_LOCATION );
1818 DALI_TEST_EQUALS( handler1.mIntParam1, 10, TEST_LOCATION );
1819 DALI_TEST_EQUALS( handler1.mIntParam2, 10, TEST_LOCATION );
1821 // End of tempSignal lifetime
1823 DALI_TEST_EQUALS( handler1.GetConnectionCount(), 0u, TEST_LOCATION );
1828 int UtcDaliSignalDisconnectStatic(void)
1833 TestSignals::VoidRetNoParamSignal signal;
1834 DALI_TEST_CHECK( signal.Empty() );
1836 signal.Connect( StaticVoidCallbackVoid );
1837 DALI_TEST_CHECK( ! signal.Empty() );
1839 wasStaticVoidCallbackVoidCalled = false;
1841 DALI_TEST_EQUALS( wasStaticVoidCallbackVoidCalled, true, TEST_LOCATION );
1843 signal.Disconnect( StaticVoidCallbackVoid );
1844 DALI_TEST_CHECK( signal.Empty() );
1846 wasStaticVoidCallbackVoidCalled = false;
1848 DALI_TEST_EQUALS( wasStaticVoidCallbackVoidCalled, false, TEST_LOCATION );
1854 TestSignals::FloatRet0ParamSignal signal;
1855 DALI_TEST_CHECK( signal.Empty() );
1857 signal.Connect( StaticFloatCallbackVoid );
1858 DALI_TEST_CHECK( ! signal.Empty() );
1860 wasStaticFloatCallbackVoidCalled = false;
1861 float result = signal.Emit();
1862 DALI_TEST_EQUALS( wasStaticFloatCallbackVoidCalled, true, TEST_LOCATION );
1863 DALI_TEST_EQUALS( result, 7.0f, TEST_LOCATION );
1865 signal.Disconnect( StaticFloatCallbackVoid );
1866 DALI_TEST_CHECK( signal.Empty() );
1868 wasStaticFloatCallbackVoidCalled = false;
1869 result = signal.Emit();
1870 DALI_TEST_EQUALS( wasStaticFloatCallbackVoidCalled, false, TEST_LOCATION );
1871 DALI_TEST_EQUALS( result, 0.0f, TEST_LOCATION );
1877 TestSignals::VoidRet1ValueParamSignal signal;
1878 DALI_TEST_CHECK( signal.Empty() );
1880 signal.Connect( StaticVoidCallbackIntValue );
1881 DALI_TEST_CHECK( ! signal.Empty() );
1883 wasStaticVoidCallbackIntValueCalled = false;
1886 DALI_TEST_EQUALS( wasStaticVoidCallbackIntValueCalled, true, TEST_LOCATION );
1887 DALI_TEST_EQUALS( staticIntValue, 10, TEST_LOCATION );
1889 signal.Disconnect( StaticVoidCallbackIntValue );
1890 DALI_TEST_CHECK( signal.Empty() );
1892 wasStaticVoidCallbackIntValueCalled = false;
1895 DALI_TEST_EQUALS( wasStaticVoidCallbackIntValueCalled, false, TEST_LOCATION );
1896 DALI_TEST_EQUALS( staticIntValue, 0, TEST_LOCATION );
1899 // float Func( float, float )
1902 TestSignals::FloatRet2ValueParamSignal signal;
1903 DALI_TEST_CHECK( signal.Empty() );
1905 signal.Connect( StaticFloatCallbackFloatValueFloatValue );
1906 DALI_TEST_CHECK( ! signal.Empty() );
1908 wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1909 staticFloatValue1 = 0.0f;
1910 staticFloatValue2 = 0.0f;
1911 float result = signal.Emit( 5.0f, 6.0f );
1912 DALI_TEST_EQUALS( wasStaticFloatCallbackFloatValueFloatValueCalled, true, TEST_LOCATION );
1913 DALI_TEST_EQUALS( staticFloatValue1, 5.0f, TEST_LOCATION );
1914 DALI_TEST_EQUALS( staticFloatValue2, 6.0f, TEST_LOCATION );
1915 DALI_TEST_EQUALS( result, 5.0f+6.0f, TEST_LOCATION );
1917 signal.Disconnect( StaticFloatCallbackFloatValueFloatValue );
1918 DALI_TEST_CHECK( signal.Empty() );
1920 wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1921 staticFloatValue1 = 0.0f;
1922 staticFloatValue2 = 0.0f;
1923 result = signal.Emit( 7.0f, 8.0f );
1924 DALI_TEST_EQUALS( wasStaticFloatCallbackFloatValueFloatValueCalled, false, TEST_LOCATION );
1925 DALI_TEST_EQUALS( staticFloatValue1, 0.0f, TEST_LOCATION );
1926 DALI_TEST_EQUALS( staticFloatValue2, 0.0f, TEST_LOCATION );
1927 DALI_TEST_EQUALS( result, 0.0f, TEST_LOCATION );
1932 int UtcDaliSignalDisconnectDuringCallback(void)
1934 // Test disconnection during each callback
1936 TestSignals::VoidRetNoParamSignal signal;
1937 DALI_TEST_CHECK( signal.Empty() );
1939 TestSlotDisconnector handler1;
1940 handler1.VoidConnectVoid( signal );
1941 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1942 DALI_TEST_CHECK( ! signal.Empty() );
1945 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1946 DALI_TEST_CHECK( signal.Empty() );
1948 // Repeat with 2 callbacks
1950 handler1.mHandled = false;
1952 TestSlotDisconnector handler2;
1953 handler1.VoidConnectVoid( signal );
1954 handler2.VoidConnectVoid( signal );
1955 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1956 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1957 DALI_TEST_CHECK( ! signal.Empty() );
1960 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1961 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1962 DALI_TEST_CHECK( signal.Empty() );
1964 // Repeat with no callbacks
1966 handler1.mHandled = false;
1967 handler2.mHandled = false;
1970 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1971 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1973 // Repeat with 3 callbacks
1975 TestSlotDisconnector handler3;
1976 handler1.VoidConnectVoid( signal );
1977 handler2.VoidConnectVoid( signal );
1978 handler3.VoidConnectVoid( signal );
1979 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1980 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1981 DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
1982 DALI_TEST_CHECK( ! signal.Empty() );
1985 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1986 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1987 DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1988 DALI_TEST_CHECK( signal.Empty() );
1990 // Repeat with no callbacks
1992 handler1.mHandled = false;
1993 handler2.mHandled = false;
1994 handler3.mHandled = false;
1997 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1998 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1999 DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
2003 int UtcDaliSignalDisconnectDuringCallback2(void)
2005 // Test disconnection of some (but not all) callbacks during sigmal emission
2007 TestSignals::VoidRetNoParamSignal signal;
2008 DALI_TEST_CHECK( signal.Empty() );
2010 TestSlotMultiDisconnector handler;
2011 handler.ConnectAll( signal );
2012 DALI_TEST_EQUALS( handler.mSlotHandled[0], false, TEST_LOCATION );
2013 DALI_TEST_EQUALS( handler.mSlotHandled[1], false, TEST_LOCATION );
2014 DALI_TEST_EQUALS( handler.mSlotHandled[2], false, TEST_LOCATION );
2015 DALI_TEST_EQUALS( handler.mSlotHandled[3], false, TEST_LOCATION );
2016 DALI_TEST_EQUALS( handler.mSlotHandled[4], false, TEST_LOCATION );
2017 DALI_TEST_EQUALS( handler.mSlotHandled[5], false, TEST_LOCATION );
2018 DALI_TEST_EQUALS( handler.mSlotHandled[6], false, TEST_LOCATION );
2019 DALI_TEST_EQUALS( handler.mSlotHandled[7], false, TEST_LOCATION );
2020 DALI_TEST_EQUALS( handler.mSlotHandled[8], false, TEST_LOCATION );
2021 DALI_TEST_EQUALS( handler.mSlotHandled[9], false, TEST_LOCATION );
2022 DALI_TEST_CHECK( ! signal.Empty() );
2026 // Slots 5, 7, & 9 should be disconnected before being called
2027 DALI_TEST_EQUALS( handler.mSlotHandled[0], true, TEST_LOCATION );
2028 DALI_TEST_EQUALS( handler.mSlotHandled[1], true, TEST_LOCATION );
2029 DALI_TEST_EQUALS( handler.mSlotHandled[2], true, TEST_LOCATION );
2030 DALI_TEST_EQUALS( handler.mSlotHandled[3], true, TEST_LOCATION );
2031 DALI_TEST_EQUALS( handler.mSlotHandled[4], true, TEST_LOCATION );
2032 DALI_TEST_EQUALS( handler.mSlotHandled[5], false, TEST_LOCATION );
2033 DALI_TEST_EQUALS( handler.mSlotHandled[6], true, TEST_LOCATION );
2034 DALI_TEST_EQUALS( handler.mSlotHandled[7], false, TEST_LOCATION );
2035 DALI_TEST_EQUALS( handler.mSlotHandled[8], true, TEST_LOCATION );
2036 DALI_TEST_EQUALS( handler.mSlotHandled[9], false, TEST_LOCATION );
2037 DALI_TEST_CHECK( ! signal.Empty() );
2039 // Odd slots are disconnected
2040 DALI_TEST_EQUALS( handler.GetConnectionCount(), 5u, TEST_LOCATION );
2044 int UtcDaliSignalEmitDuringCallback(void)
2046 TestApplication app; // Create core for debug logging
2048 TestSignals::VoidRetNoParamSignal signal;
2049 DALI_TEST_CHECK( signal.Empty() );
2051 TestEmitDuringCallback handler1;
2052 handler1.VoidConnectVoid( signal );
2054 // Test that this does not result in an infinite loop!
2059 int UtcDaliSignalTestApp01(void)
2061 // Test 1 signal connected to 1 Slot.
2062 // Signal dies first.
2064 TestButton* button = new TestButton(1);
2066 button->DownSignal().Connect(&app,&TestApp::OnButtonPress);
2068 // check we have both the button, and the app have 1 connection
2069 DALI_TEST_EQUALS( app.GetConnectionCount(), 1u, TEST_LOCATION );
2070 DALI_TEST_EQUALS( button->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2072 delete button; // should automatically destroy the connection
2074 // check we have a 0 connections
2075 DALI_TEST_EQUALS( app.GetConnectionCount(), 0u, TEST_LOCATION );
2080 int UtcDaliSignalTestApp02(void)
2082 // Test 1 signal connected to 1 Slot.
2083 // Slot owning object dies first.
2085 TestButton button(1);
2086 TestApp *app = new TestApp;
2087 button.DownSignal().Connect( app, &TestApp::OnButtonPress);
2089 // check we have a 1 connection
2090 DALI_TEST_EQUALS( app->GetConnectionCount(), 1u, TEST_LOCATION );
2091 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2093 delete app; // should automatically destroy the connection
2095 // check we have a 0 connections
2096 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION );
2100 int UtcDaliSignalTestApp03(void)
2102 // Test 1 Signal connect to 2 slots
2103 // 1 of the slot owners dies. Then the second slot owner dies
2105 TestButton button(1);
2106 TestApp *app1 = new TestApp;
2107 TestApp *app2 = new TestApp;
2109 button.DownSignal().Connect( app1, &TestApp::OnButtonPress);
2110 button.DownSignal().Connect( app2, &TestApp::OnButtonPress);
2112 // check we have a 2 connections to the signal
2113 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 2u, TEST_LOCATION );
2115 // kill the first slot
2116 delete app1; // should automatically destroy the connection
2118 // check we have 1 connection left
2119 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2121 button.Press(); // emit the signal (to ensure it doesn't seg fault)
2123 // kill the second slot
2124 delete app2; // should automatically destroy the connection
2126 // check we have 1 connection left
2127 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION );
2132 int UtcDaliSignalTestApp04(void)
2134 // Test 1 Signal connected to 2 slots (with different owners)
2135 // The Signal dies, check the 2 slots disconnect automatically
2137 TestButton* button = new TestButton(1);
2141 button->DownSignal().Connect(&app1,&TestApp::OnButtonPress);
2142 button->DownSignal().Connect(&app2,&TestApp::OnButtonPress);
2144 // check the connection counts
2145 DALI_TEST_EQUALS( app1.GetConnectionCount(), 1u, TEST_LOCATION );
2146 DALI_TEST_EQUALS( app2.GetConnectionCount(), 1u, TEST_LOCATION );
2147 DALI_TEST_EQUALS( button->DownSignal().GetConnectionCount(), 2u, TEST_LOCATION );
2149 delete button; // should automatically destroy the connection
2151 // check both slot owners have zero connections
2152 DALI_TEST_EQUALS( app1.GetConnectionCount(), 0u, TEST_LOCATION );
2153 DALI_TEST_EQUALS( app2.GetConnectionCount(), 0u, TEST_LOCATION );
2157 int UtcDaliSignalTestApp05(void)
2159 // Test 2 Signals (with different owners) connected to 1 slots
2160 // 1 Signal dies, check that the remaining connection is valid
2162 TestButton* button1 = new TestButton(1); // use for signal 1
2163 TestButton* button2 = new TestButton(2); // use for signal 2
2167 button1->DownSignal().Connect(&app,&TestApp::OnButtonPress);
2168 button2->DownSignal().Connect(&app,&TestApp::OnButtonPress);
2170 // check the connection counts
2171 DALI_TEST_EQUALS( app.GetConnectionCount(), 2u, TEST_LOCATION );
2172 DALI_TEST_EQUALS( button1->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2173 DALI_TEST_EQUALS( button2->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2175 // make sure both signals emit ok
2177 DALI_TEST_EQUALS( app.GetButtonPressedId() , 2 , TEST_LOCATION );
2180 DALI_TEST_EQUALS( app.GetButtonPressedId() , 1 , TEST_LOCATION );
2182 delete button1; // should automatically destroy 1 connection
2184 // check both slot owners have zero connections
2185 DALI_TEST_EQUALS( app.GetConnectionCount(), 1u, TEST_LOCATION );
2187 // check remaining connection still works
2189 DALI_TEST_EQUALS( app.GetButtonPressedId() , 2 , TEST_LOCATION );
2191 // kill the last signal
2193 DALI_TEST_EQUALS( app.GetConnectionCount(), 0u, TEST_LOCATION );
2197 int UtcDaliSignalTestApp06(void)
2199 SignalV2< bool () > boolSignal;
2203 // connect a slot which will return false
2204 boolSignal.Connect( &app, &TestApp::BoolReturnTestFalse);
2205 result = boolSignal.Emit();
2206 DALI_TEST_EQUALS( result, false, TEST_LOCATION );
2208 // disconnect last slot, and connect a slot which returns true
2209 boolSignal.Disconnect( &app, &TestApp::BoolReturnTestFalse);
2210 boolSignal.Connect( &app, &TestApp::BoolReturnTestTrue);
2211 result = boolSignal.Emit();
2212 DALI_TEST_EQUALS( result, true, TEST_LOCATION );
2216 int UtcDaliSlotDelegateConnection(void)
2218 TestSignals signals;
2221 TestSlotDelegateHandler handlers;
2222 signals.SignalVoidNone().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
2223 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2224 signals.EmitVoidSignalVoid();
2225 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2227 // Test double emission
2228 handlers.mHandled = false;
2229 signals.EmitVoidSignalVoid();
2230 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2232 signals.CheckNoConnections();
2235 TestSlotDelegateHandler handlers;
2236 signals.SignalVoid1Ref().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef );
2237 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2239 signals.EmitVoidSignalIntRef(x);
2240 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2241 DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
2243 signals.CheckNoConnections();
2246 TestSlotDelegateHandler handlers;
2247 signals.SignalVoid1Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue );
2248 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2249 signals.EmitVoidSignalIntValue(5);
2250 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2251 DALI_TEST_EQUALS( handlers.mIntParam1, 5, TEST_LOCATION );
2253 signals.CheckNoConnections();
2256 TestSlotDelegateHandler handlers;
2257 signals.SignalVoid2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue );
2258 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2259 signals.EmitVoidSignalIntValueIntValue(6, 7);
2260 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2261 DALI_TEST_EQUALS( handlers.mIntParam1, 6, TEST_LOCATION );
2262 DALI_TEST_EQUALS( handlers.mIntParam2, 7, TEST_LOCATION );
2264 signals.CheckNoConnections();
2267 TestSlotDelegateHandler handlers;
2268 signals.SignalBool1Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue );
2269 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2271 handlers.mBoolReturn = true;
2272 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION );
2273 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2274 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2276 // repeat with opposite return value
2277 handlers.mBoolReturn = false;
2278 handlers.mHandled = false;
2279 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION );
2280 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2281 DALI_TEST_EQUALS( handlers.mFloatParam1, 6.0f, TEST_LOCATION );
2283 signals.CheckNoConnections();
2286 TestSlotDelegateHandler handlers;
2287 signals.SignalBool2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue );
2288 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2289 handlers.mBoolReturn = true;
2290 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION );
2291 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2292 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2293 DALI_TEST_EQUALS( handlers.mIntParam2, 10, TEST_LOCATION );
2295 signals.CheckNoConnections();
2298 TestSlotDelegateHandler handlers;
2299 signals.SignalInt2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue );
2300 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2301 handlers.mIntReturn = 27;
2302 int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
2303 DALI_TEST_EQUALS( x, 27, TEST_LOCATION );
2304 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2305 DALI_TEST_EQUALS( handlers.mFloatParam1, 33.5f, TEST_LOCATION );
2306 DALI_TEST_EQUALS( handlers.mIntParam2, 5, TEST_LOCATION );
2308 signals.CheckNoConnections();
2311 TestSlotDelegateHandler handlers;
2312 signals.SignalFloat0().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid );
2313 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2314 handlers.mFloatReturn = 27.0f;
2315 float f = signals.EmitFloat0Signal();
2316 DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
2317 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2318 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
2319 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2321 signals.CheckNoConnections();
2324 TestSlotDelegateHandler handlers;
2325 signals.SignalFloat2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue );
2326 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2327 handlers.mFloatReturn = 27.0f;
2328 float f = signals.EmitFloat2VSignal(5, 33.0f);
2329 DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
2330 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2331 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2332 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
2334 signals.CheckNoConnections();
2337 TestSlotDelegateHandler handlers;
2338 signals.VoidSignalFloatValue3().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotFloatValue3 );
2339 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2340 signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
2341 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2342 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2343 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
2344 DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
2346 signals.CheckNoConnections();
2349 TestSlotDelegateHandler handlers;
2350 signals.FloatSignalFloatValue3().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValue3 );
2351 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2352 handlers.mFloatReturn = 27.0f;
2353 float returnValue = signals.EmitFloatSignalFloatValue3(5, 33.0f, 100.0f);
2354 DALI_TEST_EQUALS( returnValue, 27.0f, TEST_LOCATION );
2355 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2356 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2357 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
2358 DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
2360 signals.CheckNoConnections();
2364 int UtcDaliSignalSlotDelegateDestruction(void)
2366 // Test that signal disconnect works when slot-delegate is destroyed (goes out of scope)
2369 TestSignals::VoidRetNoParamSignal signal;
2371 DALI_TEST_CHECK( signal.Empty() );
2372 TestSlotDelegateHandler handler;
2373 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
2374 DALI_TEST_CHECK( ! signal.Empty() );
2376 // End of slot lifetime
2377 DALI_TEST_CHECK( signal.Empty() );
2379 // Signal emission should be a NOOP
2384 TestSignals::VoidRet1ValueParamSignal signal;
2386 DALI_TEST_CHECK( signal.Empty() );
2387 TestSlotDelegateHandler handler;
2388 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue );
2389 DALI_TEST_CHECK( ! signal.Empty() );
2391 // End of slot lifetime
2392 DALI_TEST_CHECK( signal.Empty() );
2394 // Signal emission should be a NOOP
2399 TestSignals::VoidRet1RefParamSignal signal;
2401 DALI_TEST_CHECK( signal.Empty() );
2402 TestSlotDelegateHandler handler;
2403 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef );
2404 DALI_TEST_CHECK( ! signal.Empty() );
2406 // End of slot lifetime
2407 DALI_TEST_CHECK( signal.Empty() );
2409 // Signal emission should be a NOOP
2411 signal.Emit( temp );
2415 TestSignals::VoidRet2ValueParamSignal signal;
2417 DALI_TEST_CHECK( signal.Empty() );
2418 TestSlotDelegateHandler handler;
2419 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue );
2420 DALI_TEST_CHECK( ! signal.Empty() );
2422 // End of slot lifetime
2423 DALI_TEST_CHECK( signal.Empty() );
2425 // Signal emission should be a NOOP
2426 signal.Emit( 1, 2 );
2430 TestSignals::BoolRet1ValueParamSignal signal;
2432 DALI_TEST_CHECK( signal.Empty() );
2433 TestSlotDelegateHandler handler;
2434 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue );
2435 DALI_TEST_CHECK( ! signal.Empty() );
2437 // End of slot lifetime
2438 DALI_TEST_CHECK( signal.Empty() );
2440 // Signal emission should be a NOOP
2441 bool blah = signal.Emit( 1.0f );
2442 DALI_TEST_CHECK( ! blah );
2446 TestSignals::BoolRet2ValueParamSignal signal;
2448 DALI_TEST_CHECK( signal.Empty() );
2449 TestSlotDelegateHandler handler;
2450 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue );
2451 DALI_TEST_CHECK( ! signal.Empty() );
2453 // End of slot lifetime
2454 DALI_TEST_CHECK( signal.Empty() );
2456 // Signal emission should be a NOOP
2457 bool blah = signal.Emit( 1.0f, 2 );
2458 DALI_TEST_CHECK( ! blah );
2462 TestSignals::IntRet2ValueParamSignal signal;
2464 DALI_TEST_CHECK( signal.Empty() );
2465 TestSlotDelegateHandler handler;
2466 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue );
2467 DALI_TEST_CHECK( ! signal.Empty() );
2469 // End of slot lifetime
2470 DALI_TEST_CHECK( signal.Empty() );
2472 // Signal emission should be a NOOP
2473 int blah = signal.Emit( 10.0f, 100 );
2474 DALI_TEST_CHECK( 0 == blah );
2478 TestSignals::FloatRet0ParamSignal signal;
2480 DALI_TEST_CHECK( signal.Empty() );
2481 TestSlotDelegateHandler handler;
2482 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid );
2483 DALI_TEST_CHECK( ! signal.Empty() );
2485 // End of slot lifetime
2486 DALI_TEST_CHECK( signal.Empty() );
2488 // Signal emission should be a NOOP
2489 float blah = signal.Emit();
2490 DALI_TEST_CHECK( 0.0f == blah );
2494 TestSignals::FloatRet2ValueParamSignal signal;
2496 DALI_TEST_CHECK( signal.Empty() );
2497 TestSlotDelegateHandler handler;
2498 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2499 DALI_TEST_CHECK( ! signal.Empty() );
2501 // End of slot lifetime
2502 DALI_TEST_CHECK( signal.Empty() );
2504 // Signal emission should be a NOOP
2505 float blah = signal.Emit( 3.0f, 4.0f );
2506 DALI_TEST_CHECK( 0.0f == blah );
2511 int UtcDaliSlotHandlerDisconnect(void)
2513 // Test that callbacks don't occur if a signal is disconnected before emission
2515 TestSignals signals;
2518 TestSlotDelegateHandler handlers;
2519 signals.SignalVoidNone().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
2520 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2521 signals.SignalVoidNone().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
2522 signals.EmitVoidSignalVoid();
2523 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2527 TestSlotDelegateHandler handlers;
2528 signals.SignalVoid1Ref().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
2529 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2531 handlers.mIntReturn = 5;
2532 signals.SignalVoid1Ref().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
2533 signals.EmitVoidSignalIntRef(r);
2534 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2535 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2536 DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
2540 TestSlotDelegateHandler handlers;
2541 signals.SignalVoid1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
2542 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2543 signals.SignalVoid1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
2544 signals.EmitVoidSignalIntValue(5);
2545 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2546 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2550 TestSlotDelegateHandler handlers;
2551 signals.SignalVoid2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
2552 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2553 signals.SignalVoid2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
2554 signals.EmitVoidSignalIntValueIntValue(5, 10);
2555 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2556 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2557 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
2561 TestSlotDelegateHandler handlers;
2562 signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2563 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2564 handlers.mBoolReturn = true;
2565 signals.SignalBool1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2566 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
2567 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2568 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
2572 TestSlotDelegateHandler handlers;
2573 signals.SignalBool2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2574 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2575 handlers.mBoolReturn = true;
2576 signals.SignalBool2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2577 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
2578 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2579 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
2580 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
2584 TestSlotDelegateHandler handlers;
2585 signals.SignalInt2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2586 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2587 handlers.mIntReturn = 27;
2588 signals.SignalInt2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2589 signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
2590 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2591 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2592 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2596 TestSlotDelegateHandler handlers;
2597 signals.SignalFloat0().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2598 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2599 handlers.mFloatReturn = 27.0f;
2600 signals.SignalFloat0().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2601 signals.EmitFloat0Signal();
2602 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2603 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
2604 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2608 TestSlotDelegateHandler handlers;
2609 signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2610 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2611 handlers.mFloatReturn = 27.0f;
2612 signals.SignalFloat2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2613 signals.EmitFloat2VSignal(5, 33.0f);
2614 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2615 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
2616 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );