5 * Copyright (c) 2021 Samsung Electronics Co., Ltd.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
21 // Helper classes for testing DALi signal and slots
26 TestButton(unsigned int id)
33 mPanelDown.Emit(*this);
41 typedef Signal<void(TestButton&)> PanelDownSignal;
42 typedef Signal<void(TestButton&)> PanelUpSignal;
44 PanelDownSignal& DownSignal()
49 PanelUpSignal& SignalUp()
61 PanelDownSignal mPanelDown;
62 PanelUpSignal mPanelUp;
65 class TestApp : public ConnectionTracker
69 : mButtonPressed(false),
70 mVoidFunctionCalled(false)
74 void OnButtonPress(TestButton& button)
76 mButtonPressed = true;
77 mButtonId = button.GetId();
80 void OnButtonRelease(TestButton& button)
82 mButtonPressed = false;
83 mButtonId = button.GetId();
86 int GetButtonPressedId()
91 bool BoolReturnTestFalse()
96 bool BoolReturnTestTrue()
103 mVoidFunctionCalled = true;
107 bool mVoidFunctionCalled;
114 // Void return, no parameters
115 typedef Signal<void()> VoidRetNoParamSignal;
117 // Void return, 1 value parameter
118 typedef Signal<void(int)> VoidRet1ValueParamSignal;
120 // Void return, 1 reference parameter
121 typedef Signal<void(int&)> VoidRet1RefParamSignal;
123 // Void return, 2 value parameters
124 typedef Signal<void(int, int)> VoidRet2ValueParamSignal;
126 // Void return, 3 value parameters
127 typedef Signal<void(int, int, int)> VoidRet3ValueParamSignal;
129 // bool return, 1 value parameter
130 typedef Signal<bool(float)> BoolRet1ValueParamSignal;
132 // bool return, 2 value parameter
133 typedef Signal<bool(float, int)> BoolRet2ValueParamSignal;
135 // int return, 2 value parameter
136 typedef Signal<int(float, int)> IntRet2ValueParamSignal;
138 // float return, 0 parameters
139 typedef Signal<float()> FloatRet0ParamSignal;
141 // float return, 1 value parameters
142 typedef Signal<float(float)> FloatRet1ParamSignal;
144 // float return, 2 value parameters
145 typedef Signal<float(float, float)> FloatRet2ValueParamSignal;
147 // float return, 3 value parameters
148 typedef Signal<float(float, float, float)> FloatRet3ValueParamSignal;
150 // void return, 3 value parameters
151 typedef Signal<void(float, float, float)> VoidSignalTypeFloatValue3;
153 VoidRetNoParamSignal& SignalVoidNone()
157 VoidRet1RefParamSignal& SignalVoid1Ref()
159 return mSignalVoid1R;
161 VoidRet1ValueParamSignal& SignalVoid1Value()
163 return mSignalVoid1V;
165 VoidRet2ValueParamSignal& SignalVoid2Value()
167 return mSignalVoid2V;
169 VoidRet3ValueParamSignal& SignalVoid3Value()
171 return mSignalVoid3V;
174 BoolRet1ValueParamSignal& SignalBool1Value()
176 return mSignalBool1V;
178 BoolRet2ValueParamSignal& SignalBool2Value()
180 return mSignalBool2V;
182 IntRet2ValueParamSignal& SignalInt2Value()
186 FloatRet0ParamSignal& SignalFloat0()
188 return mSignalFloat0;
190 FloatRet1ParamSignal& SignalFloat1Value()
192 return mSignalFloat1V;
194 FloatRet2ValueParamSignal& SignalFloat2Value()
196 return mSignalFloat2V;
199 VoidSignalTypeFloatValue3& VoidSignalFloatValue3()
201 return mVoidSignalFloatValue3;
203 FloatRet3ValueParamSignal& SignalFloat3Value()
205 return mFloatSignalFloatValue3;
212 void CheckNoConnections()
214 DALI_TEST_EQUALS(mSignalVoid0.GetConnectionCount(), 0u, TEST_LOCATION);
215 DALI_TEST_EQUALS(mSignalVoid1R.GetConnectionCount(), 0u, TEST_LOCATION);
216 DALI_TEST_EQUALS(mSignalVoid1V.GetConnectionCount(), 0u, TEST_LOCATION);
217 DALI_TEST_EQUALS(mSignalVoid2V.GetConnectionCount(), 0u, TEST_LOCATION);
218 DALI_TEST_EQUALS(mSignalVoid3V.GetConnectionCount(), 0u, TEST_LOCATION);
219 DALI_TEST_EQUALS(mSignalBool1V.GetConnectionCount(), 0u, TEST_LOCATION);
220 DALI_TEST_EQUALS(mSignalBool2V.GetConnectionCount(), 0u, TEST_LOCATION);
221 DALI_TEST_EQUALS(mSignalInt2V.GetConnectionCount(), 0u, TEST_LOCATION);
222 DALI_TEST_EQUALS(mSignalFloat0.GetConnectionCount(), 0u, TEST_LOCATION);
223 DALI_TEST_EQUALS(mSignalFloat1V.GetConnectionCount(), 0u, TEST_LOCATION);
224 DALI_TEST_EQUALS(mSignalFloat2V.GetConnectionCount(), 0u, TEST_LOCATION);
225 DALI_TEST_EQUALS(mVoidSignalFloatValue3.GetConnectionCount(), 0u, TEST_LOCATION);
226 DALI_TEST_EQUALS(mFloatSignalFloatValue3.GetConnectionCount(), 0u, TEST_LOCATION);
229 void EmitVoidSignalVoid()
234 void EmitVoidSignalIntRef(int& ref)
236 mSignalVoid1R.Emit(ref);
239 void EmitVoidSignal1IntValue(int p1)
241 mSignalVoid1V.Emit(p1);
244 void EmitVoidSignal2IntValue(int p1, int p2)
246 mSignalVoid2V.Emit(p1, p2);
249 void EmitVoidSignal3IntValue(int p1, int p2, int p3)
251 mSignalVoid3V.Emit(p1, p2, p3);
254 bool EmitBoolSignalFloatValue(float p1)
256 return mSignalBool1V.Emit(p1);
259 bool EmitBoolSignalFloatValueIntValue(float p1, int p2)
261 return mSignalBool2V.Emit(p1, p2);
264 int EmitIntSignalFloatValueIntValue(float p1, int p2)
266 return mSignalInt2V.Emit(p1, p2);
269 float EmitFloat1VSignal(float p1)
271 return mSignalFloat1V.Emit(p1);
274 float EmitFloat2VSignal(float p1, float p2)
276 return mSignalFloat2V.Emit(p1, p2);
279 float EmitFloat0Signal()
281 return mSignalFloat0.Emit();
284 void EmitVoidSignalFloatValue3(float p1, float p2, float p3)
286 mVoidSignalFloatValue3.Emit(p1, p2, p3);
289 float EmitFloat3VSignal(float p1, float p2, float p3)
291 return mFloatSignalFloatValue3.Emit(p1, p2, p3);
295 VoidRetNoParamSignal mSignalVoid0;
296 VoidRet1RefParamSignal mSignalVoid1R;
297 VoidRet1ValueParamSignal mSignalVoid1V;
298 VoidRet2ValueParamSignal mSignalVoid2V;
299 VoidRet3ValueParamSignal mSignalVoid3V;
301 BoolRet1ValueParamSignal mSignalBool1V;
302 BoolRet2ValueParamSignal mSignalBool2V;
303 IntRet2ValueParamSignal mSignalInt2V;
304 FloatRet0ParamSignal mSignalFloat0;
305 FloatRet1ParamSignal mSignalFloat1V;
306 FloatRet2ValueParamSignal mSignalFloat2V;
307 VoidSignalTypeFloatValue3 mVoidSignalFloatValue3;
308 FloatRet3ValueParamSignal mFloatSignalFloatValue3;
312 * A helper class with various slots
314 class TestSlotHandler : public ConnectionTracker
352 void VoidSlotVoidAlternative()
358 void VoidSlotIntRef(int& p1)
365 void VoidSlotIntValue(int p1)
372 void VoidDuplicateSlotIntValue(int p1)
379 void VoidSlotIntValueIntValue(int p1, int p2)
387 bool BoolSlotFloatValue(float p1)
395 bool BoolSlotFloatValueIntValue(float p1, int p2)
404 int IntSlotFloatValueIntValue(float p1, int p2)
413 float FloatSlotVoid()
420 float FloatSlotFloatValueFloatValue(float p1, float p2)
429 void VoidSlotFloatValue3(float p1, float p2, float p3)
438 float FloatSlotFloatValue3(float p1, float p2, float p3)
448 int mIntParam1, mIntParam2, mIntParam3;
449 float mFloatParam1, mFloatParam2, mFloatParam3;
458 * A version of TestSlotHandler which disconnects during the callback
460 class TestSlotDisconnector : public ConnectionTracker
463 TestSlotDisconnector()
489 void VoidConnectVoid(TestSignals::VoidRetNoParamSignal& signal)
491 mVoidSignalVoid = &signal;
492 signal.Connect(this, &TestSlotDisconnector::VoidSlotVoid);
497 mVoidSignalVoid->Disconnect(this, &TestSlotDisconnector::VoidSlotVoid);
501 void VoidConnectIntRef(TestSignals::VoidRet1RefParamSignal& signal)
503 mVoidSignalIntRef = &signal;
504 signal.Connect(this, &TestSlotDisconnector::VoidSlotIntRef);
507 void VoidSlotIntRef(int& p1)
509 mVoidSignalIntRef->Disconnect(this, &TestSlotDisconnector::VoidSlotIntRef);
514 void VoidSlotIntValue(int p1)
520 void VoidSlotIntValueIntValue(int p1, int p2)
527 bool BoolSlotFloatValue(float p1)
534 bool BoolSlotFloatValueIntValue(float p1, int p2)
542 int IntSlotFloatValueIntValue(float p1, int p2)
550 float FloatSlotVoid()
556 float FloatSlotFloatValueFloatValue(float p1, float p2)
564 TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
565 TestSignals::VoidRet1RefParamSignal* mVoidSignalIntRef;
567 int mIntParam1, mIntParam2, mIntParam3;
568 float mFloatParam1, mFloatParam2;
576 * A more complicated version of TestSlotDisconnector, which disconnects some but not all callbacks
578 class TestSlotMultiDisconnector : public ConnectionTracker
581 static const int NUM_SLOTS = 10;
583 TestSlotMultiDisconnector()
584 : mVoidSignalVoid(NULL)
591 for(int i = 0; i < NUM_SLOTS; ++i)
593 mSlotHandled[i] = false;
597 void ConnectAll(TestSignals::VoidRetNoParamSignal& signal)
599 mVoidSignalVoid = &signal;
600 signal.Connect(this, &TestSlotMultiDisconnector::Slot0);
601 signal.Connect(this, &TestSlotMultiDisconnector::Slot1);
602 signal.Connect(this, &TestSlotMultiDisconnector::Slot2);
603 signal.Connect(this, &TestSlotMultiDisconnector::Slot3);
604 signal.Connect(this, &TestSlotMultiDisconnector::Slot4);
605 signal.Connect(this, &TestSlotMultiDisconnector::Slot5);
606 signal.Connect(this, &TestSlotMultiDisconnector::Slot6);
607 signal.Connect(this, &TestSlotMultiDisconnector::Slot7);
608 signal.Connect(this, &TestSlotMultiDisconnector::Slot8);
609 signal.Connect(this, &TestSlotMultiDisconnector::Slot9);
614 mSlotHandled[0] = true;
619 mSlotHandled[1] = true;
624 mSlotHandled[2] = true;
629 mSlotHandled[3] = true;
631 // Disconnect the odd numbered lots, because we can
632 mVoidSignalVoid->Disconnect(this, &TestSlotMultiDisconnector::Slot1);
633 mVoidSignalVoid->Disconnect(this, &TestSlotMultiDisconnector::Slot3);
634 mVoidSignalVoid->Disconnect(this, &TestSlotMultiDisconnector::Slot5);
635 mVoidSignalVoid->Disconnect(this, &TestSlotMultiDisconnector::Slot7);
636 mVoidSignalVoid->Disconnect(this, &TestSlotMultiDisconnector::Slot9);
641 mSlotHandled[4] = true;
646 mSlotHandled[5] = true;
651 mSlotHandled[6] = true;
656 mSlotHandled[7] = true;
661 mSlotHandled[8] = true;
666 mSlotHandled[9] = true;
669 TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
671 bool mSlotHandled[NUM_SLOTS];
675 * A version of TestSlotHandler which disconnects during the callback
677 class TestEmitDuringCallback : public ConnectionTracker
680 TestEmitDuringCallback()
681 : mVoidSignalVoid(NULL),
682 mFloatRet0ParamSignal(NULL),
683 mFloatRet1ParamSignal(NULL),
684 mFloatRet2ParamSignal(NULL),
685 mFloatRet3ParamSignal(NULL),
690 void VoidConnectVoid(TestSignals::VoidRetNoParamSignal& signal)
692 mVoidSignalVoid = &signal;
693 signal.Connect(this, &TestEmitDuringCallback::VoidSlotVoid);
696 void FloatRet0ParamConnect(TestSignals::FloatRet0ParamSignal& signal)
698 mFloatRet0ParamSignal = &signal;
699 signal.Connect(this, &TestEmitDuringCallback::FloatRet0Param);
701 void FloatRet1ParamConnect(TestSignals::FloatRet1ParamSignal& signal)
703 mFloatRet1ParamSignal = &signal;
704 signal.Connect(this, &TestEmitDuringCallback::FloatRet1Param);
706 void FloatRet2ParamConnect(TestSignals::FloatRet2ValueParamSignal& signal)
708 mFloatRet2ParamSignal = &signal;
709 signal.Connect(this, &TestEmitDuringCallback::FloatRet2Param);
711 void FloatRet3ParamConnect(TestSignals::FloatRet3ValueParamSignal& signal)
713 mFloatRet3ParamSignal = &signal;
714 signal.Connect(this, &TestEmitDuringCallback::FloatRet3Param);
717 void DeleteDuringEmitConnect(TestSignals::VoidRetNoParamSignal& signal)
719 mVoidSignalVoid = &signal;
720 signal.Connect(this, &TestEmitDuringCallback::DeleteSignalDuringEmit);
723 void DeleteDuringEmitConnect(TestSignals::FloatRet0ParamSignal& signal)
725 mFloatRet0ParamSignal = &signal;
726 signal.Connect(this, &TestEmitDuringCallback::DeleteRetSignalDuringEmit);
731 // Emitting during Emit is very bad!
732 mVoidSignalVoid->Emit();
736 void DeleteSignalDuringEmit()
738 // deleting the signal during the emit
739 delete mVoidSignalVoid;
742 float DeleteRetSignalDuringEmit()
744 // deleting the signal during the emit
745 delete mFloatRet0ParamSignal;
749 float FloatRet0Param()
751 // Emitting during Emit is very bad!
753 return mFloatRet0ParamSignal->Emit();
755 float FloatRet1Param(float x)
757 // Emitting during Emit is very bad!
759 return mFloatRet1ParamSignal->Emit(x);
761 float FloatRet2Param(float x, float y)
763 // Emitting during Emit is very bad!
765 return mFloatRet2ParamSignal->Emit(x, y);
767 float FloatRet3Param(float x, float y, float z)
769 // Emitting during Emit is very bad!
771 return mFloatRet3ParamSignal->Emit(x, y, z);
774 TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
775 TestSignals::FloatRet0ParamSignal* mFloatRet0ParamSignal;
776 TestSignals::FloatRet1ParamSignal* mFloatRet1ParamSignal;
777 TestSignals::FloatRet2ValueParamSignal* mFloatRet2ParamSignal;
778 TestSignals::FloatRet3ValueParamSignal* mFloatRet3ParamSignal;
784 * A version of TestSlotHandler which uses SlotDelegate
786 class TestSlotDelegateHandler // This does not inherit from ConnectionTrackerInterface!
789 TestSlotDelegateHandler()
790 : mSlotDelegate(this),
825 void AlternativeVoidSlotVoid()
831 void VoidSlotIntRef(int& p1)
838 void VoidSlotIntValue(int p1)
845 void VoidDuplicateSlotIntValue(int p1)
852 void VoidSlotIntValueIntValue(int p1, int p2)
860 bool BoolSlotFloatValue(float p1)
868 bool BoolSlotFloatValueIntValue(float p1, int p2)
877 int IntSlotFloatValueIntValue(float p1, int p2)
886 float FloatSlotVoid()
893 float FloatSlotFloatValueFloatValue(float p1, float p2)
902 void VoidSlotFloatValue3(float p1, float p2, float p3)
911 float FloatSlotFloatValue3(float p1, float p2, float p3)
921 SlotDelegate<TestSlotDelegateHandler> mSlotDelegate;
923 int mIntParam1, mIntParam2, mIntParam3;
924 float mFloatParam1, mFloatParam2, mFloatParam3;
933 * Test that reimplmenting ConnectionTrackerInterface actually works.
934 * This basic connection tracker only allows one callback to be connected.
936 class TestBasicConnectionTrackerInterface : public ConnectionTrackerInterface
939 TestBasicConnectionTrackerInterface()
940 : mCallbackHandled(false),
946 ~TestBasicConnectionTrackerInterface()
948 if(mSlotObserver && mCallback)
950 // Notify signal since the slot has been destroyed
951 mSlotObserver->SlotDisconnected(mCallback);
952 // mCallback and mSlotObserver are not owned
961 mCallbackHandled = true;
965 * @copydoc ConnectionTrackerInterface::GetConnectionCount
967 virtual std::size_t GetConnectionCount() const
978 * @copydoc ConnectionTrackerInterface::SignalConnected
980 virtual void SignalConnected(SlotObserver* slotObserver, CallbackBase* callback)
982 DALI_ASSERT_ALWAYS(NULL == mCallback && "Only one connection supported!");
984 mCallback = callback;
985 mSlotObserver = slotObserver;
989 * @copydoc ConnectionTrackerInterface::SignalDisconnected
991 virtual void SignalDisconnected(SlotObserver* slotObserver, CallbackBase* callback)
993 if(mSlotObserver == slotObserver)
995 mSlotObserver = NULL;
997 // mCallback and mSlotObserver are not owned
1002 * RemoveNullCallback,
1003 * testing what occurs when we pass a callback that doesn't exist
1005 void RemoveNullCallback()
1007 mSlotObserver->SlotDisconnected(NULL);
1011 TestBasicConnectionTrackerInterface(const TestBasicConnectionTrackerInterface&); ///< undefined copy constructor
1012 TestBasicConnectionTrackerInterface& operator=(const TestBasicConnectionTrackerInterface&); ///< undefined assignment operator
1015 bool mCallbackHandled;
1018 CallbackBase* mCallback; ///< callback, has ownership
1019 SlotObserver* mSlotObserver; ///< a pointer to the slot observer (not owned)
1022 // for testing static function callbacks
1023 class StaticFunctionHandlers
1026 StaticFunctionHandlers()
1028 staticFunctionHandled = false;
1032 staticFunctionHandled = false;
1035 static void VoidSlotVoid()
1037 staticFunctionHandled = true;
1039 static void VoidSlot1Param(int p1)
1041 staticFunctionHandled = true;
1043 static void VoidSlot2Param(int p1, int p2)
1045 staticFunctionHandled = true;
1047 static void VoidSlot3Param(int p1, int p2, int p3)
1049 staticFunctionHandled = true;
1052 static float RetSlot0Param()
1054 staticFunctionHandled = true;
1057 static float RetSlot1Param(float p1)
1059 staticFunctionHandled = true;
1062 static float RetSlot2Param(float p1, float p2)
1064 staticFunctionHandled = true;
1067 static float RetSlot3Param(float p1, float p2, float p3)
1069 staticFunctionHandled = true;
1073 static bool staticFunctionHandled;
1077 * test functor, we store a reference to a bool which is outside of the functor
1078 * so when the functor is copied, the copy can reference the original data
1082 TestFunctor(bool& functorCalled)
1083 : mFunctorCalled(functorCalled){};
1087 mFunctorCalled = true;
1090 bool& mFunctorCalled;
1093 struct VoidFunctorVoid
1095 VoidFunctorVoid(bool& functorCalled)
1096 : mFunctorCalled(functorCalled)
1102 mFunctorCalled = true;
1105 bool& mFunctorCalled;
1108 #endif // #define SIGNAL_HELPER