2 * Copyright (c) 2014 Samsung Electronics Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
23 #include <dali/public-api/dali-core.h>
24 #include <dali-test-suite-utils.h>
25 #include "signal-helper.h"
29 void utc_dali_signal_templates_startup(void)
31 test_return_value = TET_UNDEF;
34 void utc_dali_signal_templates_cleanup(void)
36 test_return_value = TET_PASS;
42 bool wasStaticVoidCallbackVoidCalled = false;
43 bool wasStaticFloatCallbackVoidCalled = false;
44 bool wasStaticVoidCallbackIntValueCalled = false;
45 int staticIntValue = 0;
46 bool wasStaticFloatCallbackFloatValueFloatValueCalled = false;
47 float staticFloatValue1 = 0.0f;
48 float staticFloatValue2 = 0.0f;
50 void StaticVoidCallbackVoid()
52 wasStaticVoidCallbackVoidCalled = true;
55 void AlternativeVoidCallbackVoid()
59 float StaticFloatCallbackVoid()
61 wasStaticFloatCallbackVoidCalled = true;
65 void StaticVoidCallbackIntValue( int value )
67 wasStaticVoidCallbackIntValueCalled = true;
68 staticIntValue = value;
71 float StaticFloatCallbackFloatValueFloatValue( float value1, float value2 )
73 wasStaticFloatCallbackFloatValueFloatValueCalled = true;
74 staticFloatValue1 = value1;
75 staticFloatValue2 = value2;
76 return value1 + value2;
83 /*******************************************
85 * Start of Utc test cases.
86 * Test cases performed in order of API listed in dali-signal.h
87 * UtcDaliSignal + FunctionName + P=positive test, N = Negative test
91 int UtcDaliSignalEmptyP(void)
93 TestApplication app; // Create core for debug logging
95 // Test that Empty() is true, when no slots connected to the signal
98 TestSignals::VoidRetNoParamSignal signal;
99 DALI_TEST_CHECK( signal.Empty() );
102 // Test that Empty() is true, when a slot has connected and disconnected
104 TestSignals::VoidRetNoParamSignal signal;
105 TestSlotHandler handler;
106 signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
107 signal.Disconnect( &handler, &TestSlotHandler::VoidSlotVoid );
108 DALI_TEST_CHECK( signal.Empty() );
114 int UtcDaliSignalEmptyN(void)
116 TestApplication app; // Create core for debug logging
118 // Test that Empty() is false after signal connection
119 TestSignals::VoidRetNoParamSignal signal;
120 TestSlotHandler handler;
121 signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
122 DALI_TEST_CHECK( ! signal.Empty() );
127 int UtcDaliSignalGetConnectionCountP(void)
129 TestApplication app; // Create core for debug logging
131 TestSignals::VoidRetNoParamSignal signal;
132 TestSlotHandler handler;
133 signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
134 DALI_TEST_CHECK( signal.GetConnectionCount() == 1 );
136 TestSlotHandler handler2;
137 signal.Connect( &handler2, &TestSlotHandler::VoidSlotVoid );
138 DALI_TEST_CHECK( signal.GetConnectionCount() == 2 );
143 int UtcDaliSignalGetConnectionCountN(void)
145 TestApplication app; // Create core for debug logging
146 TestSignals::VoidRetNoParamSignal signal;
147 DALI_TEST_CHECK( signal.GetConnectionCount() == 0 );
152 * there are 5 different connection functions
153 * we go through them here in order of definition in dali-signal.h
155 int UtcDaliSignalConnectP01(void)
157 TestApplication app; // Create core for debug logging
159 // test static function: void Connect( void (*func)() )
160 TestSignals::VoidRetNoParamSignal signal;
161 signal.Connect( StaticVoidCallbackVoid );
162 DALI_TEST_CHECK( ! signal.Empty() );
168 int UtcDaliSignalConnectN01(void)
170 // difficult to perform a negative test on Connect as no checks are performed
171 // when creating a callback for a null function ( during Connect).
172 // so we test an assert on Emit
173 TestApplication app; // Create core for debug logging
175 TestSignals::VoidRetNoParamSignal signal;
176 signal.Connect( NULL );
181 catch (Dali::DaliException& e)
183 // Tests that a negative test of an assertion succeeds
184 DALI_TEST_PRINT_ASSERT( e );
185 tet_result(TET_PASS);
191 int UtcDaliSignalConnectP02(void)
193 TestApplication app; // Create core for debug logging
195 // test member function: Connect( X* obj, void (X::*func)() ))
196 TestSignals::VoidRetNoParamSignal signal;
197 TestSlotHandler handler;
198 signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
199 DALI_TEST_CHECK( ! signal.Empty() );
201 DALI_TEST_CHECK( handler.mHandled == true );
205 int UtcDaliSignalConnectN02(void)
207 TestApplication app; // Create core for debug logging
209 TestSignals::VoidRetNoParamSignal signal;
212 // test member function: Connect( X* obj, void (X::*func)() )) with NULL object
213 signal.Connect( static_cast<TestSlotHandler*>(NULL), &TestSlotHandler::VoidSlotVoid );
215 catch (Dali::DaliException& e)
217 // Tests that a negative test of an assertion succeeds
218 DALI_TEST_PRINT_ASSERT( e );
219 tet_result(TET_PASS);
225 int UtcDaliSignalConnectP03(void)
227 TestApplication app; // Create core for debug logging
229 // test slot delegate: Connect( SlotDelegate<X>& delegate, void (X::*func)() )
230 TestSignals::VoidRetNoParamSignal signal;
231 TestSlotDelegateHandler handler;
232 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
233 DALI_TEST_CHECK( ! signal.Empty() );
235 DALI_TEST_CHECK( handler.mHandled == true );
240 int UtcDaliSignalConnectN03(void)
242 TestApplication app; // Create core for debug logging
243 // the delegate is passed by reference, so you can't pass null.
244 tet_result( TET_PASS );
248 int UtcDaliSignalConnectP04(void)
250 TestApplication app; // Create core for debug logging
252 // test function object: Connect( ConnectionTrackerInterface* connectionTracker, const X& func )
253 TestSlotHandler handler;
254 TestSignals::VoidRetNoParamSignal signal;
255 bool functorCalled(false);
256 TestFunctor functor( functorCalled );
257 signal.Connect( &handler, functor );
258 DALI_TEST_CHECK( ! signal.Empty() );
260 DALI_TEST_CHECK( functorCalled == true );
265 int UtcDaliSignalConnectN04(void)
267 // for negative test we try to connect a null connection tracker to the signal
268 TestSignals::VoidRetNoParamSignal signal;
269 TestSlotHandler *nullHandler( NULL );
272 signal.Connect( nullHandler , &TestSlotHandler::VoidSlotVoid );
274 catch (Dali::DaliException& e)
276 // Tests that a negative test of an assertion succeeds
277 DALI_TEST_PRINT_ASSERT( e );
278 tet_result( TET_PASS );
285 int UtcDaliSignalConnectP05(void)
287 TestApplication app; // Create core for debug logging
289 // test function object using FunctorDelegate.
290 // :Connect( ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate )
291 TestSlotHandler handler;
292 TestSignals::VoidRetNoParamSignal signal;
293 bool functorDelegateCalled(false);
294 signal.Connect( &handler, FunctorDelegate::New( VoidFunctorVoid(functorDelegateCalled) ));
295 DALI_TEST_CHECK( ! signal.Empty() );
297 DALI_TEST_CHECK( functorDelegateCalled == true );
302 int UtcDaliSignalConnectN05(void)
304 TestApplication app; // Create core for debug logging
306 // for negative test we try to connect a null connection tracker to the signal
307 // :Connect( ConnectionTrackerInterface == NULL, FunctorDelegate* delegate )
308 TestSlotHandler *nullHandler( NULL );
309 TestSignals::VoidRetNoParamSignal signal;
310 bool functorDelegateCalled(false);
313 signal.Connect( nullHandler, FunctorDelegate::New( VoidFunctorVoid(functorDelegateCalled) ));
315 catch (Dali::DaliException& e)
317 DALI_TEST_PRINT_ASSERT( e );
318 tet_result( TET_PASS );
325 * there 3 different disconnect functions
326 * we go through them here in order of definition in dali-signal.h
328 int UtcDaliSignalDisconnectP01(void)
330 TestApplication app; // Create core for debug logging
332 // test static function: Disconnect( void (*func)( Arg0 arg0 ) )
334 TestSignals::VoidRetNoParamSignal signal;
335 signal.Connect( StaticVoidCallbackVoid );
336 DALI_TEST_CHECK( ! signal.Empty() );
337 signal.Disconnect( StaticVoidCallbackVoid );
338 DALI_TEST_CHECK( signal.Empty() );
343 int UtcDaliSignalDisconnectN01(void)
345 TestApplication app; // Create core for debug logging
347 // 1. Disconnect using the function
348 TestSignals::VoidRetNoParamSignal signal;
349 signal.Connect( StaticVoidCallbackVoid );
350 DALI_TEST_CHECK( ! signal.Empty() );
352 signal.Disconnect( AlternativeVoidCallbackVoid );
354 DALI_TEST_CHECK( ! signal.Empty() );
359 int UtcDaliSignalDisconnectP02(void)
361 TestApplication app; // Create core for debug logging
363 // test member function: Disconnect( X* obj, void (X::*func)( Arg0 arg0 ) )
364 TestSignals::VoidRetNoParamSignal signal;
365 TestSlotHandler handler;
366 signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
367 DALI_TEST_CHECK( ! signal.Empty() );
368 signal.Disconnect( &handler, &TestSlotHandler::VoidSlotVoid );
369 DALI_TEST_CHECK( signal.Empty() );
374 int UtcDaliSignalDisconnectN02(void)
376 TestApplication app; // Create core for debug logging
378 // 1. Disconnect using a null connection tracker
379 TestSignals::VoidRetNoParamSignal signal;
380 TestSlotHandler handler;
382 signal.Connect( &handler , &TestSlotHandler::VoidSlotVoid );
383 DALI_TEST_CHECK( !signal.Empty() );
387 TestSlotHandler* nullHandler( NULL );
388 signal.Disconnect( nullHandler , &TestSlotHandler::VoidSlotVoid );
390 catch(Dali::DaliException& e)
392 // Tests that a negative test of an assertion succeeds
393 DALI_TEST_PRINT_ASSERT( e );
394 DALI_TEST_CHECK( !signal.Empty() );
399 int UtcDaliSignalDisconnectP03(void)
401 TestApplication app; // Create core for debug logging
403 // test slot delegate: Disconnect( SlotDelegate<X>& delegate, void (X::*func)( Arg0 arg0 ) )
404 TestSignals::VoidRetNoParamSignal signal;
405 TestSlotDelegateHandler handler;
406 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
407 DALI_TEST_CHECK( ! signal.Empty() );
408 signal.Disconnect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
409 DALI_TEST_CHECK( signal.Empty() );
414 int UtcDaliSignalDisconnectN03(void)
416 TestApplication app; // Create core for debug logging
418 // try to disconnect from the wrong signal
419 TestSignals::VoidRetNoParamSignal signal;
420 TestSlotDelegateHandler handler;
421 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
423 // use different signal
424 signal.Disconnect( handler.mSlotDelegate , &TestSlotDelegateHandler::AlternativeVoidSlotVoid );
426 DALI_TEST_CHECK( !signal.Empty() );
432 /*******************************************
434 * End of Utc test cases for the individual API's of Signals
435 * The following testing Signals functionality as a whole
440 int UtcDaliSignalEmptyCheckSlotDestruction(void)
442 // Test that signal disconnect works when slot is destroyed (goes out of scope)
444 TestSignals::VoidRetNoParamSignal signal;
446 DALI_TEST_CHECK( signal.Empty() );
447 TestSlotHandler handler;
448 signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
449 DALI_TEST_CHECK( ! signal.Empty() );
451 // End of slot lifetime
452 DALI_TEST_CHECK( signal.Empty() );
454 // Signal emission should be a NOOP
459 TestSignals::VoidRet1ValueParamSignal signal;
461 DALI_TEST_CHECK( signal.Empty() );
462 TestSlotHandler handler;
463 signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValue );
464 DALI_TEST_CHECK( ! signal.Empty() );
466 // End of slot lifetime
467 DALI_TEST_CHECK( signal.Empty() );
469 // Signal emission should be a NOOP
474 TestSignals::VoidRet1RefParamSignal signal;
476 DALI_TEST_CHECK( signal.Empty() );
477 TestSlotHandler handler;
478 signal.Connect( &handler, &TestSlotHandler::VoidSlotIntRef );
479 DALI_TEST_CHECK( ! signal.Empty() );
481 // End of slot lifetime
482 DALI_TEST_CHECK( signal.Empty() );
484 // Signal emission should be a NOOP
490 TestSignals::VoidRet2ValueParamSignal signal;
492 DALI_TEST_CHECK( signal.Empty() );
493 TestSlotHandler handler;
494 signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValueIntValue );
495 DALI_TEST_CHECK( ! signal.Empty() );
497 // End of slot lifetime
498 DALI_TEST_CHECK( signal.Empty() );
500 // Signal emission should be a NOOP
505 TestSignals::BoolRet1ValueParamSignal signal;
507 DALI_TEST_CHECK( signal.Empty() );
508 TestSlotHandler handler;
509 signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValue );
510 DALI_TEST_CHECK( ! signal.Empty() );
512 // End of slot lifetime
513 DALI_TEST_CHECK( signal.Empty() );
515 // Signal emission should be a NOOP
516 bool blah = signal.Emit( 1.0f );
517 DALI_TEST_CHECK( ! blah );
521 TestSignals::BoolRet2ValueParamSignal signal;
523 DALI_TEST_CHECK( signal.Empty() );
524 TestSlotHandler handler;
525 signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValueIntValue );
526 DALI_TEST_CHECK( ! signal.Empty() );
528 // End of slot lifetime
529 DALI_TEST_CHECK( signal.Empty() );
531 // Signal emission should be a NOOP
532 bool blah = signal.Emit( 1.0f, 2 );
533 DALI_TEST_CHECK( ! blah );
537 TestSignals::IntRet2ValueParamSignal signal;
539 DALI_TEST_CHECK( signal.Empty() );
540 TestSlotHandler handler;
541 signal.Connect( &handler, &TestSlotHandler::IntSlotFloatValueIntValue );
542 DALI_TEST_CHECK( ! signal.Empty() );
544 // End of slot lifetime
545 DALI_TEST_CHECK( signal.Empty() );
547 // Signal emission should be a NOOP
548 int blah = signal.Emit( 10.0f, 100 );
549 DALI_TEST_CHECK( 0 == blah );
553 TestSignals::FloatRet0ParamSignal signal;
555 DALI_TEST_CHECK( signal.Empty() );
556 TestSlotHandler handler;
557 signal.Connect( &handler, &TestSlotHandler::FloatSlotVoid );
558 DALI_TEST_CHECK( ! signal.Empty() );
560 // End of slot lifetime
561 DALI_TEST_CHECK( signal.Empty() );
563 // Signal emission should be a NOOP
564 float blah = signal.Emit();
565 DALI_TEST_CHECK( 0.0f == blah );
569 TestSignals::FloatRet2ValueParamSignal signal;
571 DALI_TEST_CHECK( signal.Empty() );
572 TestSlotHandler handler;
573 signal.Connect(&handler, &TestSlotHandler::FloatSlotFloatValueFloatValue);
574 DALI_TEST_CHECK( ! signal.Empty() );
576 // End of slot lifetime
577 DALI_TEST_CHECK( signal.Empty() );
579 // Signal emission should be a NOOP
580 float blah = signal.Emit( 3.0f, 4.0f );
581 DALI_TEST_CHECK( 0.0f == blah );
586 // Positive test case for a method
587 int UtcDaliSignalConnectAndEmit(void)
589 // Test basic signal emission for each slot type
594 TestSlotHandler handlers;
595 signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
596 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
597 signals.EmitVoidSignalVoid();
598 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
600 // Test double emission
601 handlers.mHandled = false;
602 signals.EmitVoidSignalVoid();
603 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
605 signals.CheckNoConnections();
608 TestSlotHandler handlers;
609 signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
610 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
612 signals.EmitVoidSignalIntRef(x);
613 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
614 DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
616 signals.CheckNoConnections();
619 TestSlotHandler handlers;
620 signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
621 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
622 signals.EmitVoidSignalIntValue(5);
623 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
624 DALI_TEST_EQUALS( handlers.mIntParam1, 5, TEST_LOCATION );
626 signals.CheckNoConnections();
629 TestSlotHandler handlers;
630 signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
631 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
632 signals.EmitVoidSignalIntValueIntValue(6, 7);
633 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
634 DALI_TEST_EQUALS( handlers.mIntParam1, 6, TEST_LOCATION );
635 DALI_TEST_EQUALS( handlers.mIntParam2, 7, TEST_LOCATION );
637 signals.CheckNoConnections();
640 TestSlotHandler handlers;
641 signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
642 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
644 handlers.mBoolReturn = true;
645 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION );
646 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
647 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
649 // repeat with opposite return value
650 handlers.mBoolReturn = false;
651 handlers.mHandled = false;
652 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION );
653 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
654 DALI_TEST_EQUALS( handlers.mFloatParam1, 6.0f, TEST_LOCATION );
656 signals.CheckNoConnections();
659 TestSlotHandler handlers;
660 signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
661 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
662 handlers.mBoolReturn = true;
663 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION );
664 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
665 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
666 DALI_TEST_EQUALS( handlers.mIntParam2, 10, TEST_LOCATION );
668 signals.CheckNoConnections();
671 TestSlotHandler handlers;
672 signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
673 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
674 handlers.mIntReturn = 27;
675 int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
676 DALI_TEST_EQUALS( x, 27, TEST_LOCATION );
677 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
678 DALI_TEST_EQUALS( handlers.mFloatParam1, 33.5f, TEST_LOCATION );
679 DALI_TEST_EQUALS( handlers.mIntParam2, 5, TEST_LOCATION );
681 signals.CheckNoConnections();
684 TestSlotHandler handlers;
685 signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
686 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
687 handlers.mFloatReturn = 27.0f;
688 float f = signals.EmitFloat0Signal();
689 DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
690 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
691 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
692 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
694 signals.CheckNoConnections();
697 TestSlotHandler handlers;
698 signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
699 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
700 handlers.mFloatReturn = 27.0f;
701 float f = signals.EmitFloat2VSignal(5, 33.0f);
702 DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
703 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
704 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
705 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
707 signals.CheckNoConnections();
710 TestSlotHandler handlers;
711 signals.VoidSignalFloatValue3().Connect(&handlers, &TestSlotHandler::VoidSlotFloatValue3);
712 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
713 signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
714 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
715 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
716 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
717 DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
719 signals.CheckNoConnections();
722 TestSlotHandler handlers;
723 signals.FloatSignalFloatValue3().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValue3);
724 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
725 handlers.mFloatReturn = 27.0f;
726 float returnValue = signals.EmitFloatSignalFloatValue3(5, 33.0f, 100.0f);
727 DALI_TEST_EQUALS( returnValue, 27.0f, TEST_LOCATION );
728 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
729 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
730 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
731 DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
733 signals.CheckNoConnections();
737 int UtcDaliSignalDisconnect(void)
739 // Test that callbacks don't occur if a signal is disconnected before emission
744 TestSlotHandler handlers;
745 signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
746 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
747 signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
748 signals.EmitVoidSignalVoid();
749 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
753 TestSlotHandler handlers;
754 signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
755 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
757 handlers.mIntReturn = 5;
758 signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
759 signals.EmitVoidSignalIntRef(r);
760 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
761 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
762 DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
766 TestSlotHandler handlers;
767 signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
768 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
769 signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
770 signals.EmitVoidSignalIntValue(5);
771 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
772 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
776 TestSlotHandler handlers;
777 signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
778 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
779 signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
780 signals.EmitVoidSignalIntValueIntValue(5, 10);
781 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
782 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
783 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
787 TestSlotHandler handlers;
788 signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
789 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
790 handlers.mBoolReturn = true;
791 signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
792 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
793 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
794 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
798 TestSlotHandler handlers;
799 signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
800 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
801 handlers.mBoolReturn = true;
802 signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
803 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
804 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
805 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
806 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
810 TestSlotHandler handlers;
811 signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
812 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
813 handlers.mIntReturn = 27;
814 signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
815 signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
816 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
817 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
818 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
822 TestSlotHandler handlers;
823 signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
824 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
825 handlers.mFloatReturn = 27.0f;
826 signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
827 signals.EmitFloat0Signal();
828 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
829 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
830 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
834 TestSlotHandler handlers;
835 signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
836 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
837 handlers.mFloatReturn = 27.0f;
838 signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
839 signals.EmitFloat2VSignal(5, 33.0f);
840 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
841 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
842 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
847 int UtcDaliSignalDisconnect2(void)
849 // Test that nothing happens when attempting to disconnect an unconnected slot
853 TestSlotHandler handlers;
854 signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
855 signals.EmitVoidSignalVoid();
856 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
860 TestSlotHandler handlers;
862 signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
863 signals.EmitVoidSignalIntRef(r);
864 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
865 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
866 DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
870 TestSlotHandler handlers;
871 signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
872 signals.EmitVoidSignalIntValue(5);
873 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
874 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
878 TestSlotHandler handlers;
879 signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
880 signals.EmitVoidSignalIntValueIntValue(5, 10);
881 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
882 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
883 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
887 TestSlotHandler handlers;
888 handlers.mBoolReturn = true;
889 signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
890 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
891 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
892 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
896 TestSlotHandler handlers;
897 handlers.mBoolReturn = true;
898 signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
899 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
900 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
901 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
902 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
906 TestSlotHandler handlers;
907 handlers.mIntReturn = 27;
908 signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
909 signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
910 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
911 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
912 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
916 TestSlotHandler handlers;
917 handlers.mFloatReturn = 27.0f;
918 signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
919 signals.EmitFloat2VSignal(5, 33.0f);
920 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
921 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
922 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
926 TestSlotHandler handlers;
927 handlers.mFloatReturn = 27.0f;
928 signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
929 signals.EmitFloat0Signal();
930 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
931 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
932 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
937 int UtcDaliSignalDisconnect3(void)
939 // Test that callbacks stop after a signal is disconnected
944 TestSlotHandler handlers;
945 signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
946 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
949 signals.EmitVoidSignalVoid();
950 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
952 // Disconnect and emit again
953 handlers.mHandled = false;
954 signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
955 signals.EmitVoidSignalVoid();
956 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
960 TestSlotHandler handlers;
961 signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
962 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
966 signals.EmitVoidSignalIntRef(r);
967 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
968 DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
970 // Disconnect and emit again
971 handlers.mHandled = false;
972 handlers.mIntParam1 = 0;
973 signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
974 signals.EmitVoidSignalIntRef(r);
975 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
976 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
977 DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
982 int UtcDaliSignalCustomConnectionTracker(void)
984 // Test slot destruction
986 TestSignals::VoidRetNoParamSignal signal;
988 DALI_TEST_CHECK( signal.Empty() );
989 TestBasicConnectionTrackerInterface customTracker;
990 signal.Connect( &customTracker, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
991 DALI_TEST_CHECK( ! signal.Empty() );
993 // End of slot lifetime
994 DALI_TEST_CHECK( signal.Empty() );
996 // Signal emission should be a NOOP
1000 TestBasicConnectionTrackerInterface customTracker2;
1002 // Test signal emission & destruction
1004 TestSignals::VoidRetNoParamSignal signal;
1005 DALI_TEST_CHECK( signal.Empty() );
1006 DALI_TEST_EQUALS( 0u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1008 signal.Connect( &customTracker2, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
1009 DALI_TEST_CHECK( ! signal.Empty() );
1010 DALI_TEST_EQUALS( 1u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1012 DALI_TEST_EQUALS( customTracker2.mCallbackHandled, false, TEST_LOCATION );
1014 DALI_TEST_EQUALS( customTracker2.mCallbackHandled, true, TEST_LOCATION );
1016 DALI_TEST_EQUALS( 0u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1020 int UtcDaliSignalMultipleConnections(void)
1022 // Test that multiple callbacks can be connected to the same signal
1024 TestSignals signals;
1027 TestSlotHandler handler1;
1028 signals.SignalVoidNone().Connect( &handler1, &TestSlotHandler::VoidSlotVoid );
1029 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1031 TestSlotHandler handler2;
1032 signals.SignalVoidNone().Connect( &handler2, &TestSlotHandler::VoidSlotVoid );
1033 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1035 signals.EmitVoidSignalVoid();
1036 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1037 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1039 // Remove first connection and repeat
1042 signals.SignalVoidNone().Disconnect( &handler1, &TestSlotHandler::VoidSlotVoid );
1044 signals.EmitVoidSignalVoid();
1045 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1046 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1050 TestSlotHandler handler1;
1051 signals.SignalVoid1Ref().Connect( &handler1, &TestSlotHandler::VoidSlotIntRef );
1052 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1054 TestSlotHandler handler2;
1055 signals.SignalVoid1Ref().Connect( &handler2, &TestSlotHandler::VoidSlotIntRef );
1056 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1059 signals.EmitVoidSignalIntRef(x);
1060 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1061 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1062 DALI_TEST_EQUALS( handler1.mIntParam1, 7, TEST_LOCATION );
1063 DALI_TEST_EQUALS( handler2.mIntParam1, 7, TEST_LOCATION );
1065 // Remove second connection and repeat
1069 signals.SignalVoid1Ref().Disconnect( &handler2, &TestSlotHandler::VoidSlotIntRef );
1071 signals.EmitVoidSignalIntRef(x);
1072 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1073 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1074 DALI_TEST_EQUALS( handler1.mIntParam1, 8, TEST_LOCATION );
1075 DALI_TEST_EQUALS( handler2.mIntParam1, 0, TEST_LOCATION );
1079 TestSlotHandler handler1;
1080 signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1081 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1083 TestSlotHandler handler2;
1084 signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1085 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1087 TestSlotHandler handler3;
1088 signals.SignalVoid1Value().Connect( &handler3, &TestSlotHandler::VoidSlotIntValue );
1089 DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
1091 signals.EmitVoidSignalIntValue( 5 );
1092 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1093 DALI_TEST_EQUALS( handler1.mIntParam1, 5, TEST_LOCATION );
1094 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1095 DALI_TEST_EQUALS( handler2.mIntParam1, 5, TEST_LOCATION );
1096 DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1097 DALI_TEST_EQUALS( handler3.mIntParam1, 5, TEST_LOCATION );
1099 // Remove middle connection and repeat
1103 signals.SignalVoid1Value().Disconnect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1105 signals.EmitVoidSignalIntValue( 6 );
1106 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1107 DALI_TEST_EQUALS( handler1.mIntParam1, 6, TEST_LOCATION );
1108 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1109 DALI_TEST_EQUALS( handler2.mIntParam1, 0, TEST_LOCATION );
1110 DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1111 DALI_TEST_EQUALS( handler3.mIntParam1, 6, TEST_LOCATION );
1114 // Test that multiple callbacks are disconnected when a signal is destroyed
1116 TestSlotHandler handler4;
1117 TestSlotHandler handler5;
1118 TestSlotHandler handler6;
1121 TestSignals::VoidRet1ValueParamSignal tempSignal;
1123 DALI_TEST_EQUALS( handler4.GetConnectionCount(), 0u, TEST_LOCATION );
1124 DALI_TEST_EQUALS( handler5.GetConnectionCount(), 0u, TEST_LOCATION );
1125 DALI_TEST_EQUALS( handler6.GetConnectionCount(), 0u, TEST_LOCATION );
1127 tempSignal.Connect( &handler4, &TestSlotHandler::VoidSlotIntValue );
1128 tempSignal.Connect( &handler5, &TestSlotHandler::VoidSlotIntValue );
1129 tempSignal.Connect( &handler6, &TestSlotHandler::VoidSlotIntValue );
1131 DALI_TEST_EQUALS( handler4.GetConnectionCount(), 1u, TEST_LOCATION );
1132 DALI_TEST_EQUALS( handler5.GetConnectionCount(), 1u, TEST_LOCATION );
1133 DALI_TEST_EQUALS( handler6.GetConnectionCount(), 1u, TEST_LOCATION );
1135 // End of tempSignal lifetime
1137 DALI_TEST_EQUALS( handler4.GetConnectionCount(), 0u, TEST_LOCATION );
1138 DALI_TEST_EQUALS( handler5.GetConnectionCount(), 0u, TEST_LOCATION );
1139 DALI_TEST_EQUALS( handler6.GetConnectionCount(), 0u, TEST_LOCATION );
1143 int UtcDaliSignalMultipleConnections2(void)
1145 TestSignals signals;
1147 // Test that connecting the same callback twice is a NOOP
1149 TestSlotHandler handler1;
1151 // Note the double connection is intentional
1152 signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1153 signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1154 DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1156 signals.EmitVoidSignalIntValue( 6 );
1157 DALI_TEST_EQUALS( handler1.mHandledCount, 1, TEST_LOCATION );
1158 DALI_TEST_EQUALS( handler1.mIntParam1, 6, TEST_LOCATION );
1160 // Calling Disconnect once should be enough
1161 signals.SignalVoid1Value().Disconnect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1162 DALI_TEST_CHECK( signals.SignalVoid1Value().Empty() );
1163 handler1.mIntParam1 = 0;
1165 signals.EmitVoidSignalIntValue( 7 );
1166 DALI_TEST_EQUALS( handler1.mHandledCount, 1/*not incremented since last check*/, TEST_LOCATION );
1167 DALI_TEST_EQUALS( handler1.mIntParam1, 0, TEST_LOCATION );
1170 // Test automatic disconnect after multiple Connect() calls
1172 TestSlotHandler handler2;
1173 signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1174 signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1176 TestSlotHandler handler3;
1177 signals.SignalBool1Value().Connect( &handler3, &TestSlotHandler::BoolSlotFloatValue );
1178 signals.SignalBool1Value().Connect( &handler3, &TestSlotHandler::BoolSlotFloatValue );
1180 DALI_TEST_EQUALS( handler2.mHandledCount, 0, TEST_LOCATION );
1181 DALI_TEST_EQUALS( handler3.mHandledCount, 0, TEST_LOCATION );
1182 DALI_TEST_CHECK( ! signals.SignalVoid1Value().Empty() );
1183 DALI_TEST_CHECK( ! signals.SignalBool1Value().Empty() );
1185 DALI_TEST_CHECK( signals.SignalVoid1Value().Empty() );
1186 DALI_TEST_CHECK( signals.SignalBool1Value().Empty() );
1189 signals.EmitVoidSignalIntValue( 1 );
1190 signals.EmitBoolSignalFloatValue( 1.0f );
1192 // Test that connecting the same callback 10 times is a NOOP
1193 TestSlotHandler handler4;
1194 DALI_TEST_EQUALS( handler4.mHandledCount, 0, TEST_LOCATION );
1195 DALI_TEST_EQUALS( handler4.mFloatParam1, 0.0f, TEST_LOCATION );
1197 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1198 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1199 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1200 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1201 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1202 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1203 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1204 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1205 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1206 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1208 signals.EmitBoolSignalFloatValue( 2.0f );
1209 DALI_TEST_EQUALS( handler4.mHandledCount, 1, TEST_LOCATION );
1210 DALI_TEST_EQUALS( handler4.mFloatParam1, 2.0f, TEST_LOCATION );
1212 // Calling Disconnect once should be enough
1213 signals.SignalBool1Value().Disconnect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1214 DALI_TEST_CHECK( signals.SignalBool1Value().Empty() );
1216 signals.EmitBoolSignalFloatValue( 3.0f );
1217 DALI_TEST_EQUALS( handler4.mHandledCount, 1/*not incremented since last check*/, TEST_LOCATION );
1218 DALI_TEST_EQUALS( handler4.mFloatParam1, 2.0f, TEST_LOCATION );
1222 int UtcDaliSignalMultipleConnections3(void)
1224 TestSignals signals;
1226 // Test connecting two difference callbacks for the same ConnectionTracker
1228 TestSlotHandler handler1;
1231 TestSignals::VoidRet1ValueParamSignal tempSignal;
1233 DALI_TEST_EQUALS( handler1.GetConnectionCount(), 0u, TEST_LOCATION );
1234 DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1235 DALI_TEST_EQUALS( handler1.mIntParam1, 0, TEST_LOCATION );
1237 // Note that the duplicate connection is deliberate
1238 tempSignal.Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1239 tempSignal.Connect( &handler1, &TestSlotHandler::VoidDuplicateSlotIntValue );
1241 DALI_TEST_EQUALS( handler1.GetConnectionCount(), 2u, TEST_LOCATION );
1242 DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1244 tempSignal.Emit( 10 );
1246 DALI_TEST_EQUALS( handler1.mHandledCount, 2, TEST_LOCATION );
1247 DALI_TEST_EQUALS( handler1.mIntParam1, 10, TEST_LOCATION );
1248 DALI_TEST_EQUALS( handler1.mIntParam2, 10, TEST_LOCATION );
1250 // End of tempSignal lifetime
1252 DALI_TEST_EQUALS( handler1.GetConnectionCount(), 0u, TEST_LOCATION );
1257 int UtcDaliSignalDisconnectStatic(void)
1262 TestSignals::VoidRetNoParamSignal signal;
1263 DALI_TEST_CHECK( signal.Empty() );
1265 signal.Connect( StaticVoidCallbackVoid );
1266 DALI_TEST_CHECK( ! signal.Empty() );
1268 wasStaticVoidCallbackVoidCalled = false;
1270 DALI_TEST_EQUALS( wasStaticVoidCallbackVoidCalled, true, TEST_LOCATION );
1272 signal.Disconnect( StaticVoidCallbackVoid );
1273 DALI_TEST_CHECK( signal.Empty() );
1275 wasStaticVoidCallbackVoidCalled = false;
1277 DALI_TEST_EQUALS( wasStaticVoidCallbackVoidCalled, false, TEST_LOCATION );
1283 TestSignals::FloatRet0ParamSignal signal;
1284 DALI_TEST_CHECK( signal.Empty() );
1286 signal.Connect( StaticFloatCallbackVoid );
1287 DALI_TEST_CHECK( ! signal.Empty() );
1289 wasStaticFloatCallbackVoidCalled = false;
1290 float result = signal.Emit();
1291 DALI_TEST_EQUALS( wasStaticFloatCallbackVoidCalled, true, TEST_LOCATION );
1292 DALI_TEST_EQUALS( result, 7.0f, TEST_LOCATION );
1294 signal.Disconnect( StaticFloatCallbackVoid );
1295 DALI_TEST_CHECK( signal.Empty() );
1297 wasStaticFloatCallbackVoidCalled = false;
1298 result = signal.Emit();
1299 DALI_TEST_EQUALS( wasStaticFloatCallbackVoidCalled, false, TEST_LOCATION );
1300 DALI_TEST_EQUALS( result, 0.0f, TEST_LOCATION );
1306 TestSignals::VoidRet1ValueParamSignal signal;
1307 DALI_TEST_CHECK( signal.Empty() );
1309 signal.Connect( StaticVoidCallbackIntValue );
1310 DALI_TEST_CHECK( ! signal.Empty() );
1312 wasStaticVoidCallbackIntValueCalled = false;
1315 DALI_TEST_EQUALS( wasStaticVoidCallbackIntValueCalled, true, TEST_LOCATION );
1316 DALI_TEST_EQUALS( staticIntValue, 10, TEST_LOCATION );
1318 signal.Disconnect( StaticVoidCallbackIntValue );
1319 DALI_TEST_CHECK( signal.Empty() );
1321 wasStaticVoidCallbackIntValueCalled = false;
1324 DALI_TEST_EQUALS( wasStaticVoidCallbackIntValueCalled, false, TEST_LOCATION );
1325 DALI_TEST_EQUALS( staticIntValue, 0, TEST_LOCATION );
1328 // float Func( float, float )
1331 TestSignals::FloatRet2ValueParamSignal signal;
1332 DALI_TEST_CHECK( signal.Empty() );
1334 signal.Connect( StaticFloatCallbackFloatValueFloatValue );
1335 DALI_TEST_CHECK( ! signal.Empty() );
1337 wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1338 staticFloatValue1 = 0.0f;
1339 staticFloatValue2 = 0.0f;
1340 float result = signal.Emit( 5.0f, 6.0f );
1341 DALI_TEST_EQUALS( wasStaticFloatCallbackFloatValueFloatValueCalled, true, TEST_LOCATION );
1342 DALI_TEST_EQUALS( staticFloatValue1, 5.0f, TEST_LOCATION );
1343 DALI_TEST_EQUALS( staticFloatValue2, 6.0f, TEST_LOCATION );
1344 DALI_TEST_EQUALS( result, 5.0f+6.0f, TEST_LOCATION );
1346 signal.Disconnect( StaticFloatCallbackFloatValueFloatValue );
1347 DALI_TEST_CHECK( signal.Empty() );
1349 wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1350 staticFloatValue1 = 0.0f;
1351 staticFloatValue2 = 0.0f;
1352 result = signal.Emit( 7.0f, 8.0f );
1353 DALI_TEST_EQUALS( wasStaticFloatCallbackFloatValueFloatValueCalled, false, TEST_LOCATION );
1354 DALI_TEST_EQUALS( staticFloatValue1, 0.0f, TEST_LOCATION );
1355 DALI_TEST_EQUALS( staticFloatValue2, 0.0f, TEST_LOCATION );
1356 DALI_TEST_EQUALS( result, 0.0f, TEST_LOCATION );
1361 int UtcDaliSignalDisconnectDuringCallback(void)
1363 // Test disconnection during each callback
1365 TestSignals::VoidRetNoParamSignal signal;
1366 DALI_TEST_CHECK( signal.Empty() );
1368 TestSlotDisconnector handler1;
1369 handler1.VoidConnectVoid( signal );
1370 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1371 DALI_TEST_CHECK( ! signal.Empty() );
1374 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1375 DALI_TEST_CHECK( signal.Empty() );
1377 // Repeat with 2 callbacks
1379 handler1.mHandled = false;
1381 TestSlotDisconnector handler2;
1382 handler1.VoidConnectVoid( signal );
1383 handler2.VoidConnectVoid( signal );
1384 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1385 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1386 DALI_TEST_CHECK( ! signal.Empty() );
1389 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1390 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1391 DALI_TEST_CHECK( signal.Empty() );
1393 // Repeat with no callbacks
1395 handler1.mHandled = false;
1396 handler2.mHandled = false;
1399 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1400 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1402 // Repeat with 3 callbacks
1404 TestSlotDisconnector handler3;
1405 handler1.VoidConnectVoid( signal );
1406 handler2.VoidConnectVoid( signal );
1407 handler3.VoidConnectVoid( signal );
1408 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1409 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1410 DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
1411 DALI_TEST_CHECK( ! signal.Empty() );
1414 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1415 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1416 DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1417 DALI_TEST_CHECK( signal.Empty() );
1419 // Repeat with no callbacks
1421 handler1.mHandled = false;
1422 handler2.mHandled = false;
1423 handler3.mHandled = false;
1426 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1427 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1428 DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
1432 int UtcDaliSignalDisconnectDuringCallback2(void)
1434 // Test disconnection of some (but not all) callbacks during sigmal emission
1436 TestSignals::VoidRetNoParamSignal signal;
1437 DALI_TEST_CHECK( signal.Empty() );
1439 TestSlotMultiDisconnector handler;
1440 handler.ConnectAll( signal );
1441 DALI_TEST_EQUALS( handler.mSlotHandled[0], false, TEST_LOCATION );
1442 DALI_TEST_EQUALS( handler.mSlotHandled[1], false, TEST_LOCATION );
1443 DALI_TEST_EQUALS( handler.mSlotHandled[2], false, TEST_LOCATION );
1444 DALI_TEST_EQUALS( handler.mSlotHandled[3], false, TEST_LOCATION );
1445 DALI_TEST_EQUALS( handler.mSlotHandled[4], false, TEST_LOCATION );
1446 DALI_TEST_EQUALS( handler.mSlotHandled[5], false, TEST_LOCATION );
1447 DALI_TEST_EQUALS( handler.mSlotHandled[6], false, TEST_LOCATION );
1448 DALI_TEST_EQUALS( handler.mSlotHandled[7], false, TEST_LOCATION );
1449 DALI_TEST_EQUALS( handler.mSlotHandled[8], false, TEST_LOCATION );
1450 DALI_TEST_EQUALS( handler.mSlotHandled[9], false, TEST_LOCATION );
1451 DALI_TEST_CHECK( ! signal.Empty() );
1455 // Slots 5, 7, & 9 should be disconnected before being called
1456 DALI_TEST_EQUALS( handler.mSlotHandled[0], true, TEST_LOCATION );
1457 DALI_TEST_EQUALS( handler.mSlotHandled[1], true, TEST_LOCATION );
1458 DALI_TEST_EQUALS( handler.mSlotHandled[2], true, TEST_LOCATION );
1459 DALI_TEST_EQUALS( handler.mSlotHandled[3], true, TEST_LOCATION );
1460 DALI_TEST_EQUALS( handler.mSlotHandled[4], true, TEST_LOCATION );
1461 DALI_TEST_EQUALS( handler.mSlotHandled[5], false, TEST_LOCATION );
1462 DALI_TEST_EQUALS( handler.mSlotHandled[6], true, TEST_LOCATION );
1463 DALI_TEST_EQUALS( handler.mSlotHandled[7], false, TEST_LOCATION );
1464 DALI_TEST_EQUALS( handler.mSlotHandled[8], true, TEST_LOCATION );
1465 DALI_TEST_EQUALS( handler.mSlotHandled[9], false, TEST_LOCATION );
1466 DALI_TEST_CHECK( ! signal.Empty() );
1468 // Odd slots are disconnected
1469 DALI_TEST_EQUALS( handler.GetConnectionCount(), 5u, TEST_LOCATION );
1473 int UtcDaliSignalEmitDuringCallback(void)
1475 TestApplication app; // Create core for debug logging
1477 TestSignals::VoidRetNoParamSignal signal;
1478 DALI_TEST_CHECK( signal.Empty() );
1480 TestEmitDuringCallback handler1;
1481 handler1.VoidConnectVoid( signal );
1483 // Test that this does not result in an infinite loop!
1488 int UtcDaliSignalTestApp01(void)
1490 // Test 1 signal connected to 1 Slot.
1491 // Signal dies first.
1493 TestButton* button = new TestButton(1);
1495 button->DownSignal().Connect(&app,&TestApp::OnButtonPress);
1497 // check we have both the button, and the app have 1 connection
1498 DALI_TEST_EQUALS( app.GetConnectionCount(), 1u, TEST_LOCATION );
1499 DALI_TEST_EQUALS( button->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
1501 delete button; // should automatically destroy the connection
1503 // check we have a 0 connections
1504 DALI_TEST_EQUALS( app.GetConnectionCount(), 0u, TEST_LOCATION );
1509 int UtcDaliSignalTestApp02(void)
1511 // Test 1 signal connected to 1 Slot.
1512 // Slot owning object dies first.
1514 TestButton button(1);
1515 TestApp *app = new TestApp;
1516 button.DownSignal().Connect( app, &TestApp::OnButtonPress);
1518 // check we have a 1 connection
1519 DALI_TEST_EQUALS( app->GetConnectionCount(), 1u, TEST_LOCATION );
1520 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
1522 delete app; // should automatically destroy the connection
1524 // check we have a 0 connections
1525 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION );
1529 int UtcDaliSignalTestApp03(void)
1531 // Test 1 Signal connect to 2 slots
1532 // 1 of the slot owners dies. Then the second slot owner dies
1534 TestButton button(1);
1535 TestApp *app1 = new TestApp;
1536 TestApp *app2 = new TestApp;
1538 button.DownSignal().Connect( app1, &TestApp::OnButtonPress);
1539 button.DownSignal().Connect( app2, &TestApp::OnButtonPress);
1541 // check we have a 2 connections to the signal
1542 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 2u, TEST_LOCATION );
1544 // kill the first slot
1545 delete app1; // should automatically destroy the connection
1547 // check we have 1 connection left
1548 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
1550 button.Press(); // emit the signal (to ensure it doesn't seg fault)
1552 // kill the second slot
1553 delete app2; // should automatically destroy the connection
1555 // check we have 1 connection left
1556 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION );
1561 int UtcDaliSignalTestApp04(void)
1563 // Test 1 Signal connected to 2 slots (with different owners)
1564 // The Signal dies, check the 2 slots disconnect automatically
1566 TestButton* button = new TestButton(1);
1570 button->DownSignal().Connect(&app1,&TestApp::OnButtonPress);
1571 button->DownSignal().Connect(&app2,&TestApp::OnButtonPress);
1573 // check the connection counts
1574 DALI_TEST_EQUALS( app1.GetConnectionCount(), 1u, TEST_LOCATION );
1575 DALI_TEST_EQUALS( app2.GetConnectionCount(), 1u, TEST_LOCATION );
1576 DALI_TEST_EQUALS( button->DownSignal().GetConnectionCount(), 2u, TEST_LOCATION );
1578 delete button; // should automatically destroy the connection
1580 // check both slot owners have zero connections
1581 DALI_TEST_EQUALS( app1.GetConnectionCount(), 0u, TEST_LOCATION );
1582 DALI_TEST_EQUALS( app2.GetConnectionCount(), 0u, TEST_LOCATION );
1586 int UtcDaliSignalTestApp05(void)
1588 // Test 2 Signals (with different owners) connected to 1 slots
1589 // 1 Signal dies, check that the remaining connection is valid
1591 TestButton* button1 = new TestButton(1); // use for signal 1
1592 TestButton* button2 = new TestButton(2); // use for signal 2
1596 button1->DownSignal().Connect(&app,&TestApp::OnButtonPress);
1597 button2->DownSignal().Connect(&app,&TestApp::OnButtonPress);
1599 // check the connection counts
1600 DALI_TEST_EQUALS( app.GetConnectionCount(), 2u, TEST_LOCATION );
1601 DALI_TEST_EQUALS( button1->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
1602 DALI_TEST_EQUALS( button2->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
1604 // make sure both signals emit ok
1606 DALI_TEST_EQUALS( app.GetButtonPressedId() , 2 , TEST_LOCATION );
1609 DALI_TEST_EQUALS( app.GetButtonPressedId() , 1 , TEST_LOCATION );
1611 delete button1; // should automatically destroy 1 connection
1613 // check both slot owners have zero connections
1614 DALI_TEST_EQUALS( app.GetConnectionCount(), 1u, TEST_LOCATION );
1616 // check remaining connection still works
1618 DALI_TEST_EQUALS( app.GetButtonPressedId() , 2 , TEST_LOCATION );
1620 // kill the last signal
1622 DALI_TEST_EQUALS( app.GetConnectionCount(), 0u, TEST_LOCATION );
1626 int UtcDaliSignalTestApp06(void)
1628 Signal< bool () > boolSignal;
1632 // connect a slot which will return false
1633 boolSignal.Connect( &app, &TestApp::BoolReturnTestFalse);
1634 result = boolSignal.Emit();
1635 DALI_TEST_EQUALS( result, false, TEST_LOCATION );
1637 // disconnect last slot, and connect a slot which returns true
1638 boolSignal.Disconnect( &app, &TestApp::BoolReturnTestFalse);
1639 boolSignal.Connect( &app, &TestApp::BoolReturnTestTrue);
1640 result = boolSignal.Emit();
1641 DALI_TEST_EQUALS( result, true, TEST_LOCATION );
1645 int UtcDaliSlotDelegateConnection(void)
1647 TestSignals signals;
1650 TestSlotDelegateHandler handlers;
1651 signals.SignalVoidNone().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
1652 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1653 signals.EmitVoidSignalVoid();
1654 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1656 // Test double emission
1657 handlers.mHandled = false;
1658 signals.EmitVoidSignalVoid();
1659 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1661 signals.CheckNoConnections();
1664 TestSlotDelegateHandler handlers;
1665 signals.SignalVoid1Ref().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef );
1666 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1668 signals.EmitVoidSignalIntRef(x);
1669 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1670 DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
1672 signals.CheckNoConnections();
1675 TestSlotDelegateHandler handlers;
1676 signals.SignalVoid1Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue );
1677 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1678 signals.EmitVoidSignalIntValue(5);
1679 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1680 DALI_TEST_EQUALS( handlers.mIntParam1, 5, TEST_LOCATION );
1682 signals.CheckNoConnections();
1685 TestSlotDelegateHandler handlers;
1686 signals.SignalVoid2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue );
1687 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1688 signals.EmitVoidSignalIntValueIntValue(6, 7);
1689 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1690 DALI_TEST_EQUALS( handlers.mIntParam1, 6, TEST_LOCATION );
1691 DALI_TEST_EQUALS( handlers.mIntParam2, 7, TEST_LOCATION );
1693 signals.CheckNoConnections();
1696 TestSlotDelegateHandler handlers;
1697 signals.SignalBool1Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue );
1698 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1700 handlers.mBoolReturn = true;
1701 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION );
1702 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1703 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1705 // repeat with opposite return value
1706 handlers.mBoolReturn = false;
1707 handlers.mHandled = false;
1708 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION );
1709 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1710 DALI_TEST_EQUALS( handlers.mFloatParam1, 6.0f, TEST_LOCATION );
1712 signals.CheckNoConnections();
1715 TestSlotDelegateHandler handlers;
1716 signals.SignalBool2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue );
1717 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1718 handlers.mBoolReturn = true;
1719 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION );
1720 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1721 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1722 DALI_TEST_EQUALS( handlers.mIntParam2, 10, TEST_LOCATION );
1724 signals.CheckNoConnections();
1727 TestSlotDelegateHandler handlers;
1728 signals.SignalInt2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue );
1729 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1730 handlers.mIntReturn = 27;
1731 int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
1732 DALI_TEST_EQUALS( x, 27, TEST_LOCATION );
1733 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1734 DALI_TEST_EQUALS( handlers.mFloatParam1, 33.5f, TEST_LOCATION );
1735 DALI_TEST_EQUALS( handlers.mIntParam2, 5, TEST_LOCATION );
1737 signals.CheckNoConnections();
1740 TestSlotDelegateHandler handlers;
1741 signals.SignalFloat0().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid );
1742 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1743 handlers.mFloatReturn = 27.0f;
1744 float f = signals.EmitFloat0Signal();
1745 DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
1746 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1747 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1748 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1750 signals.CheckNoConnections();
1753 TestSlotDelegateHandler handlers;
1754 signals.SignalFloat2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue );
1755 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1756 handlers.mFloatReturn = 27.0f;
1757 float f = signals.EmitFloat2VSignal(5, 33.0f);
1758 DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
1759 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1760 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1761 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1763 signals.CheckNoConnections();
1766 TestSlotDelegateHandler handlers;
1767 signals.VoidSignalFloatValue3().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotFloatValue3 );
1768 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1769 signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
1770 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1771 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1772 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1773 DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
1775 signals.CheckNoConnections();
1778 TestSlotDelegateHandler handlers;
1779 signals.FloatSignalFloatValue3().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValue3 );
1780 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1781 handlers.mFloatReturn = 27.0f;
1782 float returnValue = signals.EmitFloatSignalFloatValue3(5, 33.0f, 100.0f);
1783 DALI_TEST_EQUALS( returnValue, 27.0f, TEST_LOCATION );
1784 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1785 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1786 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1787 DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
1789 signals.CheckNoConnections();
1793 int UtcDaliSignalSlotDelegateDestruction(void)
1795 // Test that signal disconnect works when slot-delegate is destroyed (goes out of scope)
1798 TestSignals::VoidRetNoParamSignal signal;
1800 DALI_TEST_CHECK( signal.Empty() );
1801 TestSlotDelegateHandler handler;
1802 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
1803 DALI_TEST_CHECK( ! signal.Empty() );
1805 // End of slot lifetime
1806 DALI_TEST_CHECK( signal.Empty() );
1808 // Signal emission should be a NOOP
1813 TestSignals::VoidRet1ValueParamSignal signal;
1815 DALI_TEST_CHECK( signal.Empty() );
1816 TestSlotDelegateHandler handler;
1817 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue );
1818 DALI_TEST_CHECK( ! signal.Empty() );
1820 // End of slot lifetime
1821 DALI_TEST_CHECK( signal.Empty() );
1823 // Signal emission should be a NOOP
1828 TestSignals::VoidRet1RefParamSignal signal;
1830 DALI_TEST_CHECK( signal.Empty() );
1831 TestSlotDelegateHandler handler;
1832 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef );
1833 DALI_TEST_CHECK( ! signal.Empty() );
1835 // End of slot lifetime
1836 DALI_TEST_CHECK( signal.Empty() );
1838 // Signal emission should be a NOOP
1840 signal.Emit( temp );
1844 TestSignals::VoidRet2ValueParamSignal signal;
1846 DALI_TEST_CHECK( signal.Empty() );
1847 TestSlotDelegateHandler handler;
1848 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue );
1849 DALI_TEST_CHECK( ! signal.Empty() );
1851 // End of slot lifetime
1852 DALI_TEST_CHECK( signal.Empty() );
1854 // Signal emission should be a NOOP
1855 signal.Emit( 1, 2 );
1859 TestSignals::BoolRet1ValueParamSignal signal;
1861 DALI_TEST_CHECK( signal.Empty() );
1862 TestSlotDelegateHandler handler;
1863 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue );
1864 DALI_TEST_CHECK( ! signal.Empty() );
1866 // End of slot lifetime
1867 DALI_TEST_CHECK( signal.Empty() );
1869 // Signal emission should be a NOOP
1870 bool blah = signal.Emit( 1.0f );
1871 DALI_TEST_CHECK( ! blah );
1875 TestSignals::BoolRet2ValueParamSignal signal;
1877 DALI_TEST_CHECK( signal.Empty() );
1878 TestSlotDelegateHandler handler;
1879 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue );
1880 DALI_TEST_CHECK( ! signal.Empty() );
1882 // End of slot lifetime
1883 DALI_TEST_CHECK( signal.Empty() );
1885 // Signal emission should be a NOOP
1886 bool blah = signal.Emit( 1.0f, 2 );
1887 DALI_TEST_CHECK( ! blah );
1891 TestSignals::IntRet2ValueParamSignal signal;
1893 DALI_TEST_CHECK( signal.Empty() );
1894 TestSlotDelegateHandler handler;
1895 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue );
1896 DALI_TEST_CHECK( ! signal.Empty() );
1898 // End of slot lifetime
1899 DALI_TEST_CHECK( signal.Empty() );
1901 // Signal emission should be a NOOP
1902 int blah = signal.Emit( 10.0f, 100 );
1903 DALI_TEST_CHECK( 0 == blah );
1907 TestSignals::FloatRet0ParamSignal signal;
1909 DALI_TEST_CHECK( signal.Empty() );
1910 TestSlotDelegateHandler handler;
1911 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid );
1912 DALI_TEST_CHECK( ! signal.Empty() );
1914 // End of slot lifetime
1915 DALI_TEST_CHECK( signal.Empty() );
1917 // Signal emission should be a NOOP
1918 float blah = signal.Emit();
1919 DALI_TEST_CHECK( 0.0f == blah );
1923 TestSignals::FloatRet2ValueParamSignal signal;
1925 DALI_TEST_CHECK( signal.Empty() );
1926 TestSlotDelegateHandler handler;
1927 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
1928 DALI_TEST_CHECK( ! signal.Empty() );
1930 // End of slot lifetime
1931 DALI_TEST_CHECK( signal.Empty() );
1933 // Signal emission should be a NOOP
1934 float blah = signal.Emit( 3.0f, 4.0f );
1935 DALI_TEST_CHECK( 0.0f == blah );
1940 int UtcDaliSlotHandlerDisconnect(void)
1942 // Test that callbacks don't occur if a signal is disconnected before emission
1944 TestSignals signals;
1947 TestSlotDelegateHandler handlers;
1948 signals.SignalVoidNone().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
1949 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1950 signals.SignalVoidNone().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
1951 signals.EmitVoidSignalVoid();
1952 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1956 TestSlotDelegateHandler handlers;
1957 signals.SignalVoid1Ref().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
1958 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1960 handlers.mIntReturn = 5;
1961 signals.SignalVoid1Ref().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
1962 signals.EmitVoidSignalIntRef(r);
1963 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1964 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1965 DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
1969 TestSlotDelegateHandler handlers;
1970 signals.SignalVoid1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
1971 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1972 signals.SignalVoid1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
1973 signals.EmitVoidSignalIntValue(5);
1974 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1975 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1979 TestSlotDelegateHandler handlers;
1980 signals.SignalVoid2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
1981 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1982 signals.SignalVoid2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
1983 signals.EmitVoidSignalIntValueIntValue(5, 10);
1984 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1985 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1986 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
1990 TestSlotDelegateHandler handlers;
1991 signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
1992 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1993 handlers.mBoolReturn = true;
1994 signals.SignalBool1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
1995 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
1996 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1997 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
2001 TestSlotDelegateHandler handlers;
2002 signals.SignalBool2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2003 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2004 handlers.mBoolReturn = true;
2005 signals.SignalBool2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2006 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
2007 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2008 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
2009 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
2013 TestSlotDelegateHandler handlers;
2014 signals.SignalInt2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2015 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2016 handlers.mIntReturn = 27;
2017 signals.SignalInt2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2018 signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
2019 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2020 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2021 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2025 TestSlotDelegateHandler handlers;
2026 signals.SignalFloat0().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2027 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2028 handlers.mFloatReturn = 27.0f;
2029 signals.SignalFloat0().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2030 signals.EmitFloat0Signal();
2031 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2032 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
2033 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2037 TestSlotDelegateHandler handlers;
2038 signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2039 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2040 handlers.mFloatReturn = 27.0f;
2041 signals.SignalFloat2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2042 signals.EmitFloat2VSignal(5, 33.0f);
2043 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2044 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
2045 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );