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.
24 #include <dali-test-suite-utils.h>
25 #include <dali/public-api/dali-core.h>
27 #include "signal-helper.h"
31 bool StaticFunctionHandlers::staticFunctionHandled;
33 void utc_dali_signal_templates_startup(void)
35 test_return_value = TET_UNDEF;
38 void utc_dali_signal_templates_cleanup(void)
40 test_return_value = TET_PASS;
45 bool wasStaticVoidCallbackVoidCalled = false;
46 bool wasStaticFloatCallbackVoidCalled = false;
47 bool wasStaticVoidCallbackIntValueCalled = false;
48 int staticIntValue = 0;
49 bool wasStaticFloatCallbackFloatValueFloatValueCalled = false;
50 float staticFloatValue1 = 0.0f;
51 float staticFloatValue2 = 0.0f;
53 void StaticVoidCallbackVoid()
55 wasStaticVoidCallbackVoidCalled = true;
58 void AlternativeVoidCallbackVoid()
62 float StaticFloatCallbackVoid()
64 wasStaticFloatCallbackVoidCalled = true;
68 void StaticVoidCallbackIntValue(int value)
70 wasStaticVoidCallbackIntValueCalled = true;
71 staticIntValue = value;
74 float StaticFloatCallbackFloatValueFloatValue(float value1, float value2)
76 wasStaticFloatCallbackFloatValueFloatValueCalled = true;
77 staticFloatValue1 = value1;
78 staticFloatValue2 = value2;
79 return value1 + value2;
84 /*******************************************
86 * Start of Utc test cases.
87 * Test cases performed in order of API listed in dali-signal.h
88 * UtcDaliSignal + FunctionName + P=positive test, N = Negative test
92 int UtcDaliSignalEmptyP(void)
94 TestApplication application; // Create core for debug logging
96 // Test that Empty() is true, when no slots connected to the signal
99 TestSignals::VoidRetNoParamSignal signal;
100 DALI_TEST_CHECK(signal.Empty());
103 // Test that Empty() is true, when a slot has connected and disconnected
105 TestSignals::VoidRetNoParamSignal signal;
106 TestSlotHandler handler;
107 signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
108 signal.Disconnect(&handler, &TestSlotHandler::VoidSlotVoid);
109 DALI_TEST_CHECK(signal.Empty());
115 int UtcDaliSignalEmptyN(void)
117 TestApplication application; // Create core for debug logging
119 // Test that Empty() is false after signal connection
120 TestSignals::VoidRetNoParamSignal signal;
121 TestSlotHandler handler;
122 signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
123 DALI_TEST_CHECK(!signal.Empty());
128 int UtcDaliSignalGetConnectionCountP(void)
130 TestApplication application; // Create core for debug logging
132 TestSignals::VoidRetNoParamSignal signal;
133 TestSlotHandler handler;
134 signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
135 DALI_TEST_CHECK(signal.GetConnectionCount() == 1);
137 TestSlotHandler handler2;
138 signal.Connect(&handler2, &TestSlotHandler::VoidSlotVoid);
139 DALI_TEST_CHECK(signal.GetConnectionCount() == 2);
144 int UtcDaliSignalGetConnectionCountN(void)
146 TestApplication application; // Create core for debug logging
147 TestSignals::VoidRetNoParamSignal signal;
148 DALI_TEST_CHECK(signal.GetConnectionCount() == 0);
153 * there are 5 different connection functions
154 * we go through them here in order of definition in dali-signal.h
156 int UtcDaliSignalConnectP01(void)
158 TestApplication application; // Create core for debug logging
160 // test static function: void Connect( void (*func)() )
161 TestSignals::VoidRetNoParamSignal signal;
162 signal.Connect(StaticVoidCallbackVoid);
163 DALI_TEST_CHECK(!signal.Empty());
168 int UtcDaliSignalConnectN01(void)
170 TestApplication application; // Create core for debug logging
172 TestSignals::VoidRetNoParamSignal signal;
173 signal.Connect(nullptr);
176 // No assert occurs any more - the callback is silently ignored.
177 // If we execute this code, then the test case didn't crash.
178 tet_result(TET_PASS);
183 int UtcDaliSignalConnectP02(void)
185 TestApplication application; // Create core for debug logging
187 // test member function: Connect( X* obj, void (X::*func)() ))
188 TestSignals::VoidRetNoParamSignal signal;
189 TestSlotHandler handler;
190 signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
191 DALI_TEST_CHECK(!signal.Empty());
193 DALI_TEST_CHECK(handler.mHandled == true);
197 int UtcDaliSignalConnectN02(void)
199 TestApplication application; // Create core for debug logging
201 TestSignals::VoidRetNoParamSignal signal;
204 // test member function: Connect( X* obj, void (X::*func)() )) with NULL object
205 signal.Connect(static_cast<TestSlotHandler*>(NULL), &TestSlotHandler::VoidSlotVoid);
207 catch(Dali::DaliException& e)
209 // Tests that a negative test of an assertion succeeds
210 DALI_TEST_PRINT_ASSERT(e);
211 tet_result(TET_PASS);
216 int UtcDaliSignalConnectP03(void)
218 TestApplication application; // Create core for debug logging
220 // test slot delegate: Connect( SlotDelegate<X>& delegate, void (X::*func)() )
221 TestSignals::VoidRetNoParamSignal signal;
222 TestSlotDelegateHandler handler;
223 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
224 DALI_TEST_CHECK(!signal.Empty());
226 DALI_TEST_CHECK(handler.mHandled == true);
231 int UtcDaliSignalConnectN03(void)
233 TestApplication application; // Create core for debug logging
234 // the delegate is passed by reference, so you can't pass null.
235 tet_result(TET_PASS);
239 int UtcDaliSignalConnectP04(void)
241 TestApplication application; // Create core for debug logging
243 // test function object: Connect( ConnectionTrackerInterface* connectionTracker, const X& func )
244 TestSlotHandler handler;
245 TestSignals::VoidRetNoParamSignal signal;
246 bool functorCalled(false);
247 TestFunctor functor(functorCalled);
248 signal.Connect(&handler, functor);
249 DALI_TEST_CHECK(!signal.Empty());
251 DALI_TEST_CHECK(functorCalled == true);
256 int UtcDaliSignalConnectN04(void)
258 // for negative test we try to connect a null connection tracker to the signal
259 TestSignals::VoidRetNoParamSignal signal;
260 TestSlotHandler* nullHandler(NULL);
263 signal.Connect(nullHandler, &TestSlotHandler::VoidSlotVoid);
265 catch(Dali::DaliException& e)
267 // Tests that a negative test of an assertion succeeds
268 DALI_TEST_PRINT_ASSERT(e);
269 tet_result(TET_PASS);
275 int UtcDaliSignalConnectP05(void)
277 TestApplication application; // Create core for debug logging
279 // test function object using FunctorDelegate.
280 // :Connect( ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate )
282 TestSlotHandler handler;
283 TestSignals::VoidRetNoParamSignal signal;
284 bool functorDelegateCalled(false);
285 signal.Connect(&handler, FunctorDelegate::New(VoidFunctorVoid(functorDelegateCalled)));
286 DALI_TEST_CHECK(!signal.Empty());
288 DALI_TEST_CHECK(functorDelegateCalled == true);
291 TestSlotHandler handler;
292 TestSignals::VoidRet1ValueParamSignal signal;
293 bool functorDelegateCalled(false);
294 signal.Connect(&handler, FunctorDelegate::New(VoidFunctorVoid(functorDelegateCalled)));
295 DALI_TEST_CHECK(!signal.Empty());
301 int UtcDaliSignalConnectN05(void)
303 TestApplication application; // Create core for debug logging
305 // for negative test we try to connect a null connection tracker to the signal
306 // :Connect( ConnectionTrackerInterface == NULL, FunctorDelegate* delegate )
307 TestSlotHandler* nullHandler(NULL);
308 TestSignals::VoidRetNoParamSignal signal;
309 bool functorDelegateCalled(false);
312 signal.Connect(nullHandler, FunctorDelegate::New(VoidFunctorVoid(functorDelegateCalled)));
314 catch(Dali::DaliException& e)
316 DALI_TEST_PRINT_ASSERT(e);
317 tet_result(TET_PASS);
323 * there 3 different disconnect functions
324 * we go through them here in order of definition in dali-signal.h
326 int UtcDaliSignalDisconnectP01(void)
328 TestApplication application; // Create core for debug logging
330 // test static function: Disconnect( void (*func)( Arg0 arg0 ) )
332 TestSignals::VoidRetNoParamSignal signal;
333 signal.Connect(StaticVoidCallbackVoid);
334 DALI_TEST_CHECK(!signal.Empty());
335 signal.Disconnect(StaticVoidCallbackVoid);
336 DALI_TEST_CHECK(signal.Empty());
340 int UtcDaliSignalDisconnectN01(void)
342 TestApplication application; // Create core for debug logging
344 // 1. Disconnect using the function
345 TestSignals::VoidRetNoParamSignal signal;
346 signal.Connect(StaticVoidCallbackVoid);
347 DALI_TEST_CHECK(!signal.Empty());
349 signal.Disconnect(AlternativeVoidCallbackVoid);
351 DALI_TEST_CHECK(!signal.Empty());
356 int UtcDaliSignalDisconnectP02(void)
358 TestApplication application; // Create core for debug logging
360 // test member function: Disconnect( X* obj, void (X::*func)( Arg0 arg0 ) )
361 TestSignals::VoidRetNoParamSignal signal;
362 TestSlotHandler handler;
363 signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
364 DALI_TEST_CHECK(!signal.Empty());
365 signal.Disconnect(&handler, &TestSlotHandler::VoidSlotVoid);
366 DALI_TEST_CHECK(signal.Empty());
370 int UtcDaliSignalDisconnectN02(void)
372 TestApplication application; // Create core for debug logging
374 // 1. Disconnect using a null connection tracker
375 TestSignals::VoidRetNoParamSignal signal;
376 TestSlotHandler handler;
378 signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
379 DALI_TEST_CHECK(!signal.Empty());
383 TestSlotHandler* nullHandler(NULL);
384 signal.Disconnect(nullHandler, &TestSlotHandler::VoidSlotVoid);
386 catch(Dali::DaliException& e)
388 // Tests that a negative test of an assertion succeeds
389 DALI_TEST_PRINT_ASSERT(e);
390 DALI_TEST_CHECK(!signal.Empty());
395 int UtcDaliSignalDisconnectP03(void)
397 TestApplication application; // Create core for debug logging
399 // test slot delegate: Disconnect( SlotDelegate<X>& delegate, void (X::*func)( Arg0 arg0 ) )
400 TestSignals::VoidRetNoParamSignal signal;
401 TestSlotDelegateHandler handler;
402 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
403 DALI_TEST_CHECK(!signal.Empty());
404 signal.Disconnect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
405 DALI_TEST_CHECK(signal.Empty());
410 int UtcDaliSignalDisconnectN03(void)
412 TestApplication application; // Create core for debug logging
414 // try to disconnect from the wrong signal
415 TestSignals::VoidRetNoParamSignal signal;
416 TestSlotDelegateHandler handler;
417 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
419 // use different signal
420 signal.Disconnect(handler.mSlotDelegate, &TestSlotDelegateHandler::AlternativeVoidSlotVoid);
422 DALI_TEST_CHECK(!signal.Empty());
427 /*******************************************
429 * End of Utc test cases for the individual API's of Signals
430 * The following testing Signals functionality as a whole
435 int UtcDaliSignalEmptyCheckSlotDestruction(void)
437 // Test that signal disconnect works when slot is destroyed (goes out of scope)
439 TestSignals::VoidRetNoParamSignal signal;
441 DALI_TEST_CHECK(signal.Empty());
442 TestSlotHandler handler;
443 signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
444 DALI_TEST_CHECK(!signal.Empty());
446 // End of slot lifetime
447 DALI_TEST_CHECK(signal.Empty());
449 // Signal emission should be a NOOP
454 TestSignals::VoidRet1ValueParamSignal signal;
456 DALI_TEST_CHECK(signal.Empty());
457 TestSlotHandler handler;
458 signal.Connect(&handler, &TestSlotHandler::VoidSlotIntValue);
459 DALI_TEST_CHECK(!signal.Empty());
461 // End of slot lifetime
462 DALI_TEST_CHECK(signal.Empty());
464 // Signal emission should be a NOOP
469 TestSignals::VoidRet1RefParamSignal signal;
471 DALI_TEST_CHECK(signal.Empty());
472 TestSlotHandler handler;
473 signal.Connect(&handler, &TestSlotHandler::VoidSlotIntRef);
474 DALI_TEST_CHECK(!signal.Empty());
476 // End of slot lifetime
477 DALI_TEST_CHECK(signal.Empty());
479 // Signal emission should be a NOOP
485 TestSignals::VoidRet2ValueParamSignal signal;
487 DALI_TEST_CHECK(signal.Empty());
488 TestSlotHandler handler;
489 signal.Connect(&handler, &TestSlotHandler::VoidSlotIntValueIntValue);
490 DALI_TEST_CHECK(!signal.Empty());
492 // End of slot lifetime
493 DALI_TEST_CHECK(signal.Empty());
495 // Signal emission should be a NOOP
500 TestSignals::BoolRet1ValueParamSignal signal;
502 DALI_TEST_CHECK(signal.Empty());
503 TestSlotHandler handler;
504 signal.Connect(&handler, &TestSlotHandler::BoolSlotFloatValue);
505 DALI_TEST_CHECK(!signal.Empty());
507 // End of slot lifetime
508 DALI_TEST_CHECK(signal.Empty());
510 // Signal emission should be a NOOP
511 bool blah = signal.Emit(1.0f);
512 DALI_TEST_CHECK(!blah);
516 TestSignals::BoolRet2ValueParamSignal signal;
518 DALI_TEST_CHECK(signal.Empty());
519 TestSlotHandler handler;
520 signal.Connect(&handler, &TestSlotHandler::BoolSlotFloatValueIntValue);
521 DALI_TEST_CHECK(!signal.Empty());
523 // End of slot lifetime
524 DALI_TEST_CHECK(signal.Empty());
526 // Signal emission should be a NOOP
527 bool blah = signal.Emit(1.0f, 2);
528 DALI_TEST_CHECK(!blah);
532 TestSignals::IntRet2ValueParamSignal signal;
534 DALI_TEST_CHECK(signal.Empty());
535 TestSlotHandler handler;
536 signal.Connect(&handler, &TestSlotHandler::IntSlotFloatValueIntValue);
537 DALI_TEST_CHECK(!signal.Empty());
539 // End of slot lifetime
540 DALI_TEST_CHECK(signal.Empty());
542 // Signal emission should be a NOOP
543 int blah = signal.Emit(10.0f, 100);
544 DALI_TEST_CHECK(0 == blah);
548 TestSignals::FloatRet0ParamSignal signal;
550 DALI_TEST_CHECK(signal.Empty());
551 TestSlotHandler handler;
552 signal.Connect(&handler, &TestSlotHandler::FloatSlotVoid);
553 DALI_TEST_CHECK(!signal.Empty());
555 // End of slot lifetime
556 DALI_TEST_CHECK(signal.Empty());
558 // Signal emission should be a NOOP
559 float blah = signal.Emit();
560 DALI_TEST_CHECK(0.0f == blah);
564 TestSignals::FloatRet2ValueParamSignal signal;
566 DALI_TEST_CHECK(signal.Empty());
567 TestSlotHandler handler;
568 signal.Connect(&handler, &TestSlotHandler::FloatSlotFloatValueFloatValue);
569 DALI_TEST_CHECK(!signal.Empty());
571 // End of slot lifetime
572 DALI_TEST_CHECK(signal.Empty());
574 // Signal emission should be a NOOP
575 float blah = signal.Emit(3.0f, 4.0f);
576 DALI_TEST_CHECK(0.0f == blah);
581 // Positive test case for a method
582 int UtcDaliSignalConnectAndEmit01P(void)
584 // Test basic signal emission for each slot type
589 TestSlotHandler handlers;
590 signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
591 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
592 signals.EmitVoidSignalVoid();
593 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
595 // Test double emission
596 handlers.mHandled = false;
597 signals.EmitVoidSignalVoid();
598 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
600 signals.CheckNoConnections();
603 TestSlotHandler handlers;
604 signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
605 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
607 signals.EmitVoidSignalIntRef(x);
608 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
609 DALI_TEST_EQUALS(handlers.mIntParam1, 7, TEST_LOCATION);
611 signals.CheckNoConnections();
614 TestSlotHandler handlers;
615 signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
616 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
617 signals.EmitVoidSignal1IntValue(5);
618 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
619 DALI_TEST_EQUALS(handlers.mIntParam1, 5, TEST_LOCATION);
621 signals.CheckNoConnections();
624 TestSlotHandler handlers;
625 signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
626 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
627 signals.EmitVoidSignal2IntValue(6, 7);
628 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
629 DALI_TEST_EQUALS(handlers.mIntParam1, 6, TEST_LOCATION);
630 DALI_TEST_EQUALS(handlers.mIntParam2, 7, TEST_LOCATION);
632 signals.CheckNoConnections();
635 TestSlotHandler handlers;
636 signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
637 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
639 handlers.mBoolReturn = true;
640 DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION);
641 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
642 DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
644 // repeat with opposite return value
645 handlers.mBoolReturn = false;
646 handlers.mHandled = false;
647 DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION);
648 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
649 DALI_TEST_EQUALS(handlers.mFloatParam1, 6.0f, TEST_LOCATION);
651 signals.CheckNoConnections();
654 TestSlotHandler handlers;
655 signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
656 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
657 handlers.mBoolReturn = true;
658 DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION);
659 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
660 DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
661 DALI_TEST_EQUALS(handlers.mIntParam2, 10, TEST_LOCATION);
663 signals.CheckNoConnections();
666 TestSlotHandler handlers;
667 signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
668 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
669 handlers.mIntReturn = 27;
670 int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
671 DALI_TEST_EQUALS(x, 27, TEST_LOCATION);
672 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
673 DALI_TEST_EQUALS(handlers.mFloatParam1, 33.5f, TEST_LOCATION);
674 DALI_TEST_EQUALS(handlers.mIntParam2, 5, TEST_LOCATION);
676 signals.CheckNoConnections();
679 TestSlotHandler handlers;
680 signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
681 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
682 handlers.mFloatReturn = 27.0f;
683 float f = signals.EmitFloat0Signal();
684 DALI_TEST_EQUALS(f, 27.0f, TEST_LOCATION);
685 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
686 DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
687 DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
689 signals.CheckNoConnections();
692 TestSlotHandler handlers;
693 signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
694 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
695 handlers.mFloatReturn = 27.0f;
696 float f = signals.EmitFloat2VSignal(5, 33.0f);
697 DALI_TEST_EQUALS(f, 27.0f, TEST_LOCATION);
698 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
699 DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
700 DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
702 signals.CheckNoConnections();
705 TestSlotHandler handlers;
706 signals.VoidSignalFloatValue3().Connect(&handlers, &TestSlotHandler::VoidSlotFloatValue3);
707 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
708 signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
709 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
710 DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
711 DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
712 DALI_TEST_EQUALS(handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION);
714 signals.CheckNoConnections();
717 TestSlotHandler handlers;
718 signals.SignalFloat3Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValue3);
719 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
720 handlers.mFloatReturn = 27.0f;
721 float returnValue = signals.EmitFloat3VSignal(5, 33.0f, 100.0f);
722 DALI_TEST_EQUALS(returnValue, 27.0f, TEST_LOCATION);
723 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
724 DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
725 DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
726 DALI_TEST_EQUALS(handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION);
728 signals.CheckNoConnections();
732 int UtcDaliSignalConnectAndEmit02P(void)
734 // testing connection of static functions
736 StaticFunctionHandlers handlers;
739 signals.SignalVoidNone().Connect(&StaticFunctionHandlers::VoidSlotVoid);
740 DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
741 signals.EmitVoidSignalVoid();
742 DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
746 signals.SignalVoid1Value().Connect(&StaticFunctionHandlers::VoidSlot1Param);
747 DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
748 signals.EmitVoidSignal1IntValue(1);
749 DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
753 signals.SignalVoid2Value().Connect(&StaticFunctionHandlers::VoidSlot2Param);
754 DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
755 signals.EmitVoidSignal2IntValue(1, 2);
756 DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
758 // void ( p1, p2, p3 )
760 signals.SignalVoid3Value().Connect(&StaticFunctionHandlers::VoidSlot3Param);
761 DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
762 signals.EmitVoidSignal3IntValue(1, 2, 3);
763 DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
767 signals.SignalFloat0().Connect(&StaticFunctionHandlers::RetSlot0Param);
768 DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
769 signals.EmitFloat0Signal();
770 DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
774 signals.SignalFloat1Value().Connect(&StaticFunctionHandlers::RetSlot1Param);
775 DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
776 signals.EmitFloat1VSignal(1.f);
777 DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
781 signals.SignalFloat2Value().Connect(&StaticFunctionHandlers::RetSlot2Param);
782 DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
783 signals.EmitFloat2VSignal(1.f, 2.f);
784 DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
786 // ret ( p1, p2, p3 )
788 signals.SignalFloat3Value().Connect(&StaticFunctionHandlers::RetSlot3Param);
789 DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
790 signals.EmitFloat3VSignal(1.f, 2.f, 3.f);
791 DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
796 int UtcDaliSignalDisconnect(void)
798 // Test that callbacks don't occur if a signal is disconnected before emission
803 TestSlotHandler handlers;
804 signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
805 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
806 signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
807 signals.EmitVoidSignalVoid();
808 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
812 TestSlotHandler handlers;
813 signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
814 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
816 handlers.mIntReturn = 5;
817 signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
818 signals.EmitVoidSignalIntRef(r);
819 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
820 DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
821 DALI_TEST_EQUALS(r, 7, TEST_LOCATION);
825 TestSlotHandler handlers;
826 signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
827 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
828 signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
829 signals.EmitVoidSignal1IntValue(5);
830 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
831 DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
835 TestSlotHandler handlers;
836 signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
837 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
838 signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
839 signals.EmitVoidSignal2IntValue(5, 10);
840 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
841 DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
842 DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
846 TestSlotHandler handlers;
847 signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
848 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
849 handlers.mBoolReturn = true;
850 signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
851 DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION);
852 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
853 DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
857 TestSlotHandler handlers;
858 signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
859 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
860 handlers.mBoolReturn = true;
861 signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
862 DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION);
863 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
864 DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
865 DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
869 TestSlotHandler handlers;
870 signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
871 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
872 handlers.mIntReturn = 27;
873 signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
874 signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
875 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
876 DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
877 DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
881 TestSlotHandler handlers;
882 signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
883 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
884 handlers.mFloatReturn = 27.0f;
885 signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
886 signals.EmitFloat0Signal();
887 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
888 DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
889 DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
893 TestSlotHandler handlers;
894 signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
895 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
896 handlers.mFloatReturn = 27.0f;
897 signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
898 signals.EmitFloat2VSignal(5, 33.0f);
899 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
900 DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
901 DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
906 int UtcDaliSignalDisconnect2(void)
908 // Test that nothing happens when attempting to disconnect an unconnected slot
912 TestSlotHandler handlers;
913 signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
914 signals.EmitVoidSignalVoid();
915 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
919 TestSlotHandler handlers;
921 signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
922 signals.EmitVoidSignalIntRef(r);
923 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
924 DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
925 DALI_TEST_EQUALS(r, 7, TEST_LOCATION);
929 TestSlotHandler handlers;
930 signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
931 signals.EmitVoidSignal1IntValue(5);
932 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
933 DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
937 TestSlotHandler handlers;
938 signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
939 signals.EmitVoidSignal2IntValue(5, 10);
940 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
941 DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
942 DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
946 TestSlotHandler handlers;
947 handlers.mBoolReturn = true;
948 signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
949 DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION);
950 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
951 DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
955 TestSlotHandler handlers;
956 handlers.mBoolReturn = true;
957 signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
958 DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION);
959 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
960 DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
961 DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
965 TestSlotHandler handlers;
966 handlers.mIntReturn = 27;
967 signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
968 signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
969 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
970 DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
971 DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
975 TestSlotHandler handlers;
976 handlers.mFloatReturn = 27.0f;
977 signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
978 signals.EmitFloat2VSignal(5, 33.0f);
979 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
980 DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
981 DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
985 TestSlotHandler handlers;
986 handlers.mFloatReturn = 27.0f;
987 signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
988 signals.EmitFloat0Signal();
989 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
990 DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
991 DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
996 int UtcDaliSignalDisconnect3(void)
998 // Test that callbacks stop after a signal is disconnected
1000 TestSignals signals;
1003 TestSlotHandler handlers;
1004 signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
1005 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1008 signals.EmitVoidSignalVoid();
1009 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1011 // Disconnect and emit again
1012 handlers.mHandled = false;
1013 signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
1014 signals.EmitVoidSignalVoid();
1015 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1019 TestSlotHandler handlers;
1020 signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1021 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1025 signals.EmitVoidSignalIntRef(r);
1026 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1027 DALI_TEST_EQUALS(handlers.mIntParam1, 7, TEST_LOCATION);
1029 // Disconnect and emit again
1030 handlers.mHandled = false;
1031 handlers.mIntParam1 = 0;
1032 signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1033 signals.EmitVoidSignalIntRef(r);
1034 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1035 DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
1036 DALI_TEST_EQUALS(r, 7, TEST_LOCATION);
1041 int UtcDaliSignalCustomConnectionTracker(void)
1043 // Test slot destruction
1045 TestSignals::VoidRetNoParamSignal signal;
1047 DALI_TEST_CHECK(signal.Empty());
1048 TestBasicConnectionTrackerInterface customTracker;
1049 signal.Connect(&customTracker, &TestBasicConnectionTrackerInterface::VoidSlotVoid);
1050 DALI_TEST_CHECK(!signal.Empty());
1052 // End of slot lifetime
1053 DALI_TEST_CHECK(signal.Empty());
1055 // Signal emission should be a NOOP
1059 TestBasicConnectionTrackerInterface customTracker2;
1061 // Test signal emission & destruction
1063 TestSignals::VoidRetNoParamSignal signal;
1064 DALI_TEST_CHECK(signal.Empty());
1065 DALI_TEST_EQUALS(0u, customTracker2.GetConnectionCount(), TEST_LOCATION);
1067 signal.Connect(&customTracker2, &TestBasicConnectionTrackerInterface::VoidSlotVoid);
1068 DALI_TEST_CHECK(!signal.Empty());
1069 DALI_TEST_EQUALS(1u, customTracker2.GetConnectionCount(), TEST_LOCATION);
1071 DALI_TEST_EQUALS(customTracker2.mCallbackHandled, false, TEST_LOCATION);
1073 DALI_TEST_EQUALS(customTracker2.mCallbackHandled, true, TEST_LOCATION);
1075 DALI_TEST_EQUALS(0u, customTracker2.GetConnectionCount(), TEST_LOCATION);
1077 // Test for removing a null callback
1079 TestBasicConnectionTrackerInterface customTracker3;
1081 TestSignals::VoidRetNoParamSignal signal;
1082 DALI_TEST_CHECK(signal.Empty());
1083 DALI_TEST_EQUALS(0u, customTracker3.GetConnectionCount(), TEST_LOCATION);
1085 signal.Connect(&customTracker3, &TestBasicConnectionTrackerInterface::VoidSlotVoid);
1086 DALI_TEST_CHECK(!signal.Empty());
1087 DALI_TEST_EQUALS(1u, customTracker3.GetConnectionCount(), TEST_LOCATION);
1091 customTracker3.RemoveNullCallback();
1092 tet_result(TET_FAIL);
1094 catch(Dali::DaliException& e)
1096 tet_result(TET_PASS);
1103 int UtcDaliSignalMultipleConnections(void)
1105 // Test that multiple callbacks can be connected to the same signal
1107 TestSignals signals;
1110 TestSlotHandler handler1;
1111 signals.SignalVoidNone().Connect(&handler1, &TestSlotHandler::VoidSlotVoid);
1112 DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
1114 TestSlotHandler handler2;
1115 signals.SignalVoidNone().Connect(&handler2, &TestSlotHandler::VoidSlotVoid);
1116 DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
1118 signals.EmitVoidSignalVoid();
1119 DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
1120 DALI_TEST_EQUALS(handler2.mHandled, true, TEST_LOCATION);
1122 // Remove first connection and repeat
1125 signals.SignalVoidNone().Disconnect(&handler1, &TestSlotHandler::VoidSlotVoid);
1127 signals.EmitVoidSignalVoid();
1128 DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
1129 DALI_TEST_EQUALS(handler2.mHandled, true, TEST_LOCATION);
1133 TestSlotHandler handler1;
1134 signals.SignalVoid1Ref().Connect(&handler1, &TestSlotHandler::VoidSlotIntRef);
1135 DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
1137 TestSlotHandler handler2;
1138 signals.SignalVoid1Ref().Connect(&handler2, &TestSlotHandler::VoidSlotIntRef);
1139 DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
1142 signals.EmitVoidSignalIntRef(x);
1143 DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
1144 DALI_TEST_EQUALS(handler2.mHandled, true, TEST_LOCATION);
1145 DALI_TEST_EQUALS(handler1.mIntParam1, 7, TEST_LOCATION);
1146 DALI_TEST_EQUALS(handler2.mIntParam1, 7, TEST_LOCATION);
1148 // Remove second connection and repeat
1152 signals.SignalVoid1Ref().Disconnect(&handler2, &TestSlotHandler::VoidSlotIntRef);
1154 signals.EmitVoidSignalIntRef(x);
1155 DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
1156 DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
1157 DALI_TEST_EQUALS(handler1.mIntParam1, 8, TEST_LOCATION);
1158 DALI_TEST_EQUALS(handler2.mIntParam1, 0, TEST_LOCATION);
1162 TestSlotHandler handler1;
1163 signals.SignalVoid1Value().Connect(&handler1, &TestSlotHandler::VoidSlotIntValue);
1164 DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
1166 TestSlotHandler handler2;
1167 signals.SignalVoid1Value().Connect(&handler2, &TestSlotHandler::VoidSlotIntValue);
1168 DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
1170 TestSlotHandler handler3;
1171 signals.SignalVoid1Value().Connect(&handler3, &TestSlotHandler::VoidSlotIntValue);
1172 DALI_TEST_EQUALS(handler3.mHandled, false, TEST_LOCATION);
1174 signals.EmitVoidSignal1IntValue(5);
1175 DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
1176 DALI_TEST_EQUALS(handler1.mIntParam1, 5, TEST_LOCATION);
1177 DALI_TEST_EQUALS(handler2.mHandled, true, TEST_LOCATION);
1178 DALI_TEST_EQUALS(handler2.mIntParam1, 5, TEST_LOCATION);
1179 DALI_TEST_EQUALS(handler3.mHandled, true, TEST_LOCATION);
1180 DALI_TEST_EQUALS(handler3.mIntParam1, 5, TEST_LOCATION);
1182 // Remove middle connection and repeat
1186 signals.SignalVoid1Value().Disconnect(&handler2, &TestSlotHandler::VoidSlotIntValue);
1188 signals.EmitVoidSignal1IntValue(6);
1189 DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
1190 DALI_TEST_EQUALS(handler1.mIntParam1, 6, TEST_LOCATION);
1191 DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
1192 DALI_TEST_EQUALS(handler2.mIntParam1, 0, TEST_LOCATION);
1193 DALI_TEST_EQUALS(handler3.mHandled, true, TEST_LOCATION);
1194 DALI_TEST_EQUALS(handler3.mIntParam1, 6, TEST_LOCATION);
1197 // Test that multiple callbacks are disconnected when a signal is destroyed
1199 TestSlotHandler handler4;
1200 TestSlotHandler handler5;
1201 TestSlotHandler handler6;
1204 TestSignals::VoidRet1ValueParamSignal tempSignal;
1206 DALI_TEST_EQUALS(handler4.GetConnectionCount(), 0u, TEST_LOCATION);
1207 DALI_TEST_EQUALS(handler5.GetConnectionCount(), 0u, TEST_LOCATION);
1208 DALI_TEST_EQUALS(handler6.GetConnectionCount(), 0u, TEST_LOCATION);
1210 tempSignal.Connect(&handler4, &TestSlotHandler::VoidSlotIntValue);
1211 tempSignal.Connect(&handler5, &TestSlotHandler::VoidSlotIntValue);
1212 tempSignal.Connect(&handler6, &TestSlotHandler::VoidSlotIntValue);
1214 DALI_TEST_EQUALS(handler4.GetConnectionCount(), 1u, TEST_LOCATION);
1215 DALI_TEST_EQUALS(handler5.GetConnectionCount(), 1u, TEST_LOCATION);
1216 DALI_TEST_EQUALS(handler6.GetConnectionCount(), 1u, TEST_LOCATION);
1218 // End of tempSignal lifetime
1220 DALI_TEST_EQUALS(handler4.GetConnectionCount(), 0u, TEST_LOCATION);
1221 DALI_TEST_EQUALS(handler5.GetConnectionCount(), 0u, TEST_LOCATION);
1222 DALI_TEST_EQUALS(handler6.GetConnectionCount(), 0u, TEST_LOCATION);
1226 int UtcDaliSignalMultipleConnections2(void)
1228 TestSignals signals;
1230 // Test that connecting the same callback twice is a NOOP
1232 TestSlotHandler handler1;
1234 // Note the double connection is intentional
1235 signals.SignalVoid1Value().Connect(&handler1, &TestSlotHandler::VoidSlotIntValue);
1236 signals.SignalVoid1Value().Connect(&handler1, &TestSlotHandler::VoidSlotIntValue);
1237 DALI_TEST_EQUALS(handler1.mHandledCount, 0, TEST_LOCATION);
1239 signals.EmitVoidSignal1IntValue(6);
1240 DALI_TEST_EQUALS(handler1.mHandledCount, 1, TEST_LOCATION);
1241 DALI_TEST_EQUALS(handler1.mIntParam1, 6, TEST_LOCATION);
1243 // Calling Disconnect once should be enough
1244 signals.SignalVoid1Value().Disconnect(&handler1, &TestSlotHandler::VoidSlotIntValue);
1245 DALI_TEST_CHECK(signals.SignalVoid1Value().Empty());
1246 handler1.mIntParam1 = 0;
1248 signals.EmitVoidSignal1IntValue(7);
1249 DALI_TEST_EQUALS(handler1.mHandledCount, 1 /*not incremented since last check*/, TEST_LOCATION);
1250 DALI_TEST_EQUALS(handler1.mIntParam1, 0, TEST_LOCATION);
1253 // Test automatic disconnect after multiple Connect() calls
1255 TestSlotHandler handler2;
1256 signals.SignalVoid1Value().Connect(&handler2, &TestSlotHandler::VoidSlotIntValue);
1257 signals.SignalVoid1Value().Connect(&handler2, &TestSlotHandler::VoidSlotIntValue);
1259 TestSlotHandler handler3;
1260 signals.SignalBool1Value().Connect(&handler3, &TestSlotHandler::BoolSlotFloatValue);
1261 signals.SignalBool1Value().Connect(&handler3, &TestSlotHandler::BoolSlotFloatValue);
1263 DALI_TEST_EQUALS(handler2.mHandledCount, 0, TEST_LOCATION);
1264 DALI_TEST_EQUALS(handler3.mHandledCount, 0, TEST_LOCATION);
1265 DALI_TEST_CHECK(!signals.SignalVoid1Value().Empty());
1266 DALI_TEST_CHECK(!signals.SignalBool1Value().Empty());
1268 DALI_TEST_CHECK(signals.SignalVoid1Value().Empty());
1269 DALI_TEST_CHECK(signals.SignalBool1Value().Empty());
1272 signals.EmitVoidSignal1IntValue(1);
1273 signals.EmitBoolSignalFloatValue(1.0f);
1275 // Test that connecting the same callback 10 times is a NOOP
1276 TestSlotHandler handler4;
1277 DALI_TEST_EQUALS(handler4.mHandledCount, 0, TEST_LOCATION);
1278 DALI_TEST_EQUALS(handler4.mFloatParam1, 0.0f, TEST_LOCATION);
1280 signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1281 signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1282 signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1283 signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1284 signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1285 signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1286 signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1287 signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1288 signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1289 signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1291 signals.EmitBoolSignalFloatValue(2.0f);
1292 DALI_TEST_EQUALS(handler4.mHandledCount, 1, TEST_LOCATION);
1293 DALI_TEST_EQUALS(handler4.mFloatParam1, 2.0f, TEST_LOCATION);
1295 // Calling Disconnect once should be enough
1296 signals.SignalBool1Value().Disconnect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1297 DALI_TEST_CHECK(signals.SignalBool1Value().Empty());
1299 signals.EmitBoolSignalFloatValue(3.0f);
1300 DALI_TEST_EQUALS(handler4.mHandledCount, 1 /*not incremented since last check*/, TEST_LOCATION);
1301 DALI_TEST_EQUALS(handler4.mFloatParam1, 2.0f, TEST_LOCATION);
1305 int UtcDaliSignalMultipleConnections3(void)
1307 TestSignals signals;
1309 // Test connecting two difference callbacks for the same ConnectionTracker
1311 TestSlotHandler handler1;
1314 TestSignals::VoidRet1ValueParamSignal tempSignal;
1316 DALI_TEST_EQUALS(handler1.GetConnectionCount(), 0u, TEST_LOCATION);
1317 DALI_TEST_EQUALS(handler1.mHandledCount, 0, TEST_LOCATION);
1318 DALI_TEST_EQUALS(handler1.mIntParam1, 0, TEST_LOCATION);
1320 // Note that the duplicate connection is deliberate
1321 tempSignal.Connect(&handler1, &TestSlotHandler::VoidSlotIntValue);
1322 tempSignal.Connect(&handler1, &TestSlotHandler::VoidDuplicateSlotIntValue);
1324 DALI_TEST_EQUALS(handler1.GetConnectionCount(), 2u, TEST_LOCATION);
1325 DALI_TEST_EQUALS(handler1.mHandledCount, 0, TEST_LOCATION);
1327 tempSignal.Emit(10);
1329 DALI_TEST_EQUALS(handler1.mHandledCount, 2, TEST_LOCATION);
1330 DALI_TEST_EQUALS(handler1.mIntParam1, 10, TEST_LOCATION);
1331 DALI_TEST_EQUALS(handler1.mIntParam2, 10, TEST_LOCATION);
1333 // End of tempSignal lifetime
1335 DALI_TEST_EQUALS(handler1.GetConnectionCount(), 0u, TEST_LOCATION);
1339 int UtcDaliSignalDisconnectStatic(void)
1344 TestSignals::VoidRetNoParamSignal signal;
1345 DALI_TEST_CHECK(signal.Empty());
1347 signal.Connect(StaticVoidCallbackVoid);
1348 DALI_TEST_CHECK(!signal.Empty());
1350 wasStaticVoidCallbackVoidCalled = false;
1352 DALI_TEST_EQUALS(wasStaticVoidCallbackVoidCalled, true, TEST_LOCATION);
1354 signal.Disconnect(StaticVoidCallbackVoid);
1355 DALI_TEST_CHECK(signal.Empty());
1357 wasStaticVoidCallbackVoidCalled = false;
1359 DALI_TEST_EQUALS(wasStaticVoidCallbackVoidCalled, false, TEST_LOCATION);
1365 TestSignals::FloatRet0ParamSignal signal;
1366 DALI_TEST_CHECK(signal.Empty());
1368 signal.Connect(StaticFloatCallbackVoid);
1369 DALI_TEST_CHECK(!signal.Empty());
1371 wasStaticFloatCallbackVoidCalled = false;
1372 float result = signal.Emit();
1373 DALI_TEST_EQUALS(wasStaticFloatCallbackVoidCalled, true, TEST_LOCATION);
1374 DALI_TEST_EQUALS(result, 7.0f, TEST_LOCATION);
1376 signal.Disconnect(StaticFloatCallbackVoid);
1377 DALI_TEST_CHECK(signal.Empty());
1379 wasStaticFloatCallbackVoidCalled = false;
1380 result = signal.Emit();
1381 DALI_TEST_EQUALS(wasStaticFloatCallbackVoidCalled, false, TEST_LOCATION);
1382 DALI_TEST_EQUALS(result, 0.0f, TEST_LOCATION);
1388 TestSignals::VoidRet1ValueParamSignal signal;
1389 DALI_TEST_CHECK(signal.Empty());
1391 signal.Connect(StaticVoidCallbackIntValue);
1392 DALI_TEST_CHECK(!signal.Empty());
1394 wasStaticVoidCallbackIntValueCalled = false;
1397 DALI_TEST_EQUALS(wasStaticVoidCallbackIntValueCalled, true, TEST_LOCATION);
1398 DALI_TEST_EQUALS(staticIntValue, 10, TEST_LOCATION);
1400 signal.Disconnect(StaticVoidCallbackIntValue);
1401 DALI_TEST_CHECK(signal.Empty());
1403 wasStaticVoidCallbackIntValueCalled = false;
1406 DALI_TEST_EQUALS(wasStaticVoidCallbackIntValueCalled, false, TEST_LOCATION);
1407 DALI_TEST_EQUALS(staticIntValue, 0, TEST_LOCATION);
1410 // float Func( float, float )
1413 TestSignals::FloatRet2ValueParamSignal signal;
1414 DALI_TEST_CHECK(signal.Empty());
1416 signal.Connect(StaticFloatCallbackFloatValueFloatValue);
1417 DALI_TEST_CHECK(!signal.Empty());
1419 wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1420 staticFloatValue1 = 0.0f;
1421 staticFloatValue2 = 0.0f;
1422 float result = signal.Emit(5.0f, 6.0f);
1423 DALI_TEST_EQUALS(wasStaticFloatCallbackFloatValueFloatValueCalled, true, TEST_LOCATION);
1424 DALI_TEST_EQUALS(staticFloatValue1, 5.0f, TEST_LOCATION);
1425 DALI_TEST_EQUALS(staticFloatValue2, 6.0f, TEST_LOCATION);
1426 DALI_TEST_EQUALS(result, 5.0f + 6.0f, TEST_LOCATION);
1428 signal.Disconnect(StaticFloatCallbackFloatValueFloatValue);
1429 DALI_TEST_CHECK(signal.Empty());
1431 wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1432 staticFloatValue1 = 0.0f;
1433 staticFloatValue2 = 0.0f;
1434 result = signal.Emit(7.0f, 8.0f);
1435 DALI_TEST_EQUALS(wasStaticFloatCallbackFloatValueFloatValueCalled, false, TEST_LOCATION);
1436 DALI_TEST_EQUALS(staticFloatValue1, 0.0f, TEST_LOCATION);
1437 DALI_TEST_EQUALS(staticFloatValue2, 0.0f, TEST_LOCATION);
1438 DALI_TEST_EQUALS(result, 0.0f, TEST_LOCATION);
1443 int UtcDaliSignalDisconnectDuringCallback(void)
1445 // Test disconnection during each callback
1447 TestSignals::VoidRetNoParamSignal signal;
1448 DALI_TEST_CHECK(signal.Empty());
1450 TestSlotDisconnector handler1;
1451 handler1.VoidConnectVoid(signal);
1452 DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
1453 DALI_TEST_CHECK(!signal.Empty());
1456 DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
1457 DALI_TEST_CHECK(signal.Empty());
1459 // Repeat with 2 callbacks
1461 handler1.mHandled = false;
1463 TestSlotDisconnector handler2;
1464 handler1.VoidConnectVoid(signal);
1465 handler2.VoidConnectVoid(signal);
1466 DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
1467 DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
1468 DALI_TEST_CHECK(!signal.Empty());
1471 DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
1472 DALI_TEST_EQUALS(handler2.mHandled, true, TEST_LOCATION);
1473 DALI_TEST_CHECK(signal.Empty());
1475 // Repeat with no callbacks
1477 handler1.mHandled = false;
1478 handler2.mHandled = false;
1481 DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
1482 DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
1484 // Repeat with 3 callbacks
1486 TestSlotDisconnector handler3;
1487 handler1.VoidConnectVoid(signal);
1488 handler2.VoidConnectVoid(signal);
1489 handler3.VoidConnectVoid(signal);
1490 DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
1491 DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
1492 DALI_TEST_EQUALS(handler3.mHandled, false, TEST_LOCATION);
1493 DALI_TEST_CHECK(!signal.Empty());
1496 DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
1497 DALI_TEST_EQUALS(handler2.mHandled, true, TEST_LOCATION);
1498 DALI_TEST_EQUALS(handler3.mHandled, true, TEST_LOCATION);
1499 DALI_TEST_CHECK(signal.Empty());
1501 // Repeat with no callbacks
1503 handler1.mHandled = false;
1504 handler2.mHandled = false;
1505 handler3.mHandled = false;
1508 DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
1509 DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
1510 DALI_TEST_EQUALS(handler3.mHandled, false, TEST_LOCATION);
1514 int UtcDaliSignalDisconnectDuringCallback2(void)
1516 // Test disconnection of some (but not all) callbacks during sigmal emission
1518 TestSignals::VoidRetNoParamSignal signal;
1519 DALI_TEST_CHECK(signal.Empty());
1521 TestSlotMultiDisconnector handler;
1522 handler.ConnectAll(signal);
1523 DALI_TEST_EQUALS(handler.mSlotHandled[0], false, TEST_LOCATION);
1524 DALI_TEST_EQUALS(handler.mSlotHandled[1], false, TEST_LOCATION);
1525 DALI_TEST_EQUALS(handler.mSlotHandled[2], false, TEST_LOCATION);
1526 DALI_TEST_EQUALS(handler.mSlotHandled[3], false, TEST_LOCATION);
1527 DALI_TEST_EQUALS(handler.mSlotHandled[4], false, TEST_LOCATION);
1528 DALI_TEST_EQUALS(handler.mSlotHandled[5], false, TEST_LOCATION);
1529 DALI_TEST_EQUALS(handler.mSlotHandled[6], false, TEST_LOCATION);
1530 DALI_TEST_EQUALS(handler.mSlotHandled[7], false, TEST_LOCATION);
1531 DALI_TEST_EQUALS(handler.mSlotHandled[8], false, TEST_LOCATION);
1532 DALI_TEST_EQUALS(handler.mSlotHandled[9], false, TEST_LOCATION);
1533 DALI_TEST_CHECK(!signal.Empty());
1537 // Slots 5, 7, & 9 should be disconnected before being called
1538 DALI_TEST_EQUALS(handler.mSlotHandled[0], true, TEST_LOCATION);
1539 DALI_TEST_EQUALS(handler.mSlotHandled[1], true, TEST_LOCATION);
1540 DALI_TEST_EQUALS(handler.mSlotHandled[2], true, TEST_LOCATION);
1541 DALI_TEST_EQUALS(handler.mSlotHandled[3], true, TEST_LOCATION);
1542 DALI_TEST_EQUALS(handler.mSlotHandled[4], true, TEST_LOCATION);
1543 DALI_TEST_EQUALS(handler.mSlotHandled[5], false, TEST_LOCATION);
1544 DALI_TEST_EQUALS(handler.mSlotHandled[6], true, TEST_LOCATION);
1545 DALI_TEST_EQUALS(handler.mSlotHandled[7], false, TEST_LOCATION);
1546 DALI_TEST_EQUALS(handler.mSlotHandled[8], true, TEST_LOCATION);
1547 DALI_TEST_EQUALS(handler.mSlotHandled[9], false, TEST_LOCATION);
1548 DALI_TEST_CHECK(!signal.Empty());
1550 // Odd slots are disconnected
1551 DALI_TEST_EQUALS(handler.GetConnectionCount(), 5u, TEST_LOCATION);
1555 int UtcDaliSignalEmitDuringCallback(void)
1557 TestApplication application; // Create core for debug logging
1559 // for coverage purposes we test the emit guard for each signal type (0,1,2,3 params) void / return value
1561 TestSignals::VoidRetNoParamSignal signal;
1562 DALI_TEST_CHECK(signal.Empty());
1564 TestEmitDuringCallback handler1;
1565 handler1.VoidConnectVoid(signal);
1567 // Test that this does not result in an infinite loop!
1571 TestSignals::FloatRet0ParamSignal signal;
1573 DALI_TEST_CHECK(signal.Empty());
1575 TestEmitDuringCallback handler1;
1576 handler1.FloatRet0ParamConnect(signal);
1578 // Test that this does not result in an infinite loop!
1582 TestSignals::FloatRet1ParamSignal signal;
1584 DALI_TEST_CHECK(signal.Empty());
1586 TestEmitDuringCallback handler1;
1587 handler1.FloatRet1ParamConnect(signal);
1589 // Test that this does not result in an infinite loop!
1593 TestSignals::FloatRet2ValueParamSignal signal;
1595 DALI_TEST_CHECK(signal.Empty());
1597 TestEmitDuringCallback handler1;
1598 handler1.FloatRet2ParamConnect(signal);
1600 // Test that this does not result in an infinite loop!
1601 signal.Emit(1.f, 1.f);
1604 TestSignals::FloatRet3ValueParamSignal signal;
1606 DALI_TEST_CHECK(signal.Empty());
1608 TestEmitDuringCallback handler1;
1609 handler1.FloatRet3ParamConnect(signal);
1611 // Test that this does not result in an infinite loop!
1612 signal.Emit(1.f, 1.f, 1.f);
1617 int UtcDaliSignalDeleteDuringEmit(void)
1619 // testing a signal deletion during an emit
1620 // need to dynamically allocate the signal for this to work
1622 TestApplication application; // Create core for debug logging
1625 TestSignals::VoidRetNoParamSignal* signal = new TestSignals::VoidRetNoParamSignal;
1627 TestEmitDuringCallback handler1;
1628 handler1.DeleteDuringEmitConnect(*signal);
1630 // should just log an error
1635 TestSignals::FloatRet0ParamSignal* signal = new TestSignals::FloatRet0ParamSignal;
1637 TestEmitDuringCallback handler1;
1638 handler1.DeleteDuringEmitConnect(*signal);
1640 // should just log an error
1644 tet_result(TET_PASS);
1649 int UtcDaliSignalTestApp01(void)
1651 // Test 1 signal connected to 1 Slot.
1652 // Signal dies first.
1654 TestButton* button = new TestButton(1);
1656 button->DownSignal().Connect(&app, &TestApp::OnButtonPress);
1658 // check we have both the button, and the app have 1 connection
1659 DALI_TEST_EQUALS(app.GetConnectionCount(), 1u, TEST_LOCATION);
1660 DALI_TEST_EQUALS(button->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
1662 delete button; // should automatically destroy the connection
1664 // check we have a 0 connections
1665 DALI_TEST_EQUALS(app.GetConnectionCount(), 0u, TEST_LOCATION);
1670 int UtcDaliSignalTestApp02(void)
1672 // Test 1 signal connected to 1 Slot.
1673 // Slot owning object dies first.
1675 TestButton button(1);
1676 TestApp* app = new TestApp;
1677 button.DownSignal().Connect(app, &TestApp::OnButtonPress);
1679 // check we have a 1 connection
1680 DALI_TEST_EQUALS(app->GetConnectionCount(), 1u, TEST_LOCATION);
1681 DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
1683 delete app; // should automatically destroy the connection
1685 // check we have a 0 connections
1686 DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION);
1690 int UtcDaliSignalTestApp03(void)
1692 // Test 1 Signal connect to 2 slots
1693 // 1 of the slot owners dies. Then the second slot owner dies
1695 TestButton button(1);
1696 TestApp* app1 = new TestApp;
1697 TestApp* app2 = new TestApp;
1699 button.DownSignal().Connect(app1, &TestApp::OnButtonPress);
1700 button.DownSignal().Connect(app2, &TestApp::OnButtonPress);
1702 // check we have a 2 connections to the signal
1703 DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 2u, TEST_LOCATION);
1705 // kill the first slot
1706 delete app1; // should automatically destroy the connection
1708 // check we have 1 connection left
1709 DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
1711 button.Press(); // emit the signal (to ensure it doesn't seg fault)
1713 // kill the second slot
1714 delete app2; // should automatically destroy the connection
1716 // check we have 1 connection left
1717 DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION);
1722 int UtcDaliSignalTestApp04(void)
1724 // Test 1 Signal connected to 2 slots (with different owners)
1725 // The Signal dies, check the 2 slots disconnect automatically
1727 TestButton* button = new TestButton(1);
1731 button->DownSignal().Connect(&app1, &TestApp::OnButtonPress);
1732 button->DownSignal().Connect(&app2, &TestApp::OnButtonPress);
1734 // check the connection counts
1735 DALI_TEST_EQUALS(app1.GetConnectionCount(), 1u, TEST_LOCATION);
1736 DALI_TEST_EQUALS(app2.GetConnectionCount(), 1u, TEST_LOCATION);
1737 DALI_TEST_EQUALS(button->DownSignal().GetConnectionCount(), 2u, TEST_LOCATION);
1739 delete button; // should automatically destroy the connection
1741 // check both slot owners have zero connections
1742 DALI_TEST_EQUALS(app1.GetConnectionCount(), 0u, TEST_LOCATION);
1743 DALI_TEST_EQUALS(app2.GetConnectionCount(), 0u, TEST_LOCATION);
1747 int UtcDaliSignalTestApp05(void)
1749 // Test 2 Signals (with different owners) connected to 1 slots
1750 // 1 Signal dies, check that the remaining connection is valid
1752 TestButton* button1 = new TestButton(1); // use for signal 1
1753 TestButton* button2 = new TestButton(2); // use for signal 2
1757 button1->DownSignal().Connect(&app, &TestApp::OnButtonPress);
1758 button2->DownSignal().Connect(&app, &TestApp::OnButtonPress);
1760 // check the connection counts
1761 DALI_TEST_EQUALS(app.GetConnectionCount(), 2u, TEST_LOCATION);
1762 DALI_TEST_EQUALS(button1->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
1763 DALI_TEST_EQUALS(button2->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
1765 // make sure both signals emit ok
1767 DALI_TEST_EQUALS(app.GetButtonPressedId(), 2, TEST_LOCATION);
1770 DALI_TEST_EQUALS(app.GetButtonPressedId(), 1, TEST_LOCATION);
1772 delete button1; // should automatically destroy 1 connection
1774 // check both slot owners have zero connections
1775 DALI_TEST_EQUALS(app.GetConnectionCount(), 1u, TEST_LOCATION);
1777 // check remaining connection still works
1779 DALI_TEST_EQUALS(app.GetButtonPressedId(), 2, TEST_LOCATION);
1781 // kill the last signal
1783 DALI_TEST_EQUALS(app.GetConnectionCount(), 0u, TEST_LOCATION);
1787 int UtcDaliSignalTestApp06(void)
1789 Signal<bool()> boolSignal;
1793 // connect a slot which will return false
1794 boolSignal.Connect(&app, &TestApp::BoolReturnTestFalse);
1795 result = boolSignal.Emit();
1796 DALI_TEST_EQUALS(result, false, TEST_LOCATION);
1798 // disconnect last slot, and connect a slot which returns true
1799 boolSignal.Disconnect(&app, &TestApp::BoolReturnTestFalse);
1800 boolSignal.Connect(&app, &TestApp::BoolReturnTestTrue);
1801 result = boolSignal.Emit();
1802 DALI_TEST_EQUALS(result, true, TEST_LOCATION);
1806 int UtcDaliSlotDelegateConnection(void)
1808 TestSignals signals;
1811 TestSlotDelegateHandler handlers;
1812 signals.SignalVoidNone().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
1813 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1814 signals.EmitVoidSignalVoid();
1815 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1817 // Test double emission
1818 handlers.mHandled = false;
1819 signals.EmitVoidSignalVoid();
1820 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1822 signals.CheckNoConnections();
1825 TestSlotDelegateHandler handlers;
1826 signals.SignalVoid1Ref().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
1827 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1829 signals.EmitVoidSignalIntRef(x);
1830 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1831 DALI_TEST_EQUALS(handlers.mIntParam1, 7, TEST_LOCATION);
1833 signals.CheckNoConnections();
1836 TestSlotDelegateHandler handlers;
1837 signals.SignalVoid1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
1838 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1839 signals.EmitVoidSignal1IntValue(5);
1840 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1841 DALI_TEST_EQUALS(handlers.mIntParam1, 5, TEST_LOCATION);
1843 signals.CheckNoConnections();
1846 TestSlotDelegateHandler handlers;
1847 signals.SignalVoid2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
1848 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1849 signals.EmitVoidSignal2IntValue(6, 7);
1850 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1851 DALI_TEST_EQUALS(handlers.mIntParam1, 6, TEST_LOCATION);
1852 DALI_TEST_EQUALS(handlers.mIntParam2, 7, TEST_LOCATION);
1854 signals.CheckNoConnections();
1857 TestSlotDelegateHandler handlers;
1858 signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
1859 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1861 handlers.mBoolReturn = true;
1862 DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION);
1863 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1864 DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
1866 // repeat with opposite return value
1867 handlers.mBoolReturn = false;
1868 handlers.mHandled = false;
1869 DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION);
1870 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1871 DALI_TEST_EQUALS(handlers.mFloatParam1, 6.0f, TEST_LOCATION);
1873 signals.CheckNoConnections();
1876 TestSlotDelegateHandler handlers;
1877 signals.SignalBool2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
1878 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1879 handlers.mBoolReturn = true;
1880 DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION);
1881 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1882 DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
1883 DALI_TEST_EQUALS(handlers.mIntParam2, 10, TEST_LOCATION);
1885 signals.CheckNoConnections();
1888 TestSlotDelegateHandler handlers;
1889 signals.SignalInt2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
1890 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1891 handlers.mIntReturn = 27;
1892 int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
1893 DALI_TEST_EQUALS(x, 27, TEST_LOCATION);
1894 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1895 DALI_TEST_EQUALS(handlers.mFloatParam1, 33.5f, TEST_LOCATION);
1896 DALI_TEST_EQUALS(handlers.mIntParam2, 5, TEST_LOCATION);
1898 signals.CheckNoConnections();
1901 TestSlotDelegateHandler handlers;
1902 signals.SignalFloat0().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
1903 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1904 handlers.mFloatReturn = 27.0f;
1905 float f = signals.EmitFloat0Signal();
1906 DALI_TEST_EQUALS(f, 27.0f, TEST_LOCATION);
1907 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1908 DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
1909 DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
1911 signals.CheckNoConnections();
1914 TestSlotDelegateHandler handlers;
1915 signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
1916 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1917 handlers.mFloatReturn = 27.0f;
1918 float f = signals.EmitFloat2VSignal(5, 33.0f);
1919 DALI_TEST_EQUALS(f, 27.0f, TEST_LOCATION);
1920 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1921 DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
1922 DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
1924 signals.CheckNoConnections();
1927 TestSlotDelegateHandler handlers;
1928 signals.VoidSignalFloatValue3().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotFloatValue3);
1929 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1930 signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
1931 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1932 DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
1933 DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
1934 DALI_TEST_EQUALS(handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION);
1936 signals.CheckNoConnections();
1939 TestSlotDelegateHandler handlers;
1940 signals.SignalFloat3Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValue3);
1941 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1942 handlers.mFloatReturn = 27.0f;
1943 float returnValue = signals.EmitFloat3VSignal(5, 33.0f, 100.0f);
1944 DALI_TEST_EQUALS(returnValue, 27.0f, TEST_LOCATION);
1945 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1946 DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
1947 DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
1948 DALI_TEST_EQUALS(handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION);
1950 signals.CheckNoConnections();
1954 int UtcDaliSignalSlotDelegateDestruction(void)
1956 // Test that signal disconnect works when slot-delegate is destroyed (goes out of scope)
1959 TestSignals::VoidRetNoParamSignal signal;
1961 DALI_TEST_CHECK(signal.Empty());
1962 TestSlotDelegateHandler handler;
1963 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
1964 DALI_TEST_CHECK(!signal.Empty());
1966 // End of slot lifetime
1967 DALI_TEST_CHECK(signal.Empty());
1969 // Signal emission should be a NOOP
1974 TestSignals::VoidRet1ValueParamSignal signal;
1976 DALI_TEST_CHECK(signal.Empty());
1977 TestSlotDelegateHandler handler;
1978 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
1979 DALI_TEST_CHECK(!signal.Empty());
1981 // End of slot lifetime
1982 DALI_TEST_CHECK(signal.Empty());
1984 // Signal emission should be a NOOP
1989 TestSignals::VoidRet1RefParamSignal signal;
1991 DALI_TEST_CHECK(signal.Empty());
1992 TestSlotDelegateHandler handler;
1993 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
1994 DALI_TEST_CHECK(!signal.Empty());
1996 // End of slot lifetime
1997 DALI_TEST_CHECK(signal.Empty());
1999 // Signal emission should be a NOOP
2005 TestSignals::VoidRet2ValueParamSignal signal;
2007 DALI_TEST_CHECK(signal.Empty());
2008 TestSlotDelegateHandler handler;
2009 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
2010 DALI_TEST_CHECK(!signal.Empty());
2012 // End of slot lifetime
2013 DALI_TEST_CHECK(signal.Empty());
2015 // Signal emission should be a NOOP
2020 TestSignals::BoolRet1ValueParamSignal signal;
2022 DALI_TEST_CHECK(signal.Empty());
2023 TestSlotDelegateHandler handler;
2024 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2025 DALI_TEST_CHECK(!signal.Empty());
2027 // End of slot lifetime
2028 DALI_TEST_CHECK(signal.Empty());
2030 // Signal emission should be a NOOP
2031 bool blah = signal.Emit(1.0f);
2032 DALI_TEST_CHECK(!blah);
2036 TestSignals::BoolRet2ValueParamSignal signal;
2038 DALI_TEST_CHECK(signal.Empty());
2039 TestSlotDelegateHandler handler;
2040 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2041 DALI_TEST_CHECK(!signal.Empty());
2043 // End of slot lifetime
2044 DALI_TEST_CHECK(signal.Empty());
2046 // Signal emission should be a NOOP
2047 bool blah = signal.Emit(1.0f, 2);
2048 DALI_TEST_CHECK(!blah);
2052 TestSignals::IntRet2ValueParamSignal signal;
2054 DALI_TEST_CHECK(signal.Empty());
2055 TestSlotDelegateHandler handler;
2056 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2057 DALI_TEST_CHECK(!signal.Empty());
2059 // End of slot lifetime
2060 DALI_TEST_CHECK(signal.Empty());
2062 // Signal emission should be a NOOP
2063 int blah = signal.Emit(10.0f, 100);
2064 DALI_TEST_CHECK(0 == blah);
2068 TestSignals::FloatRet0ParamSignal signal;
2070 DALI_TEST_CHECK(signal.Empty());
2071 TestSlotDelegateHandler handler;
2072 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2073 DALI_TEST_CHECK(!signal.Empty());
2075 // End of slot lifetime
2076 DALI_TEST_CHECK(signal.Empty());
2078 // Signal emission should be a NOOP
2079 float blah = signal.Emit();
2080 DALI_TEST_CHECK(0.0f == blah);
2084 TestSignals::FloatRet2ValueParamSignal signal;
2086 DALI_TEST_CHECK(signal.Empty());
2087 TestSlotDelegateHandler handler;
2088 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2089 DALI_TEST_CHECK(!signal.Empty());
2091 // End of slot lifetime
2092 DALI_TEST_CHECK(signal.Empty());
2094 // Signal emission should be a NOOP
2095 float blah = signal.Emit(3.0f, 4.0f);
2096 DALI_TEST_CHECK(0.0f == blah);
2101 int UtcDaliSlotHandlerDisconnect(void)
2103 // Test that callbacks don't occur if a signal is disconnected before emission
2105 TestSignals signals;
2108 TestSlotDelegateHandler handlers;
2109 signals.SignalVoidNone().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
2110 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2111 signals.SignalVoidNone().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
2112 signals.EmitVoidSignalVoid();
2113 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2117 TestSlotDelegateHandler handlers;
2118 signals.SignalVoid1Ref().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
2119 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2121 handlers.mIntReturn = 5;
2122 signals.SignalVoid1Ref().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
2123 signals.EmitVoidSignalIntRef(r);
2124 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2125 DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
2126 DALI_TEST_EQUALS(r, 7, TEST_LOCATION);
2130 TestSlotDelegateHandler handlers;
2131 signals.SignalVoid1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
2132 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2133 signals.SignalVoid1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
2134 signals.EmitVoidSignal1IntValue(5);
2135 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2136 DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
2140 TestSlotDelegateHandler handlers;
2141 signals.SignalVoid2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
2142 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2143 signals.SignalVoid2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
2144 signals.EmitVoidSignal2IntValue(5, 10);
2145 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2146 DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
2147 DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
2151 TestSlotDelegateHandler handlers;
2152 signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2153 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2154 handlers.mBoolReturn = true;
2155 signals.SignalBool1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2156 DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION);
2157 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2158 DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
2162 TestSlotDelegateHandler handlers;
2163 signals.SignalBool2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2164 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2165 handlers.mBoolReturn = true;
2166 signals.SignalBool2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2167 DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION);
2168 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2169 DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
2170 DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
2174 TestSlotDelegateHandler handlers;
2175 signals.SignalInt2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2176 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2177 handlers.mIntReturn = 27;
2178 signals.SignalInt2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2179 signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
2180 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2181 DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
2182 DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
2186 TestSlotDelegateHandler handlers;
2187 signals.SignalFloat0().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2188 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2189 handlers.mFloatReturn = 27.0f;
2190 signals.SignalFloat0().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2191 signals.EmitFloat0Signal();
2192 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2193 DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
2194 DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
2198 TestSlotDelegateHandler handlers;
2199 signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2200 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2201 handlers.mFloatReturn = 27.0f;
2202 signals.SignalFloat2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2203 signals.EmitFloat2VSignal(5, 33.0f);
2204 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2205 DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
2206 DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
2211 int UtcDaliCallbackBase(void)
2213 // simple constructor for coverage
2215 tet_result(TET_PASS);
2219 int UtcDaliSlotDelegateMethods(void)
2221 TestSignals signals;
2223 TestSlotDelegateHandler handlers;
2224 DALI_TEST_EQUALS(0, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION);
2225 signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2226 DALI_TEST_EQUALS(1, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION);
2227 signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2228 DALI_TEST_EQUALS(2, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION);
2230 handlers.mSlotDelegate.DisconnectAll();
2231 DALI_TEST_EQUALS(0, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION);