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 bool StaticFunctionHandlers::staticFunctionHandled;
31 void utc_dali_signal_templates_startup(void)
33 test_return_value = TET_UNDEF;
36 void utc_dali_signal_templates_cleanup(void)
38 test_return_value = TET_PASS;
44 bool wasStaticVoidCallbackVoidCalled = false;
45 bool wasStaticFloatCallbackVoidCalled = false;
46 bool wasStaticVoidCallbackIntValueCalled = false;
47 int staticIntValue = 0;
48 bool wasStaticFloatCallbackFloatValueFloatValueCalled = false;
49 float staticFloatValue1 = 0.0f;
50 float staticFloatValue2 = 0.0f;
52 void StaticVoidCallbackVoid()
54 wasStaticVoidCallbackVoidCalled = true;
57 void AlternativeVoidCallbackVoid()
61 float StaticFloatCallbackVoid()
63 wasStaticFloatCallbackVoidCalled = true;
67 void StaticVoidCallbackIntValue( int value )
69 wasStaticVoidCallbackIntValueCalled = true;
70 staticIntValue = value;
73 float StaticFloatCallbackFloatValueFloatValue( float value1, float value2 )
75 wasStaticFloatCallbackFloatValueFloatValueCalled = true;
76 staticFloatValue1 = value1;
77 staticFloatValue2 = value2;
78 return value1 + value2;
85 /*******************************************
87 * Start of Utc test cases.
88 * Test cases performed in order of API listed in dali-signal.h
89 * UtcDaliSignal + FunctionName + P=positive test, N = Negative test
93 int UtcDaliSignalEmptyP(void)
95 TestApplication app; // Create core for debug logging
97 // Test that Empty() is true, when no slots connected to the signal
100 TestSignals::VoidRetNoParamSignal signal;
101 DALI_TEST_CHECK( signal.Empty() );
104 // Test that Empty() is true, when a slot has connected and disconnected
106 TestSignals::VoidRetNoParamSignal signal;
107 TestSlotHandler handler;
108 signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
109 signal.Disconnect( &handler, &TestSlotHandler::VoidSlotVoid );
110 DALI_TEST_CHECK( signal.Empty() );
116 int UtcDaliSignalEmptyN(void)
118 TestApplication app; // Create core for debug logging
120 // Test that Empty() is false after signal connection
121 TestSignals::VoidRetNoParamSignal signal;
122 TestSlotHandler handler;
123 signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
124 DALI_TEST_CHECK( ! signal.Empty() );
129 int UtcDaliSignalGetConnectionCountP(void)
131 TestApplication app; // Create core for debug logging
133 TestSignals::VoidRetNoParamSignal signal;
134 TestSlotHandler handler;
135 signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
136 DALI_TEST_CHECK( signal.GetConnectionCount() == 1 );
138 TestSlotHandler handler2;
139 signal.Connect( &handler2, &TestSlotHandler::VoidSlotVoid );
140 DALI_TEST_CHECK( signal.GetConnectionCount() == 2 );
145 int UtcDaliSignalGetConnectionCountN(void)
147 TestApplication app; // Create core for debug logging
148 TestSignals::VoidRetNoParamSignal signal;
149 DALI_TEST_CHECK( signal.GetConnectionCount() == 0 );
154 * there are 5 different connection functions
155 * we go through them here in order of definition in dali-signal.h
157 int UtcDaliSignalConnectP01(void)
159 TestApplication app; // Create core for debug logging
161 // test static function: void Connect( void (*func)() )
162 TestSignals::VoidRetNoParamSignal signal;
163 signal.Connect( StaticVoidCallbackVoid );
164 DALI_TEST_CHECK( ! signal.Empty() );
170 int UtcDaliSignalConnectN01(void)
172 // difficult to perform a negative test on Connect as no checks are performed
173 // when creating a callback for a null function ( during Connect).
174 // so we test an assert on Emit
175 TestApplication app; // Create core for debug logging
177 TestSignals::VoidRetNoParamSignal signal;
178 signal.Connect( NULL );
183 catch (Dali::DaliException& e)
185 // Tests that a negative test of an assertion succeeds
186 DALI_TEST_PRINT_ASSERT( e );
187 tet_result(TET_PASS);
193 int UtcDaliSignalConnectP02(void)
195 TestApplication app; // Create core for debug logging
197 // test member function: Connect( X* obj, void (X::*func)() ))
198 TestSignals::VoidRetNoParamSignal signal;
199 TestSlotHandler handler;
200 signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
201 DALI_TEST_CHECK( ! signal.Empty() );
203 DALI_TEST_CHECK( handler.mHandled == true );
207 int UtcDaliSignalConnectN02(void)
209 TestApplication app; // Create core for debug logging
211 TestSignals::VoidRetNoParamSignal signal;
214 // test member function: Connect( X* obj, void (X::*func)() )) with NULL object
215 signal.Connect( static_cast<TestSlotHandler*>(NULL), &TestSlotHandler::VoidSlotVoid );
217 catch (Dali::DaliException& e)
219 // Tests that a negative test of an assertion succeeds
220 DALI_TEST_PRINT_ASSERT( e );
221 tet_result(TET_PASS);
227 int UtcDaliSignalConnectP03(void)
229 TestApplication app; // Create core for debug logging
231 // test slot delegate: Connect( SlotDelegate<X>& delegate, void (X::*func)() )
232 TestSignals::VoidRetNoParamSignal signal;
233 TestSlotDelegateHandler handler;
234 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
235 DALI_TEST_CHECK( ! signal.Empty() );
237 DALI_TEST_CHECK( handler.mHandled == true );
242 int UtcDaliSignalConnectN03(void)
244 TestApplication app; // Create core for debug logging
245 // the delegate is passed by reference, so you can't pass null.
246 tet_result( TET_PASS );
250 int UtcDaliSignalConnectP04(void)
252 TestApplication app; // Create core for debug logging
254 // test function object: Connect( ConnectionTrackerInterface* connectionTracker, const X& func )
255 TestSlotHandler handler;
256 TestSignals::VoidRetNoParamSignal signal;
257 bool functorCalled(false);
258 TestFunctor functor( functorCalled );
259 signal.Connect( &handler, functor );
260 DALI_TEST_CHECK( ! signal.Empty() );
262 DALI_TEST_CHECK( functorCalled == true );
267 int UtcDaliSignalConnectN04(void)
269 // for negative test we try to connect a null connection tracker to the signal
270 TestSignals::VoidRetNoParamSignal signal;
271 TestSlotHandler *nullHandler( NULL );
274 signal.Connect( nullHandler , &TestSlotHandler::VoidSlotVoid );
276 catch (Dali::DaliException& e)
278 // Tests that a negative test of an assertion succeeds
279 DALI_TEST_PRINT_ASSERT( e );
280 tet_result( TET_PASS );
287 int UtcDaliSignalConnectP05(void)
289 TestApplication app; // Create core for debug logging
291 // test function object using FunctorDelegate.
292 // :Connect( ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate )
294 TestSlotHandler handler;
295 TestSignals::VoidRetNoParamSignal signal;
296 bool functorDelegateCalled(false);
297 signal.Connect( &handler, FunctorDelegate::New( VoidFunctorVoid(functorDelegateCalled) ));
298 DALI_TEST_CHECK( ! signal.Empty() );
300 DALI_TEST_CHECK( functorDelegateCalled == true );
303 TestSlotHandler handler;
304 TestSignals::VoidRet1ValueParamSignal signal;
305 bool functorDelegateCalled(false);
306 signal.Connect( &handler, FunctorDelegate::New( VoidFunctorVoid(functorDelegateCalled) ));
307 DALI_TEST_CHECK( ! signal.Empty() );
313 int UtcDaliSignalConnectN05(void)
315 TestApplication app; // Create core for debug logging
317 // for negative test we try to connect a null connection tracker to the signal
318 // :Connect( ConnectionTrackerInterface == NULL, FunctorDelegate* delegate )
319 TestSlotHandler *nullHandler( NULL );
320 TestSignals::VoidRetNoParamSignal signal;
321 bool functorDelegateCalled(false);
324 signal.Connect( nullHandler, FunctorDelegate::New( VoidFunctorVoid(functorDelegateCalled) ));
326 catch (Dali::DaliException& e)
328 DALI_TEST_PRINT_ASSERT( e );
329 tet_result( TET_PASS );
336 * there 3 different disconnect functions
337 * we go through them here in order of definition in dali-signal.h
339 int UtcDaliSignalDisconnectP01(void)
341 TestApplication app; // Create core for debug logging
343 // test static function: Disconnect( void (*func)( Arg0 arg0 ) )
345 TestSignals::VoidRetNoParamSignal signal;
346 signal.Connect( StaticVoidCallbackVoid );
347 DALI_TEST_CHECK( ! signal.Empty() );
348 signal.Disconnect( StaticVoidCallbackVoid );
349 DALI_TEST_CHECK( signal.Empty() );
354 int UtcDaliSignalDisconnectN01(void)
356 TestApplication app; // Create core for debug logging
358 // 1. Disconnect using the function
359 TestSignals::VoidRetNoParamSignal signal;
360 signal.Connect( StaticVoidCallbackVoid );
361 DALI_TEST_CHECK( ! signal.Empty() );
363 signal.Disconnect( AlternativeVoidCallbackVoid );
365 DALI_TEST_CHECK( ! signal.Empty() );
370 int UtcDaliSignalDisconnectP02(void)
372 TestApplication app; // Create core for debug logging
374 // test member function: Disconnect( X* obj, void (X::*func)( Arg0 arg0 ) )
375 TestSignals::VoidRetNoParamSignal signal;
376 TestSlotHandler handler;
377 signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
378 DALI_TEST_CHECK( ! signal.Empty() );
379 signal.Disconnect( &handler, &TestSlotHandler::VoidSlotVoid );
380 DALI_TEST_CHECK( signal.Empty() );
385 int UtcDaliSignalDisconnectN02(void)
387 TestApplication app; // Create core for debug logging
389 // 1. Disconnect using a null connection tracker
390 TestSignals::VoidRetNoParamSignal signal;
391 TestSlotHandler handler;
393 signal.Connect( &handler , &TestSlotHandler::VoidSlotVoid );
394 DALI_TEST_CHECK( !signal.Empty() );
398 TestSlotHandler* nullHandler( NULL );
399 signal.Disconnect( nullHandler , &TestSlotHandler::VoidSlotVoid );
401 catch(Dali::DaliException& e)
403 // Tests that a negative test of an assertion succeeds
404 DALI_TEST_PRINT_ASSERT( e );
405 DALI_TEST_CHECK( !signal.Empty() );
410 int UtcDaliSignalDisconnectP03(void)
412 TestApplication app; // Create core for debug logging
414 // test slot delegate: Disconnect( SlotDelegate<X>& delegate, void (X::*func)( Arg0 arg0 ) )
415 TestSignals::VoidRetNoParamSignal signal;
416 TestSlotDelegateHandler handler;
417 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
418 DALI_TEST_CHECK( ! signal.Empty() );
419 signal.Disconnect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
420 DALI_TEST_CHECK( signal.Empty() );
425 int UtcDaliSignalDisconnectN03(void)
427 TestApplication app; // Create core for debug logging
429 // try to disconnect from the wrong signal
430 TestSignals::VoidRetNoParamSignal signal;
431 TestSlotDelegateHandler handler;
432 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
434 // use different signal
435 signal.Disconnect( handler.mSlotDelegate , &TestSlotDelegateHandler::AlternativeVoidSlotVoid );
437 DALI_TEST_CHECK( !signal.Empty() );
443 /*******************************************
445 * End of Utc test cases for the individual API's of Signals
446 * The following testing Signals functionality as a whole
451 int UtcDaliSignalEmptyCheckSlotDestruction(void)
453 // Test that signal disconnect works when slot is destroyed (goes out of scope)
455 TestSignals::VoidRetNoParamSignal signal;
457 DALI_TEST_CHECK( signal.Empty() );
458 TestSlotHandler handler;
459 signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
460 DALI_TEST_CHECK( ! signal.Empty() );
462 // End of slot lifetime
463 DALI_TEST_CHECK( signal.Empty() );
465 // Signal emission should be a NOOP
470 TestSignals::VoidRet1ValueParamSignal signal;
472 DALI_TEST_CHECK( signal.Empty() );
473 TestSlotHandler handler;
474 signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValue );
475 DALI_TEST_CHECK( ! signal.Empty() );
477 // End of slot lifetime
478 DALI_TEST_CHECK( signal.Empty() );
480 // Signal emission should be a NOOP
485 TestSignals::VoidRet1RefParamSignal signal;
487 DALI_TEST_CHECK( signal.Empty() );
488 TestSlotHandler handler;
489 signal.Connect( &handler, &TestSlotHandler::VoidSlotIntRef );
490 DALI_TEST_CHECK( ! signal.Empty() );
492 // End of slot lifetime
493 DALI_TEST_CHECK( signal.Empty() );
495 // Signal emission should be a NOOP
501 TestSignals::VoidRet2ValueParamSignal signal;
503 DALI_TEST_CHECK( signal.Empty() );
504 TestSlotHandler handler;
505 signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValueIntValue );
506 DALI_TEST_CHECK( ! signal.Empty() );
508 // End of slot lifetime
509 DALI_TEST_CHECK( signal.Empty() );
511 // Signal emission should be a NOOP
516 TestSignals::BoolRet1ValueParamSignal signal;
518 DALI_TEST_CHECK( signal.Empty() );
519 TestSlotHandler handler;
520 signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValue );
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 );
528 DALI_TEST_CHECK( ! blah );
532 TestSignals::BoolRet2ValueParamSignal signal;
534 DALI_TEST_CHECK( signal.Empty() );
535 TestSlotHandler handler;
536 signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValueIntValue );
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 bool blah = signal.Emit( 1.0f, 2 );
544 DALI_TEST_CHECK( ! blah );
548 TestSignals::IntRet2ValueParamSignal signal;
550 DALI_TEST_CHECK( signal.Empty() );
551 TestSlotHandler handler;
552 signal.Connect( &handler, &TestSlotHandler::IntSlotFloatValueIntValue );
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 int blah = signal.Emit( 10.0f, 100 );
560 DALI_TEST_CHECK( 0 == blah );
564 TestSignals::FloatRet0ParamSignal signal;
566 DALI_TEST_CHECK( signal.Empty() );
567 TestSlotHandler handler;
568 signal.Connect( &handler, &TestSlotHandler::FloatSlotVoid );
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();
576 DALI_TEST_CHECK( 0.0f == blah );
580 TestSignals::FloatRet2ValueParamSignal signal;
582 DALI_TEST_CHECK( signal.Empty() );
583 TestSlotHandler handler;
584 signal.Connect(&handler, &TestSlotHandler::FloatSlotFloatValueFloatValue);
585 DALI_TEST_CHECK( ! signal.Empty() );
587 // End of slot lifetime
588 DALI_TEST_CHECK( signal.Empty() );
590 // Signal emission should be a NOOP
591 float blah = signal.Emit( 3.0f, 4.0f );
592 DALI_TEST_CHECK( 0.0f == blah );
597 // Positive test case for a method
598 int UtcDaliSignalConnectAndEmit01P(void)
600 // Test basic signal emission for each slot type
605 TestSlotHandler handlers;
606 signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
607 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
608 signals.EmitVoidSignalVoid();
609 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
611 // Test double emission
612 handlers.mHandled = false;
613 signals.EmitVoidSignalVoid();
614 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
616 signals.CheckNoConnections();
619 TestSlotHandler handlers;
620 signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
621 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
623 signals.EmitVoidSignalIntRef(x);
624 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
625 DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
627 signals.CheckNoConnections();
630 TestSlotHandler handlers;
631 signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
632 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
633 signals.EmitVoidSignal1IntValue(5);
634 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
635 DALI_TEST_EQUALS( handlers.mIntParam1, 5, TEST_LOCATION );
637 signals.CheckNoConnections();
640 TestSlotHandler handlers;
641 signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
642 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
643 signals.EmitVoidSignal2IntValue(6, 7);
644 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
645 DALI_TEST_EQUALS( handlers.mIntParam1, 6, TEST_LOCATION );
646 DALI_TEST_EQUALS( handlers.mIntParam2, 7, TEST_LOCATION );
648 signals.CheckNoConnections();
651 TestSlotHandler handlers;
652 signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
653 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
655 handlers.mBoolReturn = true;
656 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION );
657 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
658 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
660 // repeat with opposite return value
661 handlers.mBoolReturn = false;
662 handlers.mHandled = false;
663 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION );
664 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
665 DALI_TEST_EQUALS( handlers.mFloatParam1, 6.0f, TEST_LOCATION );
667 signals.CheckNoConnections();
670 TestSlotHandler handlers;
671 signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
672 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
673 handlers.mBoolReturn = true;
674 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION );
675 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
676 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
677 DALI_TEST_EQUALS( handlers.mIntParam2, 10, TEST_LOCATION );
679 signals.CheckNoConnections();
682 TestSlotHandler handlers;
683 signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
684 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
685 handlers.mIntReturn = 27;
686 int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
687 DALI_TEST_EQUALS( x, 27, TEST_LOCATION );
688 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
689 DALI_TEST_EQUALS( handlers.mFloatParam1, 33.5f, TEST_LOCATION );
690 DALI_TEST_EQUALS( handlers.mIntParam2, 5, TEST_LOCATION );
692 signals.CheckNoConnections();
695 TestSlotHandler handlers;
696 signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
697 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
698 handlers.mFloatReturn = 27.0f;
699 float f = signals.EmitFloat0Signal();
700 DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
701 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
702 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
703 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
705 signals.CheckNoConnections();
708 TestSlotHandler handlers;
709 signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
710 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
711 handlers.mFloatReturn = 27.0f;
712 float f = signals.EmitFloat2VSignal(5, 33.0f);
713 DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
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 );
718 signals.CheckNoConnections();
721 TestSlotHandler handlers;
722 signals.VoidSignalFloatValue3().Connect(&handlers, &TestSlotHandler::VoidSlotFloatValue3);
723 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
724 signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
725 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
726 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
727 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
728 DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
730 signals.CheckNoConnections();
733 TestSlotHandler handlers;
734 signals.SignalFloat3Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValue3);
735 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
736 handlers.mFloatReturn = 27.0f;
737 float returnValue = signals.EmitFloat3VSignal(5, 33.0f, 100.0f);
738 DALI_TEST_EQUALS( returnValue, 27.0f, TEST_LOCATION );
739 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
740 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
741 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
742 DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
744 signals.CheckNoConnections();
748 int UtcDaliSignalConnectAndEmit02P(void)
750 // testing connection of static functions
752 StaticFunctionHandlers handlers;
755 signals.SignalVoidNone().Connect( &StaticFunctionHandlers::VoidSlotVoid );
756 DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
757 signals.EmitVoidSignalVoid();
758 DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
763 signals.SignalVoid1Value().Connect( &StaticFunctionHandlers::VoidSlot1Param );
764 DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
765 signals.EmitVoidSignal1IntValue( 1 );
766 DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
770 signals.SignalVoid2Value().Connect( &StaticFunctionHandlers::VoidSlot2Param );
771 DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
772 signals.EmitVoidSignal2IntValue( 1, 2 );
773 DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
776 // void ( p1, p2, p3 )
778 signals.SignalVoid3Value().Connect( &StaticFunctionHandlers::VoidSlot3Param );
779 DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
780 signals.EmitVoidSignal3IntValue( 1, 2, 3 );
781 DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
785 signals.SignalFloat0().Connect( &StaticFunctionHandlers::RetSlot0Param );
786 DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
787 signals.EmitFloat0Signal();
788 DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
792 signals.SignalFloat1Value().Connect( &StaticFunctionHandlers::RetSlot1Param );
793 DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
794 signals.EmitFloat1VSignal( 1.f );
795 DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
799 signals.SignalFloat2Value().Connect( &StaticFunctionHandlers::RetSlot2Param );
800 DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
801 signals.EmitFloat2VSignal( 1.f, 2.f );
802 DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
805 // ret ( p1, p2, p3 )
807 signals.SignalFloat3Value().Connect( &StaticFunctionHandlers::RetSlot3Param );
808 DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
809 signals.EmitFloat3VSignal( 1.f, 2.f, 3.f );
810 DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
817 int UtcDaliSignalDisconnect(void)
819 // Test that callbacks don't occur if a signal is disconnected before emission
824 TestSlotHandler handlers;
825 signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
826 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
827 signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
828 signals.EmitVoidSignalVoid();
829 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
833 TestSlotHandler handlers;
834 signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
835 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
837 handlers.mIntReturn = 5;
838 signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
839 signals.EmitVoidSignalIntRef(r);
840 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
841 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
842 DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
846 TestSlotHandler handlers;
847 signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
848 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
849 signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
850 signals.EmitVoidSignal1IntValue(5);
851 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
852 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
856 TestSlotHandler handlers;
857 signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
858 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
859 signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
860 signals.EmitVoidSignal2IntValue(5, 10);
861 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
862 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
863 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
867 TestSlotHandler handlers;
868 signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
869 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
870 handlers.mBoolReturn = true;
871 signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
872 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
873 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
874 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
878 TestSlotHandler handlers;
879 signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
880 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
881 handlers.mBoolReturn = true;
882 signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
883 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
884 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
885 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
886 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
890 TestSlotHandler handlers;
891 signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
892 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
893 handlers.mIntReturn = 27;
894 signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
895 signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
896 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
897 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
898 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
902 TestSlotHandler handlers;
903 signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
904 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
905 handlers.mFloatReturn = 27.0f;
906 signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
907 signals.EmitFloat0Signal();
908 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
909 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
910 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
914 TestSlotHandler handlers;
915 signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
916 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
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 );
927 int UtcDaliSignalDisconnect2(void)
929 // Test that nothing happens when attempting to disconnect an unconnected slot
933 TestSlotHandler handlers;
934 signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
935 signals.EmitVoidSignalVoid();
936 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
940 TestSlotHandler handlers;
942 signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
943 signals.EmitVoidSignalIntRef(r);
944 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
945 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
946 DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
950 TestSlotHandler handlers;
951 signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
952 signals.EmitVoidSignal1IntValue(5);
953 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
954 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
958 TestSlotHandler handlers;
959 signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
960 signals.EmitVoidSignal2IntValue(5, 10);
961 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
962 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
963 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
967 TestSlotHandler handlers;
968 handlers.mBoolReturn = true;
969 signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
970 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
971 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
972 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
976 TestSlotHandler handlers;
977 handlers.mBoolReturn = true;
978 signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
979 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
980 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
981 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
982 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
986 TestSlotHandler handlers;
987 handlers.mIntReturn = 27;
988 signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
989 signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
990 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
991 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
992 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
996 TestSlotHandler handlers;
997 handlers.mFloatReturn = 27.0f;
998 signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
999 signals.EmitFloat2VSignal(5, 33.0f);
1000 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1001 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
1002 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1006 TestSlotHandler handlers;
1007 handlers.mFloatReturn = 27.0f;
1008 signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
1009 signals.EmitFloat0Signal();
1010 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1011 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
1012 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1017 int UtcDaliSignalDisconnect3(void)
1019 // Test that callbacks stop after a signal is disconnected
1021 TestSignals signals;
1024 TestSlotHandler handlers;
1025 signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
1026 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1029 signals.EmitVoidSignalVoid();
1030 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1032 // Disconnect and emit again
1033 handlers.mHandled = false;
1034 signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
1035 signals.EmitVoidSignalVoid();
1036 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1040 TestSlotHandler handlers;
1041 signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1042 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1046 signals.EmitVoidSignalIntRef(r);
1047 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1048 DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
1050 // Disconnect and emit again
1051 handlers.mHandled = false;
1052 handlers.mIntParam1 = 0;
1053 signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1054 signals.EmitVoidSignalIntRef(r);
1055 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1056 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1057 DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
1062 int UtcDaliSignalCustomConnectionTracker(void)
1064 // Test slot destruction
1066 TestSignals::VoidRetNoParamSignal signal;
1068 DALI_TEST_CHECK( signal.Empty() );
1069 TestBasicConnectionTrackerInterface customTracker;
1070 signal.Connect( &customTracker, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
1071 DALI_TEST_CHECK( ! signal.Empty() );
1073 // End of slot lifetime
1074 DALI_TEST_CHECK( signal.Empty() );
1076 // Signal emission should be a NOOP
1080 TestBasicConnectionTrackerInterface customTracker2;
1082 // Test signal emission & destruction
1084 TestSignals::VoidRetNoParamSignal signal;
1085 DALI_TEST_CHECK( signal.Empty() );
1086 DALI_TEST_EQUALS( 0u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1088 signal.Connect( &customTracker2, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
1089 DALI_TEST_CHECK( ! signal.Empty() );
1090 DALI_TEST_EQUALS( 1u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1092 DALI_TEST_EQUALS( customTracker2.mCallbackHandled, false, TEST_LOCATION );
1094 DALI_TEST_EQUALS( customTracker2.mCallbackHandled, true, TEST_LOCATION );
1096 DALI_TEST_EQUALS( 0u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1098 // Test for removing a null callback
1100 TestBasicConnectionTrackerInterface customTracker3;
1102 TestSignals::VoidRetNoParamSignal signal;
1103 DALI_TEST_CHECK( signal.Empty() );
1104 DALI_TEST_EQUALS( 0u, customTracker3.GetConnectionCount(), TEST_LOCATION );
1106 signal.Connect( &customTracker3, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
1107 DALI_TEST_CHECK( ! signal.Empty() );
1108 DALI_TEST_EQUALS( 1u, customTracker3.GetConnectionCount(), TEST_LOCATION );
1112 customTracker3.RemoveNullCallback();
1113 tet_result( TET_FAIL );
1115 catch (Dali::DaliException& e)
1117 tet_result( TET_PASS );
1124 int UtcDaliSignalMultipleConnections(void)
1126 // Test that multiple callbacks can be connected to the same signal
1128 TestSignals signals;
1131 TestSlotHandler handler1;
1132 signals.SignalVoidNone().Connect( &handler1, &TestSlotHandler::VoidSlotVoid );
1133 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1135 TestSlotHandler handler2;
1136 signals.SignalVoidNone().Connect( &handler2, &TestSlotHandler::VoidSlotVoid );
1137 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1139 signals.EmitVoidSignalVoid();
1140 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1141 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1143 // Remove first connection and repeat
1146 signals.SignalVoidNone().Disconnect( &handler1, &TestSlotHandler::VoidSlotVoid );
1148 signals.EmitVoidSignalVoid();
1149 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1150 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1154 TestSlotHandler handler1;
1155 signals.SignalVoid1Ref().Connect( &handler1, &TestSlotHandler::VoidSlotIntRef );
1156 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1158 TestSlotHandler handler2;
1159 signals.SignalVoid1Ref().Connect( &handler2, &TestSlotHandler::VoidSlotIntRef );
1160 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1163 signals.EmitVoidSignalIntRef(x);
1164 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1165 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1166 DALI_TEST_EQUALS( handler1.mIntParam1, 7, TEST_LOCATION );
1167 DALI_TEST_EQUALS( handler2.mIntParam1, 7, TEST_LOCATION );
1169 // Remove second connection and repeat
1173 signals.SignalVoid1Ref().Disconnect( &handler2, &TestSlotHandler::VoidSlotIntRef );
1175 signals.EmitVoidSignalIntRef(x);
1176 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1177 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1178 DALI_TEST_EQUALS( handler1.mIntParam1, 8, TEST_LOCATION );
1179 DALI_TEST_EQUALS( handler2.mIntParam1, 0, TEST_LOCATION );
1183 TestSlotHandler handler1;
1184 signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1185 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1187 TestSlotHandler handler2;
1188 signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1189 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1191 TestSlotHandler handler3;
1192 signals.SignalVoid1Value().Connect( &handler3, &TestSlotHandler::VoidSlotIntValue );
1193 DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
1195 signals.EmitVoidSignal1IntValue( 5 );
1196 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1197 DALI_TEST_EQUALS( handler1.mIntParam1, 5, TEST_LOCATION );
1198 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1199 DALI_TEST_EQUALS( handler2.mIntParam1, 5, TEST_LOCATION );
1200 DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1201 DALI_TEST_EQUALS( handler3.mIntParam1, 5, TEST_LOCATION );
1203 // Remove middle connection and repeat
1207 signals.SignalVoid1Value().Disconnect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1209 signals.EmitVoidSignal1IntValue( 6 );
1210 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1211 DALI_TEST_EQUALS( handler1.mIntParam1, 6, TEST_LOCATION );
1212 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1213 DALI_TEST_EQUALS( handler2.mIntParam1, 0, TEST_LOCATION );
1214 DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1215 DALI_TEST_EQUALS( handler3.mIntParam1, 6, TEST_LOCATION );
1218 // Test that multiple callbacks are disconnected when a signal is destroyed
1220 TestSlotHandler handler4;
1221 TestSlotHandler handler5;
1222 TestSlotHandler handler6;
1225 TestSignals::VoidRet1ValueParamSignal tempSignal;
1227 DALI_TEST_EQUALS( handler4.GetConnectionCount(), 0u, TEST_LOCATION );
1228 DALI_TEST_EQUALS( handler5.GetConnectionCount(), 0u, TEST_LOCATION );
1229 DALI_TEST_EQUALS( handler6.GetConnectionCount(), 0u, TEST_LOCATION );
1231 tempSignal.Connect( &handler4, &TestSlotHandler::VoidSlotIntValue );
1232 tempSignal.Connect( &handler5, &TestSlotHandler::VoidSlotIntValue );
1233 tempSignal.Connect( &handler6, &TestSlotHandler::VoidSlotIntValue );
1235 DALI_TEST_EQUALS( handler4.GetConnectionCount(), 1u, TEST_LOCATION );
1236 DALI_TEST_EQUALS( handler5.GetConnectionCount(), 1u, TEST_LOCATION );
1237 DALI_TEST_EQUALS( handler6.GetConnectionCount(), 1u, TEST_LOCATION );
1239 // End of tempSignal lifetime
1241 DALI_TEST_EQUALS( handler4.GetConnectionCount(), 0u, TEST_LOCATION );
1242 DALI_TEST_EQUALS( handler5.GetConnectionCount(), 0u, TEST_LOCATION );
1243 DALI_TEST_EQUALS( handler6.GetConnectionCount(), 0u, TEST_LOCATION );
1247 int UtcDaliSignalMultipleConnections2(void)
1249 TestSignals signals;
1251 // Test that connecting the same callback twice is a NOOP
1253 TestSlotHandler handler1;
1255 // Note the double connection is intentional
1256 signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1257 signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1258 DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1260 signals.EmitVoidSignal1IntValue( 6 );
1261 DALI_TEST_EQUALS( handler1.mHandledCount, 1, TEST_LOCATION );
1262 DALI_TEST_EQUALS( handler1.mIntParam1, 6, TEST_LOCATION );
1264 // Calling Disconnect once should be enough
1265 signals.SignalVoid1Value().Disconnect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1266 DALI_TEST_CHECK( signals.SignalVoid1Value().Empty() );
1267 handler1.mIntParam1 = 0;
1269 signals.EmitVoidSignal1IntValue( 7 );
1270 DALI_TEST_EQUALS( handler1.mHandledCount, 1/*not incremented since last check*/, TEST_LOCATION );
1271 DALI_TEST_EQUALS( handler1.mIntParam1, 0, TEST_LOCATION );
1274 // Test automatic disconnect after multiple Connect() calls
1276 TestSlotHandler handler2;
1277 signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1278 signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1280 TestSlotHandler handler3;
1281 signals.SignalBool1Value().Connect( &handler3, &TestSlotHandler::BoolSlotFloatValue );
1282 signals.SignalBool1Value().Connect( &handler3, &TestSlotHandler::BoolSlotFloatValue );
1284 DALI_TEST_EQUALS( handler2.mHandledCount, 0, TEST_LOCATION );
1285 DALI_TEST_EQUALS( handler3.mHandledCount, 0, TEST_LOCATION );
1286 DALI_TEST_CHECK( ! signals.SignalVoid1Value().Empty() );
1287 DALI_TEST_CHECK( ! signals.SignalBool1Value().Empty() );
1289 DALI_TEST_CHECK( signals.SignalVoid1Value().Empty() );
1290 DALI_TEST_CHECK( signals.SignalBool1Value().Empty() );
1293 signals.EmitVoidSignal1IntValue( 1 );
1294 signals.EmitBoolSignalFloatValue( 1.0f );
1296 // Test that connecting the same callback 10 times is a NOOP
1297 TestSlotHandler handler4;
1298 DALI_TEST_EQUALS( handler4.mHandledCount, 0, TEST_LOCATION );
1299 DALI_TEST_EQUALS( handler4.mFloatParam1, 0.0f, TEST_LOCATION );
1301 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1302 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1303 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1304 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1305 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1306 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1307 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1308 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1309 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1310 signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1312 signals.EmitBoolSignalFloatValue( 2.0f );
1313 DALI_TEST_EQUALS( handler4.mHandledCount, 1, TEST_LOCATION );
1314 DALI_TEST_EQUALS( handler4.mFloatParam1, 2.0f, TEST_LOCATION );
1316 // Calling Disconnect once should be enough
1317 signals.SignalBool1Value().Disconnect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1318 DALI_TEST_CHECK( signals.SignalBool1Value().Empty() );
1320 signals.EmitBoolSignalFloatValue( 3.0f );
1321 DALI_TEST_EQUALS( handler4.mHandledCount, 1/*not incremented since last check*/, TEST_LOCATION );
1322 DALI_TEST_EQUALS( handler4.mFloatParam1, 2.0f, TEST_LOCATION );
1326 int UtcDaliSignalMultipleConnections3(void)
1328 TestSignals signals;
1330 // Test connecting two difference callbacks for the same ConnectionTracker
1332 TestSlotHandler handler1;
1335 TestSignals::VoidRet1ValueParamSignal tempSignal;
1337 DALI_TEST_EQUALS( handler1.GetConnectionCount(), 0u, TEST_LOCATION );
1338 DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1339 DALI_TEST_EQUALS( handler1.mIntParam1, 0, TEST_LOCATION );
1341 // Note that the duplicate connection is deliberate
1342 tempSignal.Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1343 tempSignal.Connect( &handler1, &TestSlotHandler::VoidDuplicateSlotIntValue );
1345 DALI_TEST_EQUALS( handler1.GetConnectionCount(), 2u, TEST_LOCATION );
1346 DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1348 tempSignal.Emit( 10 );
1350 DALI_TEST_EQUALS( handler1.mHandledCount, 2, TEST_LOCATION );
1351 DALI_TEST_EQUALS( handler1.mIntParam1, 10, TEST_LOCATION );
1352 DALI_TEST_EQUALS( handler1.mIntParam2, 10, TEST_LOCATION );
1354 // End of tempSignal lifetime
1356 DALI_TEST_EQUALS( handler1.GetConnectionCount(), 0u, TEST_LOCATION );
1361 int UtcDaliSignalDisconnectStatic(void)
1366 TestSignals::VoidRetNoParamSignal signal;
1367 DALI_TEST_CHECK( signal.Empty() );
1369 signal.Connect( StaticVoidCallbackVoid );
1370 DALI_TEST_CHECK( ! signal.Empty() );
1372 wasStaticVoidCallbackVoidCalled = false;
1374 DALI_TEST_EQUALS( wasStaticVoidCallbackVoidCalled, true, TEST_LOCATION );
1376 signal.Disconnect( StaticVoidCallbackVoid );
1377 DALI_TEST_CHECK( signal.Empty() );
1379 wasStaticVoidCallbackVoidCalled = false;
1381 DALI_TEST_EQUALS( wasStaticVoidCallbackVoidCalled, false, TEST_LOCATION );
1387 TestSignals::FloatRet0ParamSignal signal;
1388 DALI_TEST_CHECK( signal.Empty() );
1390 signal.Connect( StaticFloatCallbackVoid );
1391 DALI_TEST_CHECK( ! signal.Empty() );
1393 wasStaticFloatCallbackVoidCalled = false;
1394 float result = signal.Emit();
1395 DALI_TEST_EQUALS( wasStaticFloatCallbackVoidCalled, true, TEST_LOCATION );
1396 DALI_TEST_EQUALS( result, 7.0f, TEST_LOCATION );
1398 signal.Disconnect( StaticFloatCallbackVoid );
1399 DALI_TEST_CHECK( signal.Empty() );
1401 wasStaticFloatCallbackVoidCalled = false;
1402 result = signal.Emit();
1403 DALI_TEST_EQUALS( wasStaticFloatCallbackVoidCalled, false, TEST_LOCATION );
1404 DALI_TEST_EQUALS( result, 0.0f, TEST_LOCATION );
1410 TestSignals::VoidRet1ValueParamSignal signal;
1411 DALI_TEST_CHECK( signal.Empty() );
1413 signal.Connect( StaticVoidCallbackIntValue );
1414 DALI_TEST_CHECK( ! signal.Empty() );
1416 wasStaticVoidCallbackIntValueCalled = false;
1419 DALI_TEST_EQUALS( wasStaticVoidCallbackIntValueCalled, true, TEST_LOCATION );
1420 DALI_TEST_EQUALS( staticIntValue, 10, TEST_LOCATION );
1422 signal.Disconnect( StaticVoidCallbackIntValue );
1423 DALI_TEST_CHECK( signal.Empty() );
1425 wasStaticVoidCallbackIntValueCalled = false;
1428 DALI_TEST_EQUALS( wasStaticVoidCallbackIntValueCalled, false, TEST_LOCATION );
1429 DALI_TEST_EQUALS( staticIntValue, 0, TEST_LOCATION );
1432 // float Func( float, float )
1435 TestSignals::FloatRet2ValueParamSignal signal;
1436 DALI_TEST_CHECK( signal.Empty() );
1438 signal.Connect( StaticFloatCallbackFloatValueFloatValue );
1439 DALI_TEST_CHECK( ! signal.Empty() );
1441 wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1442 staticFloatValue1 = 0.0f;
1443 staticFloatValue2 = 0.0f;
1444 float result = signal.Emit( 5.0f, 6.0f );
1445 DALI_TEST_EQUALS( wasStaticFloatCallbackFloatValueFloatValueCalled, true, TEST_LOCATION );
1446 DALI_TEST_EQUALS( staticFloatValue1, 5.0f, TEST_LOCATION );
1447 DALI_TEST_EQUALS( staticFloatValue2, 6.0f, TEST_LOCATION );
1448 DALI_TEST_EQUALS( result, 5.0f+6.0f, TEST_LOCATION );
1450 signal.Disconnect( StaticFloatCallbackFloatValueFloatValue );
1451 DALI_TEST_CHECK( signal.Empty() );
1453 wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1454 staticFloatValue1 = 0.0f;
1455 staticFloatValue2 = 0.0f;
1456 result = signal.Emit( 7.0f, 8.0f );
1457 DALI_TEST_EQUALS( wasStaticFloatCallbackFloatValueFloatValueCalled, false, TEST_LOCATION );
1458 DALI_TEST_EQUALS( staticFloatValue1, 0.0f, TEST_LOCATION );
1459 DALI_TEST_EQUALS( staticFloatValue2, 0.0f, TEST_LOCATION );
1460 DALI_TEST_EQUALS( result, 0.0f, TEST_LOCATION );
1465 int UtcDaliSignalDisconnectDuringCallback(void)
1467 // Test disconnection during each callback
1469 TestSignals::VoidRetNoParamSignal signal;
1470 DALI_TEST_CHECK( signal.Empty() );
1472 TestSlotDisconnector handler1;
1473 handler1.VoidConnectVoid( signal );
1474 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1475 DALI_TEST_CHECK( ! signal.Empty() );
1478 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1479 DALI_TEST_CHECK( signal.Empty() );
1481 // Repeat with 2 callbacks
1483 handler1.mHandled = false;
1485 TestSlotDisconnector handler2;
1486 handler1.VoidConnectVoid( signal );
1487 handler2.VoidConnectVoid( signal );
1488 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1489 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1490 DALI_TEST_CHECK( ! signal.Empty() );
1493 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1494 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1495 DALI_TEST_CHECK( signal.Empty() );
1497 // Repeat with no callbacks
1499 handler1.mHandled = false;
1500 handler2.mHandled = false;
1503 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1504 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1506 // Repeat with 3 callbacks
1508 TestSlotDisconnector handler3;
1509 handler1.VoidConnectVoid( signal );
1510 handler2.VoidConnectVoid( signal );
1511 handler3.VoidConnectVoid( signal );
1512 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1513 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1514 DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
1515 DALI_TEST_CHECK( ! signal.Empty() );
1518 DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1519 DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1520 DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1521 DALI_TEST_CHECK( signal.Empty() );
1523 // Repeat with no callbacks
1525 handler1.mHandled = false;
1526 handler2.mHandled = false;
1527 handler3.mHandled = false;
1530 DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1531 DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1532 DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
1536 int UtcDaliSignalDisconnectDuringCallback2(void)
1538 // Test disconnection of some (but not all) callbacks during sigmal emission
1540 TestSignals::VoidRetNoParamSignal signal;
1541 DALI_TEST_CHECK( signal.Empty() );
1543 TestSlotMultiDisconnector handler;
1544 handler.ConnectAll( signal );
1545 DALI_TEST_EQUALS( handler.mSlotHandled[0], false, TEST_LOCATION );
1546 DALI_TEST_EQUALS( handler.mSlotHandled[1], false, TEST_LOCATION );
1547 DALI_TEST_EQUALS( handler.mSlotHandled[2], false, TEST_LOCATION );
1548 DALI_TEST_EQUALS( handler.mSlotHandled[3], false, TEST_LOCATION );
1549 DALI_TEST_EQUALS( handler.mSlotHandled[4], false, TEST_LOCATION );
1550 DALI_TEST_EQUALS( handler.mSlotHandled[5], false, TEST_LOCATION );
1551 DALI_TEST_EQUALS( handler.mSlotHandled[6], false, TEST_LOCATION );
1552 DALI_TEST_EQUALS( handler.mSlotHandled[7], false, TEST_LOCATION );
1553 DALI_TEST_EQUALS( handler.mSlotHandled[8], false, TEST_LOCATION );
1554 DALI_TEST_EQUALS( handler.mSlotHandled[9], false, TEST_LOCATION );
1555 DALI_TEST_CHECK( ! signal.Empty() );
1559 // Slots 5, 7, & 9 should be disconnected before being called
1560 DALI_TEST_EQUALS( handler.mSlotHandled[0], true, TEST_LOCATION );
1561 DALI_TEST_EQUALS( handler.mSlotHandled[1], true, TEST_LOCATION );
1562 DALI_TEST_EQUALS( handler.mSlotHandled[2], true, TEST_LOCATION );
1563 DALI_TEST_EQUALS( handler.mSlotHandled[3], true, TEST_LOCATION );
1564 DALI_TEST_EQUALS( handler.mSlotHandled[4], true, TEST_LOCATION );
1565 DALI_TEST_EQUALS( handler.mSlotHandled[5], false, TEST_LOCATION );
1566 DALI_TEST_EQUALS( handler.mSlotHandled[6], true, TEST_LOCATION );
1567 DALI_TEST_EQUALS( handler.mSlotHandled[7], false, TEST_LOCATION );
1568 DALI_TEST_EQUALS( handler.mSlotHandled[8], true, TEST_LOCATION );
1569 DALI_TEST_EQUALS( handler.mSlotHandled[9], false, TEST_LOCATION );
1570 DALI_TEST_CHECK( ! signal.Empty() );
1572 // Odd slots are disconnected
1573 DALI_TEST_EQUALS( handler.GetConnectionCount(), 5u, TEST_LOCATION );
1577 int UtcDaliSignalEmitDuringCallback(void)
1579 TestApplication app; // Create core for debug logging
1581 // for coverage purposes we test the emit guard for each signal type (0,1,2,3 params) void / return value
1583 TestSignals::VoidRetNoParamSignal signal;
1584 DALI_TEST_CHECK( signal.Empty() );
1586 TestEmitDuringCallback handler1;
1587 handler1.VoidConnectVoid( signal );
1589 // Test that this does not result in an infinite loop!
1593 TestSignals::FloatRet0ParamSignal signal;
1595 DALI_TEST_CHECK( signal.Empty() );
1597 TestEmitDuringCallback handler1;
1598 handler1.FloatRet0ParamConnect( signal );
1600 // Test that this does not result in an infinite loop!
1604 TestSignals::FloatRet1ParamSignal signal;
1606 DALI_TEST_CHECK( signal.Empty() );
1608 TestEmitDuringCallback handler1;
1609 handler1.FloatRet1ParamConnect( signal );
1611 // Test that this does not result in an infinite loop!
1615 TestSignals::FloatRet2ValueParamSignal signal;
1617 DALI_TEST_CHECK( signal.Empty() );
1619 TestEmitDuringCallback handler1;
1620 handler1.FloatRet2ParamConnect( signal );
1622 // Test that this does not result in an infinite loop!
1623 signal.Emit( 1.f, 1.f );
1626 TestSignals::FloatRet3ValueParamSignal signal;
1628 DALI_TEST_CHECK( signal.Empty() );
1630 TestEmitDuringCallback handler1;
1631 handler1.FloatRet3ParamConnect( signal );
1633 // Test that this does not result in an infinite loop!
1634 signal.Emit( 1.f,1.f,1.f );
1639 int UtcDaliSignalDeleteDuringEmit(void)
1641 // testing a signal deletion during an emit
1642 // need to dynamically allocate the signal for this to work
1644 TestApplication app; // Create core for debug logging
1646 TestSignals::VoidRetNoParamSignal* signal = new TestSignals::VoidRetNoParamSignal;
1648 TestEmitDuringCallback handler1;
1649 handler1.DeleteDuringEmitConnect( *signal );
1651 // should just log an error
1654 tet_result( TET_PASS );
1659 int UtcDaliSignalTestApp01(void)
1661 // Test 1 signal connected to 1 Slot.
1662 // Signal dies first.
1664 TestButton* button = new TestButton(1);
1666 button->DownSignal().Connect(&app,&TestApp::OnButtonPress);
1668 // check we have both the button, and the app have 1 connection
1669 DALI_TEST_EQUALS( app.GetConnectionCount(), 1u, TEST_LOCATION );
1670 DALI_TEST_EQUALS( button->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
1672 delete button; // should automatically destroy the connection
1674 // check we have a 0 connections
1675 DALI_TEST_EQUALS( app.GetConnectionCount(), 0u, TEST_LOCATION );
1680 int UtcDaliSignalTestApp02(void)
1682 // Test 1 signal connected to 1 Slot.
1683 // Slot owning object dies first.
1685 TestButton button(1);
1686 TestApp *app = new TestApp;
1687 button.DownSignal().Connect( app, &TestApp::OnButtonPress);
1689 // check we have a 1 connection
1690 DALI_TEST_EQUALS( app->GetConnectionCount(), 1u, TEST_LOCATION );
1691 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
1693 delete app; // should automatically destroy the connection
1695 // check we have a 0 connections
1696 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION );
1700 int UtcDaliSignalTestApp03(void)
1702 // Test 1 Signal connect to 2 slots
1703 // 1 of the slot owners dies. Then the second slot owner dies
1705 TestButton button(1);
1706 TestApp *app1 = new TestApp;
1707 TestApp *app2 = new TestApp;
1709 button.DownSignal().Connect( app1, &TestApp::OnButtonPress);
1710 button.DownSignal().Connect( app2, &TestApp::OnButtonPress);
1712 // check we have a 2 connections to the signal
1713 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 2u, TEST_LOCATION );
1715 // kill the first slot
1716 delete app1; // should automatically destroy the connection
1718 // check we have 1 connection left
1719 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
1721 button.Press(); // emit the signal (to ensure it doesn't seg fault)
1723 // kill the second slot
1724 delete app2; // should automatically destroy the connection
1726 // check we have 1 connection left
1727 DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION );
1732 int UtcDaliSignalTestApp04(void)
1734 // Test 1 Signal connected to 2 slots (with different owners)
1735 // The Signal dies, check the 2 slots disconnect automatically
1737 TestButton* button = new TestButton(1);
1741 button->DownSignal().Connect(&app1,&TestApp::OnButtonPress);
1742 button->DownSignal().Connect(&app2,&TestApp::OnButtonPress);
1744 // check the connection counts
1745 DALI_TEST_EQUALS( app1.GetConnectionCount(), 1u, TEST_LOCATION );
1746 DALI_TEST_EQUALS( app2.GetConnectionCount(), 1u, TEST_LOCATION );
1747 DALI_TEST_EQUALS( button->DownSignal().GetConnectionCount(), 2u, TEST_LOCATION );
1749 delete button; // should automatically destroy the connection
1751 // check both slot owners have zero connections
1752 DALI_TEST_EQUALS( app1.GetConnectionCount(), 0u, TEST_LOCATION );
1753 DALI_TEST_EQUALS( app2.GetConnectionCount(), 0u, TEST_LOCATION );
1757 int UtcDaliSignalTestApp05(void)
1759 // Test 2 Signals (with different owners) connected to 1 slots
1760 // 1 Signal dies, check that the remaining connection is valid
1762 TestButton* button1 = new TestButton(1); // use for signal 1
1763 TestButton* button2 = new TestButton(2); // use for signal 2
1767 button1->DownSignal().Connect(&app,&TestApp::OnButtonPress);
1768 button2->DownSignal().Connect(&app,&TestApp::OnButtonPress);
1770 // check the connection counts
1771 DALI_TEST_EQUALS( app.GetConnectionCount(), 2u, TEST_LOCATION );
1772 DALI_TEST_EQUALS( button1->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
1773 DALI_TEST_EQUALS( button2->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
1775 // make sure both signals emit ok
1777 DALI_TEST_EQUALS( app.GetButtonPressedId() , 2 , TEST_LOCATION );
1780 DALI_TEST_EQUALS( app.GetButtonPressedId() , 1 , TEST_LOCATION );
1782 delete button1; // should automatically destroy 1 connection
1784 // check both slot owners have zero connections
1785 DALI_TEST_EQUALS( app.GetConnectionCount(), 1u, TEST_LOCATION );
1787 // check remaining connection still works
1789 DALI_TEST_EQUALS( app.GetButtonPressedId() , 2 , TEST_LOCATION );
1791 // kill the last signal
1793 DALI_TEST_EQUALS( app.GetConnectionCount(), 0u, TEST_LOCATION );
1797 int UtcDaliSignalTestApp06(void)
1799 Signal< bool () > boolSignal;
1803 // connect a slot which will return false
1804 boolSignal.Connect( &app, &TestApp::BoolReturnTestFalse);
1805 result = boolSignal.Emit();
1806 DALI_TEST_EQUALS( result, false, TEST_LOCATION );
1808 // disconnect last slot, and connect a slot which returns true
1809 boolSignal.Disconnect( &app, &TestApp::BoolReturnTestFalse);
1810 boolSignal.Connect( &app, &TestApp::BoolReturnTestTrue);
1811 result = boolSignal.Emit();
1812 DALI_TEST_EQUALS( result, true, TEST_LOCATION );
1816 int UtcDaliSlotDelegateConnection(void)
1818 TestSignals signals;
1821 TestSlotDelegateHandler handlers;
1822 signals.SignalVoidNone().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
1823 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1824 signals.EmitVoidSignalVoid();
1825 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1827 // Test double emission
1828 handlers.mHandled = false;
1829 signals.EmitVoidSignalVoid();
1830 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1832 signals.CheckNoConnections();
1835 TestSlotDelegateHandler handlers;
1836 signals.SignalVoid1Ref().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef );
1837 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1839 signals.EmitVoidSignalIntRef(x);
1840 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1841 DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
1843 signals.CheckNoConnections();
1846 TestSlotDelegateHandler handlers;
1847 signals.SignalVoid1Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue );
1848 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1849 signals.EmitVoidSignal1IntValue(5);
1850 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1851 DALI_TEST_EQUALS( handlers.mIntParam1, 5, TEST_LOCATION );
1853 signals.CheckNoConnections();
1856 TestSlotDelegateHandler handlers;
1857 signals.SignalVoid2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue );
1858 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1859 signals.EmitVoidSignal2IntValue(6, 7);
1860 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1861 DALI_TEST_EQUALS( handlers.mIntParam1, 6, TEST_LOCATION );
1862 DALI_TEST_EQUALS( handlers.mIntParam2, 7, TEST_LOCATION );
1864 signals.CheckNoConnections();
1867 TestSlotDelegateHandler handlers;
1868 signals.SignalBool1Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue );
1869 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1871 handlers.mBoolReturn = true;
1872 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION );
1873 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1874 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1876 // repeat with opposite return value
1877 handlers.mBoolReturn = false;
1878 handlers.mHandled = false;
1879 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION );
1880 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1881 DALI_TEST_EQUALS( handlers.mFloatParam1, 6.0f, TEST_LOCATION );
1883 signals.CheckNoConnections();
1886 TestSlotDelegateHandler handlers;
1887 signals.SignalBool2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue );
1888 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1889 handlers.mBoolReturn = true;
1890 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION );
1891 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1892 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1893 DALI_TEST_EQUALS( handlers.mIntParam2, 10, TEST_LOCATION );
1895 signals.CheckNoConnections();
1898 TestSlotDelegateHandler handlers;
1899 signals.SignalInt2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue );
1900 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1901 handlers.mIntReturn = 27;
1902 int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
1903 DALI_TEST_EQUALS( x, 27, TEST_LOCATION );
1904 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1905 DALI_TEST_EQUALS( handlers.mFloatParam1, 33.5f, TEST_LOCATION );
1906 DALI_TEST_EQUALS( handlers.mIntParam2, 5, TEST_LOCATION );
1908 signals.CheckNoConnections();
1911 TestSlotDelegateHandler handlers;
1912 signals.SignalFloat0().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid );
1913 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1914 handlers.mFloatReturn = 27.0f;
1915 float f = signals.EmitFloat0Signal();
1916 DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
1917 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1918 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1919 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1921 signals.CheckNoConnections();
1924 TestSlotDelegateHandler handlers;
1925 signals.SignalFloat2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue );
1926 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1927 handlers.mFloatReturn = 27.0f;
1928 float f = signals.EmitFloat2VSignal(5, 33.0f);
1929 DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
1930 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1931 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1932 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1934 signals.CheckNoConnections();
1937 TestSlotDelegateHandler handlers;
1938 signals.VoidSignalFloatValue3().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotFloatValue3 );
1939 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1940 signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
1941 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1942 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1943 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1944 DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
1946 signals.CheckNoConnections();
1949 TestSlotDelegateHandler handlers;
1950 signals.SignalFloat3Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValue3 );
1951 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1952 handlers.mFloatReturn = 27.0f;
1953 float returnValue = signals.EmitFloat3VSignal(5, 33.0f, 100.0f);
1954 DALI_TEST_EQUALS( returnValue, 27.0f, TEST_LOCATION );
1955 DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1956 DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1957 DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1958 DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
1960 signals.CheckNoConnections();
1964 int UtcDaliSignalSlotDelegateDestruction(void)
1966 // Test that signal disconnect works when slot-delegate is destroyed (goes out of scope)
1969 TestSignals::VoidRetNoParamSignal signal;
1971 DALI_TEST_CHECK( signal.Empty() );
1972 TestSlotDelegateHandler handler;
1973 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
1974 DALI_TEST_CHECK( ! signal.Empty() );
1976 // End of slot lifetime
1977 DALI_TEST_CHECK( signal.Empty() );
1979 // Signal emission should be a NOOP
1984 TestSignals::VoidRet1ValueParamSignal signal;
1986 DALI_TEST_CHECK( signal.Empty() );
1987 TestSlotDelegateHandler handler;
1988 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue );
1989 DALI_TEST_CHECK( ! signal.Empty() );
1991 // End of slot lifetime
1992 DALI_TEST_CHECK( signal.Empty() );
1994 // Signal emission should be a NOOP
1999 TestSignals::VoidRet1RefParamSignal signal;
2001 DALI_TEST_CHECK( signal.Empty() );
2002 TestSlotDelegateHandler handler;
2003 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef );
2004 DALI_TEST_CHECK( ! signal.Empty() );
2006 // End of slot lifetime
2007 DALI_TEST_CHECK( signal.Empty() );
2009 // Signal emission should be a NOOP
2011 signal.Emit( temp );
2015 TestSignals::VoidRet2ValueParamSignal signal;
2017 DALI_TEST_CHECK( signal.Empty() );
2018 TestSlotDelegateHandler handler;
2019 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue );
2020 DALI_TEST_CHECK( ! signal.Empty() );
2022 // End of slot lifetime
2023 DALI_TEST_CHECK( signal.Empty() );
2025 // Signal emission should be a NOOP
2026 signal.Emit( 1, 2 );
2030 TestSignals::BoolRet1ValueParamSignal signal;
2032 DALI_TEST_CHECK( signal.Empty() );
2033 TestSlotDelegateHandler handler;
2034 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue );
2035 DALI_TEST_CHECK( ! signal.Empty() );
2037 // End of slot lifetime
2038 DALI_TEST_CHECK( signal.Empty() );
2040 // Signal emission should be a NOOP
2041 bool blah = signal.Emit( 1.0f );
2042 DALI_TEST_CHECK( ! blah );
2046 TestSignals::BoolRet2ValueParamSignal signal;
2048 DALI_TEST_CHECK( signal.Empty() );
2049 TestSlotDelegateHandler handler;
2050 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue );
2051 DALI_TEST_CHECK( ! signal.Empty() );
2053 // End of slot lifetime
2054 DALI_TEST_CHECK( signal.Empty() );
2056 // Signal emission should be a NOOP
2057 bool blah = signal.Emit( 1.0f, 2 );
2058 DALI_TEST_CHECK( ! blah );
2062 TestSignals::IntRet2ValueParamSignal signal;
2064 DALI_TEST_CHECK( signal.Empty() );
2065 TestSlotDelegateHandler handler;
2066 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue );
2067 DALI_TEST_CHECK( ! signal.Empty() );
2069 // End of slot lifetime
2070 DALI_TEST_CHECK( signal.Empty() );
2072 // Signal emission should be a NOOP
2073 int blah = signal.Emit( 10.0f, 100 );
2074 DALI_TEST_CHECK( 0 == blah );
2078 TestSignals::FloatRet0ParamSignal signal;
2080 DALI_TEST_CHECK( signal.Empty() );
2081 TestSlotDelegateHandler handler;
2082 signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid );
2083 DALI_TEST_CHECK( ! signal.Empty() );
2085 // End of slot lifetime
2086 DALI_TEST_CHECK( signal.Empty() );
2088 // Signal emission should be a NOOP
2089 float blah = signal.Emit();
2090 DALI_TEST_CHECK( 0.0f == blah );
2094 TestSignals::FloatRet2ValueParamSignal signal;
2096 DALI_TEST_CHECK( signal.Empty() );
2097 TestSlotDelegateHandler handler;
2098 signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2099 DALI_TEST_CHECK( ! signal.Empty() );
2101 // End of slot lifetime
2102 DALI_TEST_CHECK( signal.Empty() );
2104 // Signal emission should be a NOOP
2105 float blah = signal.Emit( 3.0f, 4.0f );
2106 DALI_TEST_CHECK( 0.0f == blah );
2111 int UtcDaliSlotHandlerDisconnect(void)
2113 // Test that callbacks don't occur if a signal is disconnected before emission
2115 TestSignals signals;
2118 TestSlotDelegateHandler handlers;
2119 signals.SignalVoidNone().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
2120 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2121 signals.SignalVoidNone().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
2122 signals.EmitVoidSignalVoid();
2123 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2127 TestSlotDelegateHandler handlers;
2128 signals.SignalVoid1Ref().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
2129 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2131 handlers.mIntReturn = 5;
2132 signals.SignalVoid1Ref().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
2133 signals.EmitVoidSignalIntRef(r);
2134 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2135 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2136 DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
2140 TestSlotDelegateHandler handlers;
2141 signals.SignalVoid1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
2142 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2143 signals.SignalVoid1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
2144 signals.EmitVoidSignal1IntValue(5);
2145 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2146 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2150 TestSlotDelegateHandler handlers;
2151 signals.SignalVoid2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
2152 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2153 signals.SignalVoid2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
2154 signals.EmitVoidSignal2IntValue(5, 10);
2155 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2156 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2157 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
2161 TestSlotDelegateHandler handlers;
2162 signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2163 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2164 handlers.mBoolReturn = true;
2165 signals.SignalBool1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2166 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
2167 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2168 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
2172 TestSlotDelegateHandler handlers;
2173 signals.SignalBool2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2174 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2175 handlers.mBoolReturn = true;
2176 signals.SignalBool2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2177 DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
2178 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2179 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
2180 DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
2184 TestSlotDelegateHandler handlers;
2185 signals.SignalInt2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2186 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2187 handlers.mIntReturn = 27;
2188 signals.SignalInt2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2189 signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
2190 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2191 DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2192 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2196 TestSlotDelegateHandler handlers;
2197 signals.SignalFloat0().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2198 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2199 handlers.mFloatReturn = 27.0f;
2200 signals.SignalFloat0().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2201 signals.EmitFloat0Signal();
2202 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2203 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
2204 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2208 TestSlotDelegateHandler handlers;
2209 signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2210 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2211 handlers.mFloatReturn = 27.0f;
2212 signals.SignalFloat2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2213 signals.EmitFloat2VSignal(5, 33.0f);
2214 DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2215 DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
2216 DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2222 int UtcDaliCallbackBase(void)
2224 // simple constructor for coverage
2226 tet_result( TET_PASS );