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
1624 TestSignals::VoidRetNoParamSignal* signal = new TestSignals::VoidRetNoParamSignal;
1626 TestEmitDuringCallback handler1;
1627 handler1.DeleteDuringEmitConnect(*signal);
1629 // should just log an error
1632 tet_result(TET_PASS);
1637 int UtcDaliSignalTestApp01(void)
1639 // Test 1 signal connected to 1 Slot.
1640 // Signal dies first.
1642 TestButton* button = new TestButton(1);
1644 button->DownSignal().Connect(&app, &TestApp::OnButtonPress);
1646 // check we have both the button, and the app have 1 connection
1647 DALI_TEST_EQUALS(app.GetConnectionCount(), 1u, TEST_LOCATION);
1648 DALI_TEST_EQUALS(button->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
1650 delete button; // should automatically destroy the connection
1652 // check we have a 0 connections
1653 DALI_TEST_EQUALS(app.GetConnectionCount(), 0u, TEST_LOCATION);
1658 int UtcDaliSignalTestApp02(void)
1660 // Test 1 signal connected to 1 Slot.
1661 // Slot owning object dies first.
1663 TestButton button(1);
1664 TestApp* app = new TestApp;
1665 button.DownSignal().Connect(app, &TestApp::OnButtonPress);
1667 // check we have a 1 connection
1668 DALI_TEST_EQUALS(app->GetConnectionCount(), 1u, TEST_LOCATION);
1669 DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
1671 delete app; // should automatically destroy the connection
1673 // check we have a 0 connections
1674 DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION);
1678 int UtcDaliSignalTestApp03(void)
1680 // Test 1 Signal connect to 2 slots
1681 // 1 of the slot owners dies. Then the second slot owner dies
1683 TestButton button(1);
1684 TestApp* app1 = new TestApp;
1685 TestApp* app2 = new TestApp;
1687 button.DownSignal().Connect(app1, &TestApp::OnButtonPress);
1688 button.DownSignal().Connect(app2, &TestApp::OnButtonPress);
1690 // check we have a 2 connections to the signal
1691 DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 2u, TEST_LOCATION);
1693 // kill the first slot
1694 delete app1; // should automatically destroy the connection
1696 // check we have 1 connection left
1697 DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
1699 button.Press(); // emit the signal (to ensure it doesn't seg fault)
1701 // kill the second slot
1702 delete app2; // should automatically destroy the connection
1704 // check we have 1 connection left
1705 DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION);
1710 int UtcDaliSignalTestApp04(void)
1712 // Test 1 Signal connected to 2 slots (with different owners)
1713 // The Signal dies, check the 2 slots disconnect automatically
1715 TestButton* button = new TestButton(1);
1719 button->DownSignal().Connect(&app1, &TestApp::OnButtonPress);
1720 button->DownSignal().Connect(&app2, &TestApp::OnButtonPress);
1722 // check the connection counts
1723 DALI_TEST_EQUALS(app1.GetConnectionCount(), 1u, TEST_LOCATION);
1724 DALI_TEST_EQUALS(app2.GetConnectionCount(), 1u, TEST_LOCATION);
1725 DALI_TEST_EQUALS(button->DownSignal().GetConnectionCount(), 2u, TEST_LOCATION);
1727 delete button; // should automatically destroy the connection
1729 // check both slot owners have zero connections
1730 DALI_TEST_EQUALS(app1.GetConnectionCount(), 0u, TEST_LOCATION);
1731 DALI_TEST_EQUALS(app2.GetConnectionCount(), 0u, TEST_LOCATION);
1735 int UtcDaliSignalTestApp05(void)
1737 // Test 2 Signals (with different owners) connected to 1 slots
1738 // 1 Signal dies, check that the remaining connection is valid
1740 TestButton* button1 = new TestButton(1); // use for signal 1
1741 TestButton* button2 = new TestButton(2); // use for signal 2
1745 button1->DownSignal().Connect(&app, &TestApp::OnButtonPress);
1746 button2->DownSignal().Connect(&app, &TestApp::OnButtonPress);
1748 // check the connection counts
1749 DALI_TEST_EQUALS(app.GetConnectionCount(), 2u, TEST_LOCATION);
1750 DALI_TEST_EQUALS(button1->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
1751 DALI_TEST_EQUALS(button2->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
1753 // make sure both signals emit ok
1755 DALI_TEST_EQUALS(app.GetButtonPressedId(), 2, TEST_LOCATION);
1758 DALI_TEST_EQUALS(app.GetButtonPressedId(), 1, TEST_LOCATION);
1760 delete button1; // should automatically destroy 1 connection
1762 // check both slot owners have zero connections
1763 DALI_TEST_EQUALS(app.GetConnectionCount(), 1u, TEST_LOCATION);
1765 // check remaining connection still works
1767 DALI_TEST_EQUALS(app.GetButtonPressedId(), 2, TEST_LOCATION);
1769 // kill the last signal
1771 DALI_TEST_EQUALS(app.GetConnectionCount(), 0u, TEST_LOCATION);
1775 int UtcDaliSignalTestApp06(void)
1777 Signal<bool()> boolSignal;
1781 // connect a slot which will return false
1782 boolSignal.Connect(&app, &TestApp::BoolReturnTestFalse);
1783 result = boolSignal.Emit();
1784 DALI_TEST_EQUALS(result, false, TEST_LOCATION);
1786 // disconnect last slot, and connect a slot which returns true
1787 boolSignal.Disconnect(&app, &TestApp::BoolReturnTestFalse);
1788 boolSignal.Connect(&app, &TestApp::BoolReturnTestTrue);
1789 result = boolSignal.Emit();
1790 DALI_TEST_EQUALS(result, true, TEST_LOCATION);
1794 int UtcDaliSlotDelegateConnection(void)
1796 TestSignals signals;
1799 TestSlotDelegateHandler handlers;
1800 signals.SignalVoidNone().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
1801 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1802 signals.EmitVoidSignalVoid();
1803 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1805 // Test double emission
1806 handlers.mHandled = false;
1807 signals.EmitVoidSignalVoid();
1808 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1810 signals.CheckNoConnections();
1813 TestSlotDelegateHandler handlers;
1814 signals.SignalVoid1Ref().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
1815 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1817 signals.EmitVoidSignalIntRef(x);
1818 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1819 DALI_TEST_EQUALS(handlers.mIntParam1, 7, TEST_LOCATION);
1821 signals.CheckNoConnections();
1824 TestSlotDelegateHandler handlers;
1825 signals.SignalVoid1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
1826 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1827 signals.EmitVoidSignal1IntValue(5);
1828 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1829 DALI_TEST_EQUALS(handlers.mIntParam1, 5, TEST_LOCATION);
1831 signals.CheckNoConnections();
1834 TestSlotDelegateHandler handlers;
1835 signals.SignalVoid2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
1836 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1837 signals.EmitVoidSignal2IntValue(6, 7);
1838 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1839 DALI_TEST_EQUALS(handlers.mIntParam1, 6, TEST_LOCATION);
1840 DALI_TEST_EQUALS(handlers.mIntParam2, 7, TEST_LOCATION);
1842 signals.CheckNoConnections();
1845 TestSlotDelegateHandler handlers;
1846 signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
1847 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1849 handlers.mBoolReturn = true;
1850 DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION);
1851 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1852 DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
1854 // repeat with opposite return value
1855 handlers.mBoolReturn = false;
1856 handlers.mHandled = false;
1857 DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION);
1858 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1859 DALI_TEST_EQUALS(handlers.mFloatParam1, 6.0f, TEST_LOCATION);
1861 signals.CheckNoConnections();
1864 TestSlotDelegateHandler handlers;
1865 signals.SignalBool2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
1866 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1867 handlers.mBoolReturn = true;
1868 DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION);
1869 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1870 DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
1871 DALI_TEST_EQUALS(handlers.mIntParam2, 10, TEST_LOCATION);
1873 signals.CheckNoConnections();
1876 TestSlotDelegateHandler handlers;
1877 signals.SignalInt2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
1878 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1879 handlers.mIntReturn = 27;
1880 int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
1881 DALI_TEST_EQUALS(x, 27, TEST_LOCATION);
1882 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1883 DALI_TEST_EQUALS(handlers.mFloatParam1, 33.5f, TEST_LOCATION);
1884 DALI_TEST_EQUALS(handlers.mIntParam2, 5, TEST_LOCATION);
1886 signals.CheckNoConnections();
1889 TestSlotDelegateHandler handlers;
1890 signals.SignalFloat0().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
1891 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1892 handlers.mFloatReturn = 27.0f;
1893 float f = signals.EmitFloat0Signal();
1894 DALI_TEST_EQUALS(f, 27.0f, TEST_LOCATION);
1895 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1896 DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
1897 DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
1899 signals.CheckNoConnections();
1902 TestSlotDelegateHandler handlers;
1903 signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
1904 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1905 handlers.mFloatReturn = 27.0f;
1906 float f = signals.EmitFloat2VSignal(5, 33.0f);
1907 DALI_TEST_EQUALS(f, 27.0f, TEST_LOCATION);
1908 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1909 DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
1910 DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
1912 signals.CheckNoConnections();
1915 TestSlotDelegateHandler handlers;
1916 signals.VoidSignalFloatValue3().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotFloatValue3);
1917 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1918 signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
1919 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1920 DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
1921 DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
1922 DALI_TEST_EQUALS(handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION);
1924 signals.CheckNoConnections();
1927 TestSlotDelegateHandler handlers;
1928 signals.SignalFloat3Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValue3);
1929 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1930 handlers.mFloatReturn = 27.0f;
1931 float returnValue = signals.EmitFloat3VSignal(5, 33.0f, 100.0f);
1932 DALI_TEST_EQUALS(returnValue, 27.0f, TEST_LOCATION);
1933 DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1934 DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
1935 DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
1936 DALI_TEST_EQUALS(handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION);
1938 signals.CheckNoConnections();
1942 int UtcDaliSignalSlotDelegateDestruction(void)
1944 // Test that signal disconnect works when slot-delegate is destroyed (goes out of scope)
1947 TestSignals::VoidRetNoParamSignal signal;
1949 DALI_TEST_CHECK(signal.Empty());
1950 TestSlotDelegateHandler handler;
1951 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
1952 DALI_TEST_CHECK(!signal.Empty());
1954 // End of slot lifetime
1955 DALI_TEST_CHECK(signal.Empty());
1957 // Signal emission should be a NOOP
1962 TestSignals::VoidRet1ValueParamSignal signal;
1964 DALI_TEST_CHECK(signal.Empty());
1965 TestSlotDelegateHandler handler;
1966 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
1967 DALI_TEST_CHECK(!signal.Empty());
1969 // End of slot lifetime
1970 DALI_TEST_CHECK(signal.Empty());
1972 // Signal emission should be a NOOP
1977 TestSignals::VoidRet1RefParamSignal signal;
1979 DALI_TEST_CHECK(signal.Empty());
1980 TestSlotDelegateHandler handler;
1981 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
1982 DALI_TEST_CHECK(!signal.Empty());
1984 // End of slot lifetime
1985 DALI_TEST_CHECK(signal.Empty());
1987 // Signal emission should be a NOOP
1993 TestSignals::VoidRet2ValueParamSignal signal;
1995 DALI_TEST_CHECK(signal.Empty());
1996 TestSlotDelegateHandler handler;
1997 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
1998 DALI_TEST_CHECK(!signal.Empty());
2000 // End of slot lifetime
2001 DALI_TEST_CHECK(signal.Empty());
2003 // Signal emission should be a NOOP
2008 TestSignals::BoolRet1ValueParamSignal signal;
2010 DALI_TEST_CHECK(signal.Empty());
2011 TestSlotDelegateHandler handler;
2012 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2013 DALI_TEST_CHECK(!signal.Empty());
2015 // End of slot lifetime
2016 DALI_TEST_CHECK(signal.Empty());
2018 // Signal emission should be a NOOP
2019 bool blah = signal.Emit(1.0f);
2020 DALI_TEST_CHECK(!blah);
2024 TestSignals::BoolRet2ValueParamSignal signal;
2026 DALI_TEST_CHECK(signal.Empty());
2027 TestSlotDelegateHandler handler;
2028 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2029 DALI_TEST_CHECK(!signal.Empty());
2031 // End of slot lifetime
2032 DALI_TEST_CHECK(signal.Empty());
2034 // Signal emission should be a NOOP
2035 bool blah = signal.Emit(1.0f, 2);
2036 DALI_TEST_CHECK(!blah);
2040 TestSignals::IntRet2ValueParamSignal signal;
2042 DALI_TEST_CHECK(signal.Empty());
2043 TestSlotDelegateHandler handler;
2044 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2045 DALI_TEST_CHECK(!signal.Empty());
2047 // End of slot lifetime
2048 DALI_TEST_CHECK(signal.Empty());
2050 // Signal emission should be a NOOP
2051 int blah = signal.Emit(10.0f, 100);
2052 DALI_TEST_CHECK(0 == blah);
2056 TestSignals::FloatRet0ParamSignal signal;
2058 DALI_TEST_CHECK(signal.Empty());
2059 TestSlotDelegateHandler handler;
2060 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2061 DALI_TEST_CHECK(!signal.Empty());
2063 // End of slot lifetime
2064 DALI_TEST_CHECK(signal.Empty());
2066 // Signal emission should be a NOOP
2067 float blah = signal.Emit();
2068 DALI_TEST_CHECK(0.0f == blah);
2072 TestSignals::FloatRet2ValueParamSignal signal;
2074 DALI_TEST_CHECK(signal.Empty());
2075 TestSlotDelegateHandler handler;
2076 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2077 DALI_TEST_CHECK(!signal.Empty());
2079 // End of slot lifetime
2080 DALI_TEST_CHECK(signal.Empty());
2082 // Signal emission should be a NOOP
2083 float blah = signal.Emit(3.0f, 4.0f);
2084 DALI_TEST_CHECK(0.0f == blah);
2089 int UtcDaliSlotHandlerDisconnect(void)
2091 // Test that callbacks don't occur if a signal is disconnected before emission
2093 TestSignals signals;
2096 TestSlotDelegateHandler handlers;
2097 signals.SignalVoidNone().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
2098 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2099 signals.SignalVoidNone().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
2100 signals.EmitVoidSignalVoid();
2101 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2105 TestSlotDelegateHandler handlers;
2106 signals.SignalVoid1Ref().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
2107 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2109 handlers.mIntReturn = 5;
2110 signals.SignalVoid1Ref().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
2111 signals.EmitVoidSignalIntRef(r);
2112 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2113 DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
2114 DALI_TEST_EQUALS(r, 7, TEST_LOCATION);
2118 TestSlotDelegateHandler handlers;
2119 signals.SignalVoid1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
2120 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2121 signals.SignalVoid1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
2122 signals.EmitVoidSignal1IntValue(5);
2123 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2124 DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
2128 TestSlotDelegateHandler handlers;
2129 signals.SignalVoid2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
2130 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2131 signals.SignalVoid2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
2132 signals.EmitVoidSignal2IntValue(5, 10);
2133 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2134 DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
2135 DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
2139 TestSlotDelegateHandler handlers;
2140 signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2141 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2142 handlers.mBoolReturn = true;
2143 signals.SignalBool1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2144 DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION);
2145 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2146 DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
2150 TestSlotDelegateHandler handlers;
2151 signals.SignalBool2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2152 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2153 handlers.mBoolReturn = true;
2154 signals.SignalBool2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2155 DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION);
2156 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2157 DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
2158 DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
2162 TestSlotDelegateHandler handlers;
2163 signals.SignalInt2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2164 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2165 handlers.mIntReturn = 27;
2166 signals.SignalInt2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2167 signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
2168 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2169 DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
2170 DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
2174 TestSlotDelegateHandler handlers;
2175 signals.SignalFloat0().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2176 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2177 handlers.mFloatReturn = 27.0f;
2178 signals.SignalFloat0().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2179 signals.EmitFloat0Signal();
2180 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2181 DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
2182 DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
2186 TestSlotDelegateHandler handlers;
2187 signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2188 DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2189 handlers.mFloatReturn = 27.0f;
2190 signals.SignalFloat2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2191 signals.EmitFloat2VSignal(5, 33.0f);
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);
2199 int UtcDaliCallbackBase(void)
2201 // simple constructor for coverage
2203 tet_result(TET_PASS);
2207 int UtcDaliSlotDelegateMethods(void)
2209 TestSignals signals;
2211 TestSlotDelegateHandler handlers;
2212 DALI_TEST_EQUALS(0, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION);
2213 signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2214 DALI_TEST_EQUALS(1, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION);
2215 signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2216 DALI_TEST_EQUALS(2, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION);
2218 handlers.mSlotDelegate.DisconnectAll();
2219 DALI_TEST_EQUALS(0, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION);