automated-tests/src/dali/utc-Dali-SignalTemplates.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   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
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  *
  16  */
  17
  18 // EXTERNAL INCLUDES
  19 #include <stdlib.h>
  20
  21 #include <iostream>
  22
  23 // INTERNAL INCLUDES
  24 #include <dali-test-suite-utils.h>
  25 #include <dali/public-api/dali-core.h>
  26
  27 #include "signal-helper.h"
  28
  29 using namespace Dali;
  30
  31 bool StaticFunctionHandlers::staticFunctionHandled;
  32
  33 void utc_dali_signal_templates_startup(void)
  34 {
  35   test_return_value = TET_UNDEF;
  36 }
  37
  38 void utc_dali_signal_templates_cleanup(void)
  39 {
  40   test_return_value = TET_PASS;
  41 }
  42
  43 namespace
  44 {
  45 bool  wasStaticVoidCallbackVoidCalled                  = false;
  46 bool  wasStaticFloatCallbackVoidCalled                 = false;
  47 bool  wasStaticVoidCallbackIntValueCalled              = false;
  48 int   staticIntValue                                   = 0;
  49 bool  wasStaticFloatCallbackFloatValueFloatValueCalled = false;
  50 float staticFloatValue1                                = 0.0f;
  51 float staticFloatValue2                                = 0.0f;
  52
  53 void StaticVoidCallbackVoid()
  54 {
  55   wasStaticVoidCallbackVoidCalled = true;
  56 }
  57
  58 void AlternativeVoidCallbackVoid()
  59 {
  60 }
  61
  62 float StaticFloatCallbackVoid()
  63 {
  64   wasStaticFloatCallbackVoidCalled = true;
  65   return 7.0f;
  66 }
  67
  68 void StaticVoidCallbackIntValue(int value)
  69 {
  70   wasStaticVoidCallbackIntValueCalled = true;
  71   staticIntValue                      = value;
  72 }
  73
  74 float StaticFloatCallbackFloatValueFloatValue(float value1, float value2)
  75 {
  76   wasStaticFloatCallbackFloatValueFloatValueCalled = true;
  77   staticFloatValue1                                = value1;
  78   staticFloatValue2                                = value2;
  79   return value1 + value2;
  80 }
  81
  82 } // namespace
  83
  84 /*******************************************
  85  *
  86  * Start of Utc test cases.
  87  * Test cases performed in order of API listed in dali-signal.h
  88  * UtcDaliSignal + FunctionName + P=positive test, N = Negative test
  89  *
  90  */
  91
  92 int UtcDaliSignalEmptyP(void)
  93 {
  94   TestApplication application; // Create core for debug logging
  95
  96   // Test that Empty() is true, when no slots connected to the signal
  97
  98   {
  99     TestSignals::VoidRetNoParamSignal signal;
 100     DALI_TEST_CHECK(signal.Empty());
 101   }
 102
 103   // Test that Empty() is true, when a slot has connected and disconnected
 104   {
 105     TestSignals::VoidRetNoParamSignal signal;
 106     TestSlotHandler                   handler;
 107     signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
 108     signal.Disconnect(&handler, &TestSlotHandler::VoidSlotVoid);
 109     DALI_TEST_CHECK(signal.Empty());
 110   }
 111
 112   END_TEST;
 113 }
 114
 115 int UtcDaliSignalEmptyN(void)
 116 {
 117   TestApplication application; // Create core for debug logging
 118
 119   // Test that Empty() is false after signal connection
 120   TestSignals::VoidRetNoParamSignal signal;
 121   TestSlotHandler                   handler;
 122   signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
 123   DALI_TEST_CHECK(!signal.Empty());
 124
 125   END_TEST;
 126 }
 127
 128 int UtcDaliSignalGetConnectionCountP(void)
 129 {
 130   TestApplication application; // Create core for debug logging
 131
 132   TestSignals::VoidRetNoParamSignal signal;
 133   TestSlotHandler                   handler;
 134   signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
 135   DALI_TEST_CHECK(signal.GetConnectionCount() == 1);
 136
 137   TestSlotHandler handler2;
 138   signal.Connect(&handler2, &TestSlotHandler::VoidSlotVoid);
 139   DALI_TEST_CHECK(signal.GetConnectionCount() == 2);
 140
 141   END_TEST;
 142 }
 143
 144 int UtcDaliSignalGetConnectionCountN(void)
 145 {
 146   TestApplication                   application; // Create core for debug logging
 147   TestSignals::VoidRetNoParamSignal signal;
 148   DALI_TEST_CHECK(signal.GetConnectionCount() == 0);
 149   END_TEST;
 150 }
 151
 152 /**
 153  * there are 5 different connection functions
 154  * we go through them here in order of definition in dali-signal.h
 155  */
 156 int UtcDaliSignalConnectP01(void)
 157 {
 158   TestApplication application; // Create core for debug logging
 159
 160   // test static function: void Connect( void (*func)() )
 161   TestSignals::VoidRetNoParamSignal signal;
 162   signal.Connect(StaticVoidCallbackVoid);
 163   DALI_TEST_CHECK(!signal.Empty());
 164
 165   END_TEST;
 166 }
 167
 168 int UtcDaliSignalConnectN01(void)
 169 {
 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 application; // Create core for debug logging
 174
 175   TestSignals::VoidRetNoParamSignal signal;
 176   signal.Connect(NULL);
 177   try
 178   {
 179     signal.Emit();
 180   }
 181   catch(Dali::DaliException& e)
 182   {
 183     // Tests that a negative test of an assertion succeeds
 184     DALI_TEST_PRINT_ASSERT(e);
 185     tet_result(TET_PASS);
 186   }
 187   END_TEST;
 188 }
 189
 190 int UtcDaliSignalConnectP02(void)
 191 {
 192   TestApplication application; // Create core for debug logging
 193
 194   // test member function: Connect( X* obj, void (X::*func)() ))
 195   TestSignals::VoidRetNoParamSignal signal;
 196   TestSlotHandler                   handler;
 197   signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
 198   DALI_TEST_CHECK(!signal.Empty());
 199   signal.Emit();
 200   DALI_TEST_CHECK(handler.mHandled == true);
 201   END_TEST;
 202 }
 203
 204 int UtcDaliSignalConnectN02(void)
 205 {
 206   TestApplication application; // Create core for debug logging
 207
 208   TestSignals::VoidRetNoParamSignal signal;
 209   try
 210   {
 211     // test member function: Connect( X* obj, void (X::*func)() )) with NULL object
 212     signal.Connect(static_cast<TestSlotHandler*>(NULL), &TestSlotHandler::VoidSlotVoid);
 213   }
 214   catch(Dali::DaliException& e)
 215   {
 216     // Tests that a negative test of an assertion succeeds
 217     DALI_TEST_PRINT_ASSERT(e);
 218     tet_result(TET_PASS);
 219   }
 220   END_TEST;
 221 }
 222
 223 int UtcDaliSignalConnectP03(void)
 224 {
 225   TestApplication application; // Create core for debug logging
 226
 227   // test slot delegate: Connect( SlotDelegate<X>& delegate, void (X::*func)() )
 228   TestSignals::VoidRetNoParamSignal signal;
 229   TestSlotDelegateHandler           handler;
 230   signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
 231   DALI_TEST_CHECK(!signal.Empty());
 232   signal.Emit();
 233   DALI_TEST_CHECK(handler.mHandled == true);
 234
 235   END_TEST;
 236 }
 237
 238 int UtcDaliSignalConnectN03(void)
 239 {
 240   TestApplication application; // Create core for debug logging
 241   // the delegate is passed by reference, so you can't pass null.
 242   tet_result(TET_PASS);
 243   END_TEST;
 244 }
 245
 246 int UtcDaliSignalConnectP04(void)
 247 {
 248   TestApplication application; // Create core for debug logging
 249
 250   //  test function object: Connect( ConnectionTrackerInterface* connectionTracker, const X& func )
 251   TestSlotHandler                   handler;
 252   TestSignals::VoidRetNoParamSignal signal;
 253   bool                              functorCalled(false);
 254   TestFunctor                       functor(functorCalled);
 255   signal.Connect(&handler, functor);
 256   DALI_TEST_CHECK(!signal.Empty());
 257   signal.Emit();
 258   DALI_TEST_CHECK(functorCalled == true);
 259
 260   END_TEST;
 261 }
 262
 263 int UtcDaliSignalConnectN04(void)
 264 {
 265   // for negative test we try to connect a null connection tracker to the signal
 266   TestSignals::VoidRetNoParamSignal signal;
 267   TestSlotHandler*                  nullHandler(NULL);
 268   try
 269   {
 270     signal.Connect(nullHandler, &TestSlotHandler::VoidSlotVoid);
 271   }
 272   catch(Dali::DaliException& e)
 273   {
 274     // Tests that a negative test of an assertion succeeds
 275     DALI_TEST_PRINT_ASSERT(e);
 276     tet_result(TET_PASS);
 277   }
 278
 279   END_TEST;
 280 }
 281
 282 int UtcDaliSignalConnectP05(void)
 283 {
 284   TestApplication application; // Create core for debug logging
 285
 286   // test function object using FunctorDelegate.
 287   // :Connect( ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate )
 288   {
 289     TestSlotHandler                   handler;
 290     TestSignals::VoidRetNoParamSignal signal;
 291     bool                              functorDelegateCalled(false);
 292     signal.Connect(&handler, FunctorDelegate::New(VoidFunctorVoid(functorDelegateCalled)));
 293     DALI_TEST_CHECK(!signal.Empty());
 294     signal.Emit();
 295     DALI_TEST_CHECK(functorDelegateCalled == true);
 296   }
 297   {
 298     TestSlotHandler                       handler;
 299     TestSignals::VoidRet1ValueParamSignal signal;
 300     bool                                  functorDelegateCalled(false);
 301     signal.Connect(&handler, FunctorDelegate::New(VoidFunctorVoid(functorDelegateCalled)));
 302     DALI_TEST_CHECK(!signal.Empty());
 303     signal.Emit(1);
 304   }
 305   END_TEST;
 306 }
 307
 308 int UtcDaliSignalConnectN05(void)
 309 {
 310   TestApplication application; // Create core for debug logging
 311
 312   // for negative test we try to connect a null connection tracker to the signal
 313   // :Connect( ConnectionTrackerInterface == NULL, FunctorDelegate* delegate )
 314   TestSlotHandler*                  nullHandler(NULL);
 315   TestSignals::VoidRetNoParamSignal signal;
 316   bool                              functorDelegateCalled(false);
 317   try
 318   {
 319     signal.Connect(nullHandler, FunctorDelegate::New(VoidFunctorVoid(functorDelegateCalled)));
 320   }
 321   catch(Dali::DaliException& e)
 322   {
 323     DALI_TEST_PRINT_ASSERT(e);
 324     tet_result(TET_PASS);
 325   }
 326   END_TEST;
 327 }
 328
 329 /**
 330  * there 3 different disconnect functions
 331  *  we go through them here in order of definition in dali-signal.h
 332  */
 333 int UtcDaliSignalDisconnectP01(void)
 334 {
 335   TestApplication application; // Create core for debug logging
 336
 337   // test static function:  Disconnect( void (*func)( Arg0 arg0 ) )
 338
 339   TestSignals::VoidRetNoParamSignal signal;
 340   signal.Connect(StaticVoidCallbackVoid);
 341   DALI_TEST_CHECK(!signal.Empty());
 342   signal.Disconnect(StaticVoidCallbackVoid);
 343   DALI_TEST_CHECK(signal.Empty());
 344
 345   END_TEST;
 346 }
 347 int UtcDaliSignalDisconnectN01(void)
 348 {
 349   TestApplication application; // Create core for debug logging
 350
 351   // 1. Disconnect using the function
 352   TestSignals::VoidRetNoParamSignal signal;
 353   signal.Connect(StaticVoidCallbackVoid);
 354   DALI_TEST_CHECK(!signal.Empty());
 355
 356   signal.Disconnect(AlternativeVoidCallbackVoid);
 357
 358   DALI_TEST_CHECK(!signal.Empty());
 359
 360   END_TEST;
 361 }
 362
 363 int UtcDaliSignalDisconnectP02(void)
 364 {
 365   TestApplication application; // Create core for debug logging
 366
 367   // test member function: Disconnect( X* obj, void (X::*func)( Arg0 arg0 ) )
 368   TestSignals::VoidRetNoParamSignal signal;
 369   TestSlotHandler                   handler;
 370   signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
 371   DALI_TEST_CHECK(!signal.Empty());
 372   signal.Disconnect(&handler, &TestSlotHandler::VoidSlotVoid);
 373   DALI_TEST_CHECK(signal.Empty());
 374
 375   END_TEST;
 376 }
 377 int UtcDaliSignalDisconnectN02(void)
 378 {
 379   TestApplication application; // Create core for debug logging
 380
 381   // 1. Disconnect using a null connection tracker
 382   TestSignals::VoidRetNoParamSignal signal;
 383   TestSlotHandler                   handler;
 384
 385   signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
 386   DALI_TEST_CHECK(!signal.Empty());
 387
 388   try
 389   {
 390     TestSlotHandler* nullHandler(NULL);
 391     signal.Disconnect(nullHandler, &TestSlotHandler::VoidSlotVoid);
 392   }
 393   catch(Dali::DaliException& e)
 394   {
 395     // Tests that a negative test of an assertion succeeds
 396     DALI_TEST_PRINT_ASSERT(e);
 397     DALI_TEST_CHECK(!signal.Empty());
 398   }
 399   END_TEST;
 400 }
 401
 402 int UtcDaliSignalDisconnectP03(void)
 403 {
 404   TestApplication application; // Create core for debug logging
 405
 406   // test slot delegate: Disconnect( SlotDelegate<X>& delegate, void (X::*func)( Arg0 arg0 ) )
 407   TestSignals::VoidRetNoParamSignal signal;
 408   TestSlotDelegateHandler           handler;
 409   signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
 410   DALI_TEST_CHECK(!signal.Empty());
 411   signal.Disconnect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
 412   DALI_TEST_CHECK(signal.Empty());
 413
 414   END_TEST;
 415 }
 416
 417 int UtcDaliSignalDisconnectN03(void)
 418 {
 419   TestApplication application; // Create core for debug logging
 420
 421   // try to disconnect from the wrong signal
 422   TestSignals::VoidRetNoParamSignal signal;
 423   TestSlotDelegateHandler           handler;
 424   signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
 425
 426   // use different signal
 427   signal.Disconnect(handler.mSlotDelegate, &TestSlotDelegateHandler::AlternativeVoidSlotVoid);
 428
 429   DALI_TEST_CHECK(!signal.Empty());
 430
 431   END_TEST;
 432 }
 433
 434 /*******************************************
 435  *
 436  * End of Utc test cases for the individual API's of Signals
 437  * The following testing Signals functionality as a whole
 438  *
 439  *
 440  */
 441
 442 int UtcDaliSignalEmptyCheckSlotDestruction(void)
 443 {
 444   // Test that signal disconnect works when slot is destroyed (goes out of scope)
 445   {
 446     TestSignals::VoidRetNoParamSignal signal;
 447     {
 448       DALI_TEST_CHECK(signal.Empty());
 449       TestSlotHandler handler;
 450       signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
 451       DALI_TEST_CHECK(!signal.Empty());
 452     }
 453     // End of slot lifetime
 454     DALI_TEST_CHECK(signal.Empty());
 455
 456     // Signal emission should be a NOOP
 457     signal.Emit();
 458   }
 459
 460   {
 461     TestSignals::VoidRet1ValueParamSignal signal;
 462     {
 463       DALI_TEST_CHECK(signal.Empty());
 464       TestSlotHandler handler;
 465       signal.Connect(&handler, &TestSlotHandler::VoidSlotIntValue);
 466       DALI_TEST_CHECK(!signal.Empty());
 467     }
 468     // End of slot lifetime
 469     DALI_TEST_CHECK(signal.Empty());
 470
 471     // Signal emission should be a NOOP
 472     signal.Emit(10);
 473   }
 474
 475   {
 476     TestSignals::VoidRet1RefParamSignal signal;
 477     {
 478       DALI_TEST_CHECK(signal.Empty());
 479       TestSlotHandler handler;
 480       signal.Connect(&handler, &TestSlotHandler::VoidSlotIntRef);
 481       DALI_TEST_CHECK(!signal.Empty());
 482     }
 483     // End of slot lifetime
 484     DALI_TEST_CHECK(signal.Empty());
 485
 486     // Signal emission should be a NOOP
 487     int temp(5);
 488     signal.Emit(temp);
 489   }
 490
 491   {
 492     TestSignals::VoidRet2ValueParamSignal signal;
 493     {
 494       DALI_TEST_CHECK(signal.Empty());
 495       TestSlotHandler handler;
 496       signal.Connect(&handler, &TestSlotHandler::VoidSlotIntValueIntValue);
 497       DALI_TEST_CHECK(!signal.Empty());
 498     }
 499     // End of slot lifetime
 500     DALI_TEST_CHECK(signal.Empty());
 501
 502     // Signal emission should be a NOOP
 503     signal.Emit(1, 2);
 504   }
 505
 506   {
 507     TestSignals::BoolRet1ValueParamSignal signal;
 508     {
 509       DALI_TEST_CHECK(signal.Empty());
 510       TestSlotHandler handler;
 511       signal.Connect(&handler, &TestSlotHandler::BoolSlotFloatValue);
 512       DALI_TEST_CHECK(!signal.Empty());
 513     }
 514     // End of slot lifetime
 515     DALI_TEST_CHECK(signal.Empty());
 516
 517     // Signal emission should be a NOOP
 518     bool blah = signal.Emit(1.0f);
 519     DALI_TEST_CHECK(!blah);
 520   }
 521
 522   {
 523     TestSignals::BoolRet2ValueParamSignal signal;
 524     {
 525       DALI_TEST_CHECK(signal.Empty());
 526       TestSlotHandler handler;
 527       signal.Connect(&handler, &TestSlotHandler::BoolSlotFloatValueIntValue);
 528       DALI_TEST_CHECK(!signal.Empty());
 529     }
 530     // End of slot lifetime
 531     DALI_TEST_CHECK(signal.Empty());
 532
 533     // Signal emission should be a NOOP
 534     bool blah = signal.Emit(1.0f, 2);
 535     DALI_TEST_CHECK(!blah);
 536   }
 537
 538   {
 539     TestSignals::IntRet2ValueParamSignal signal;
 540     {
 541       DALI_TEST_CHECK(signal.Empty());
 542       TestSlotHandler handler;
 543       signal.Connect(&handler, &TestSlotHandler::IntSlotFloatValueIntValue);
 544       DALI_TEST_CHECK(!signal.Empty());
 545     }
 546     // End of slot lifetime
 547     DALI_TEST_CHECK(signal.Empty());
 548
 549     // Signal emission should be a NOOP
 550     int blah = signal.Emit(10.0f, 100);
 551     DALI_TEST_CHECK(0 == blah);
 552   }
 553
 554   {
 555     TestSignals::FloatRet0ParamSignal signal;
 556     {
 557       DALI_TEST_CHECK(signal.Empty());
 558       TestSlotHandler handler;
 559       signal.Connect(&handler, &TestSlotHandler::FloatSlotVoid);
 560       DALI_TEST_CHECK(!signal.Empty());
 561     }
 562     // End of slot lifetime
 563     DALI_TEST_CHECK(signal.Empty());
 564
 565     // Signal emission should be a NOOP
 566     float blah = signal.Emit();
 567     DALI_TEST_CHECK(0.0f == blah);
 568   }
 569
 570   {
 571     TestSignals::FloatRet2ValueParamSignal signal;
 572     {
 573       DALI_TEST_CHECK(signal.Empty());
 574       TestSlotHandler handler;
 575       signal.Connect(&handler, &TestSlotHandler::FloatSlotFloatValueFloatValue);
 576       DALI_TEST_CHECK(!signal.Empty());
 577     }
 578     // End of slot lifetime
 579     DALI_TEST_CHECK(signal.Empty());
 580
 581     // Signal emission should be a NOOP
 582     float blah = signal.Emit(3.0f, 4.0f);
 583     DALI_TEST_CHECK(0.0f == blah);
 584   }
 585   END_TEST;
 586 }
 587
 588 // Positive test case for a method
 589 int UtcDaliSignalConnectAndEmit01P(void)
 590 {
 591   // Test basic signal emission for each slot type
 592
 593   TestSignals signals;
 594
 595   {
 596     TestSlotHandler handlers;
 597     signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
 598     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 599     signals.EmitVoidSignalVoid();
 600     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
 601
 602     // Test double emission
 603     handlers.mHandled = false;
 604     signals.EmitVoidSignalVoid();
 605     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
 606   }
 607   signals.CheckNoConnections();
 608
 609   {
 610     TestSlotHandler handlers;
 611     signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
 612     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 613     int x = 7;
 614     signals.EmitVoidSignalIntRef(x);
 615     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
 616     DALI_TEST_EQUALS(handlers.mIntParam1, 7, TEST_LOCATION);
 617   }
 618   signals.CheckNoConnections();
 619
 620   {
 621     TestSlotHandler handlers;
 622     signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
 623     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 624     signals.EmitVoidSignal1IntValue(5);
 625     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
 626     DALI_TEST_EQUALS(handlers.mIntParam1, 5, TEST_LOCATION);
 627   }
 628   signals.CheckNoConnections();
 629
 630   {
 631     TestSlotHandler handlers;
 632     signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
 633     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 634     signals.EmitVoidSignal2IntValue(6, 7);
 635     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
 636     DALI_TEST_EQUALS(handlers.mIntParam1, 6, TEST_LOCATION);
 637     DALI_TEST_EQUALS(handlers.mIntParam2, 7, TEST_LOCATION);
 638   }
 639   signals.CheckNoConnections();
 640
 641   {
 642     TestSlotHandler handlers;
 643     signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
 644     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 645
 646     handlers.mBoolReturn = true;
 647     DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION);
 648     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
 649     DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
 650
 651     // repeat with opposite return value
 652     handlers.mBoolReturn = false;
 653     handlers.mHandled    = false;
 654     DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION);
 655     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
 656     DALI_TEST_EQUALS(handlers.mFloatParam1, 6.0f, TEST_LOCATION);
 657   }
 658   signals.CheckNoConnections();
 659
 660   {
 661     TestSlotHandler handlers;
 662     signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
 663     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 664     handlers.mBoolReturn = true;
 665     DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION);
 666     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
 667     DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
 668     DALI_TEST_EQUALS(handlers.mIntParam2, 10, TEST_LOCATION);
 669   }
 670   signals.CheckNoConnections();
 671
 672   {
 673     TestSlotHandler handlers;
 674     signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
 675     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 676     handlers.mIntReturn = 27;
 677     int x               = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
 678     DALI_TEST_EQUALS(x, 27, TEST_LOCATION);
 679     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
 680     DALI_TEST_EQUALS(handlers.mFloatParam1, 33.5f, TEST_LOCATION);
 681     DALI_TEST_EQUALS(handlers.mIntParam2, 5, TEST_LOCATION);
 682   }
 683   signals.CheckNoConnections();
 684
 685   {
 686     TestSlotHandler handlers;
 687     signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
 688     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 689     handlers.mFloatReturn = 27.0f;
 690     float f               = signals.EmitFloat0Signal();
 691     DALI_TEST_EQUALS(f, 27.0f, TEST_LOCATION);
 692     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
 693     DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
 694     DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
 695   }
 696   signals.CheckNoConnections();
 697
 698   {
 699     TestSlotHandler handlers;
 700     signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
 701     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 702     handlers.mFloatReturn = 27.0f;
 703     float f               = signals.EmitFloat2VSignal(5, 33.0f);
 704     DALI_TEST_EQUALS(f, 27.0f, TEST_LOCATION);
 705     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
 706     DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
 707     DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
 708   }
 709   signals.CheckNoConnections();
 710
 711   {
 712     TestSlotHandler handlers;
 713     signals.VoidSignalFloatValue3().Connect(&handlers, &TestSlotHandler::VoidSlotFloatValue3);
 714     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 715     signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
 716     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
 717     DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
 718     DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
 719     DALI_TEST_EQUALS(handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION);
 720   }
 721   signals.CheckNoConnections();
 722
 723   {
 724     TestSlotHandler handlers;
 725     signals.SignalFloat3Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValue3);
 726     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 727     handlers.mFloatReturn = 27.0f;
 728     float returnValue     = signals.EmitFloat3VSignal(5, 33.0f, 100.0f);
 729     DALI_TEST_EQUALS(returnValue, 27.0f, TEST_LOCATION);
 730     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
 731     DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
 732     DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
 733     DALI_TEST_EQUALS(handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION);
 734   }
 735   signals.CheckNoConnections();
 736   END_TEST;
 737 }
 738
 739 int UtcDaliSignalConnectAndEmit02P(void)
 740 {
 741   // testing connection of static functions
 742   TestSignals            signals;
 743   StaticFunctionHandlers handlers;
 744
 745   // void ( void )
 746   signals.SignalVoidNone().Connect(&StaticFunctionHandlers::VoidSlotVoid);
 747   DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
 748   signals.EmitVoidSignalVoid();
 749   DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
 750
 751   // void ( p1 )
 752   handlers.Reset();
 753   signals.SignalVoid1Value().Connect(&StaticFunctionHandlers::VoidSlot1Param);
 754   DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
 755   signals.EmitVoidSignal1IntValue(1);
 756   DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
 757
 758   // void ( p1, p2 )
 759   handlers.Reset();
 760   signals.SignalVoid2Value().Connect(&StaticFunctionHandlers::VoidSlot2Param);
 761   DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
 762   signals.EmitVoidSignal2IntValue(1, 2);
 763   DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
 764
 765   // void ( p1, p2, p3 )
 766   handlers.Reset();
 767   signals.SignalVoid3Value().Connect(&StaticFunctionHandlers::VoidSlot3Param);
 768   DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
 769   signals.EmitVoidSignal3IntValue(1, 2, 3);
 770   DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
 771
 772   // ret ( )
 773   handlers.Reset();
 774   signals.SignalFloat0().Connect(&StaticFunctionHandlers::RetSlot0Param);
 775   DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
 776   signals.EmitFloat0Signal();
 777   DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
 778
 779   // ret ( p1 )
 780   handlers.Reset();
 781   signals.SignalFloat1Value().Connect(&StaticFunctionHandlers::RetSlot1Param);
 782   DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
 783   signals.EmitFloat1VSignal(1.f);
 784   DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
 785
 786   // ret ( p1, p2 )
 787   handlers.Reset();
 788   signals.SignalFloat2Value().Connect(&StaticFunctionHandlers::RetSlot2Param);
 789   DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
 790   signals.EmitFloat2VSignal(1.f, 2.f);
 791   DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
 792
 793   // ret ( p1, p2, p3 )
 794   handlers.Reset();
 795   signals.SignalFloat3Value().Connect(&StaticFunctionHandlers::RetSlot3Param);
 796   DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
 797   signals.EmitFloat3VSignal(1.f, 2.f, 3.f);
 798   DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
 799
 800   END_TEST;
 801 }
 802
 803 int UtcDaliSignalDisconnect(void)
 804 {
 805   // Test that callbacks don't occur if a signal is disconnected before emission
 806
 807   TestSignals signals;
 808
 809   {
 810     TestSlotHandler handlers;
 811     signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
 812     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 813     signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
 814     signals.EmitVoidSignalVoid();
 815     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 816   }
 817
 818   {
 819     TestSlotHandler handlers;
 820     signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
 821     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 822     int r               = 7;
 823     handlers.mIntReturn = 5;
 824     signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
 825     signals.EmitVoidSignalIntRef(r);
 826     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 827     DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
 828     DALI_TEST_EQUALS(r, 7, TEST_LOCATION);
 829   }
 830
 831   {
 832     TestSlotHandler handlers;
 833     signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
 834     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 835     signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
 836     signals.EmitVoidSignal1IntValue(5);
 837     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 838     DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
 839   }
 840
 841   {
 842     TestSlotHandler handlers;
 843     signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
 844     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 845     signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
 846     signals.EmitVoidSignal2IntValue(5, 10);
 847     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 848     DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
 849     DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
 850   }
 851
 852   {
 853     TestSlotHandler handlers;
 854     signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
 855     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 856     handlers.mBoolReturn = true;
 857     signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
 858     DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION);
 859     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 860     DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
 861   }
 862
 863   {
 864     TestSlotHandler handlers;
 865     signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
 866     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 867     handlers.mBoolReturn = true;
 868     signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
 869     DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION);
 870     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 871     DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
 872     DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
 873   }
 874
 875   {
 876     TestSlotHandler handlers;
 877     signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
 878     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 879     handlers.mIntReturn = 27;
 880     signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
 881     signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
 882     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 883     DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
 884     DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
 885   }
 886
 887   {
 888     TestSlotHandler handlers;
 889     signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
 890     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 891     handlers.mFloatReturn = 27.0f;
 892     signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
 893     signals.EmitFloat0Signal();
 894     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 895     DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
 896     DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
 897   }
 898
 899   {
 900     TestSlotHandler handlers;
 901     signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
 902     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 903     handlers.mFloatReturn = 27.0f;
 904     signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
 905     signals.EmitFloat2VSignal(5, 33.0f);
 906     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 907     DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
 908     DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
 909   }
 910   END_TEST;
 911 }
 912
 913 int UtcDaliSignalDisconnect2(void)
 914 {
 915   // Test that nothing happens when attempting to disconnect an unconnected slot
 916
 917   TestSignals signals;
 918   {
 919     TestSlotHandler handlers;
 920     signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
 921     signals.EmitVoidSignalVoid();
 922     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 923   }
 924
 925   {
 926     TestSlotHandler handlers;
 927     int             r = 7;
 928     signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
 929     signals.EmitVoidSignalIntRef(r);
 930     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 931     DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
 932     DALI_TEST_EQUALS(r, 7, TEST_LOCATION);
 933   }
 934
 935   {
 936     TestSlotHandler handlers;
 937     signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
 938     signals.EmitVoidSignal1IntValue(5);
 939     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 940     DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
 941   }
 942
 943   {
 944     TestSlotHandler handlers;
 945     signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
 946     signals.EmitVoidSignal2IntValue(5, 10);
 947     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 948     DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
 949     DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
 950   }
 951
 952   {
 953     TestSlotHandler handlers;
 954     handlers.mBoolReturn = true;
 955     signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
 956     DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION);
 957     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 958     DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
 959   }
 960
 961   {
 962     TestSlotHandler handlers;
 963     handlers.mBoolReturn = true;
 964     signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
 965     DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION);
 966     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 967     DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
 968     DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
 969   }
 970
 971   {
 972     TestSlotHandler handlers;
 973     handlers.mIntReturn = 27;
 974     signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
 975     signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
 976     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 977     DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
 978     DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
 979   }
 980
 981   {
 982     TestSlotHandler handlers;
 983     handlers.mFloatReturn = 27.0f;
 984     signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
 985     signals.EmitFloat2VSignal(5, 33.0f);
 986     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 987     DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
 988     DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
 989   }
 990
 991   {
 992     TestSlotHandler handlers;
 993     handlers.mFloatReturn = 27.0f;
 994     signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
 995     signals.EmitFloat0Signal();
 996     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
 997     DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
 998     DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
 999   }
1000   END_TEST;
1001 }
1002
1003 int UtcDaliSignalDisconnect3(void)
1004 {
1005   // Test that callbacks stop after a signal is disconnected
1006
1007   TestSignals signals;
1008
1009   {
1010     TestSlotHandler handlers;
1011     signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
1012     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1013
1014     // Emit first
1015     signals.EmitVoidSignalVoid();
1016     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1017
1018     // Disconnect and emit again
1019     handlers.mHandled = false;
1020     signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
1021     signals.EmitVoidSignalVoid();
1022     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1023   }
1024
1025   {
1026     TestSlotHandler handlers;
1027     signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1028     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1029     int r = 7;
1030
1031     // Emit first
1032     signals.EmitVoidSignalIntRef(r);
1033     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1034     DALI_TEST_EQUALS(handlers.mIntParam1, 7, TEST_LOCATION);
1035
1036     // Disconnect and emit again
1037     handlers.mHandled   = false;
1038     handlers.mIntParam1 = 0;
1039     signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1040     signals.EmitVoidSignalIntRef(r);
1041     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1042     DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
1043     DALI_TEST_EQUALS(r, 7, TEST_LOCATION);
1044   }
1045   END_TEST;
1046 }
1047
1048 int UtcDaliSignalCustomConnectionTracker(void)
1049 {
1050   // Test slot destruction
1051   {
1052     TestSignals::VoidRetNoParamSignal signal;
1053     {
1054       DALI_TEST_CHECK(signal.Empty());
1055       TestBasicConnectionTrackerInterface customTracker;
1056       signal.Connect(&customTracker, &TestBasicConnectionTrackerInterface::VoidSlotVoid);
1057       DALI_TEST_CHECK(!signal.Empty());
1058     }
1059     // End of slot lifetime
1060     DALI_TEST_CHECK(signal.Empty());
1061
1062     // Signal emission should be a NOOP
1063     signal.Emit();
1064   }
1065
1066   TestBasicConnectionTrackerInterface customTracker2;
1067
1068   // Test signal emission & destruction
1069   {
1070     TestSignals::VoidRetNoParamSignal signal;
1071     DALI_TEST_CHECK(signal.Empty());
1072     DALI_TEST_EQUALS(0u, customTracker2.GetConnectionCount(), TEST_LOCATION);
1073
1074     signal.Connect(&customTracker2, &TestBasicConnectionTrackerInterface::VoidSlotVoid);
1075     DALI_TEST_CHECK(!signal.Empty());
1076     DALI_TEST_EQUALS(1u, customTracker2.GetConnectionCount(), TEST_LOCATION);
1077
1078     DALI_TEST_EQUALS(customTracker2.mCallbackHandled, false, TEST_LOCATION);
1079     signal.Emit();
1080     DALI_TEST_EQUALS(customTracker2.mCallbackHandled, true, TEST_LOCATION);
1081   }
1082   DALI_TEST_EQUALS(0u, customTracker2.GetConnectionCount(), TEST_LOCATION);
1083
1084   // Test for removing a null callback
1085   {
1086     TestBasicConnectionTrackerInterface customTracker3;
1087
1088     TestSignals::VoidRetNoParamSignal signal;
1089     DALI_TEST_CHECK(signal.Empty());
1090     DALI_TEST_EQUALS(0u, customTracker3.GetConnectionCount(), TEST_LOCATION);
1091
1092     signal.Connect(&customTracker3, &TestBasicConnectionTrackerInterface::VoidSlotVoid);
1093     DALI_TEST_CHECK(!signal.Empty());
1094     DALI_TEST_EQUALS(1u, customTracker3.GetConnectionCount(), TEST_LOCATION);
1095     try
1096     {
1097       // should assert
1098       customTracker3.RemoveNullCallback();
1099       tet_result(TET_FAIL);
1100     }
1101     catch(Dali::DaliException& e)
1102     {
1103       tet_result(TET_PASS);
1104     }
1105   }
1106
1107   END_TEST;
1108 }
1109
1110 int UtcDaliSignalMultipleConnections(void)
1111 {
1112   // Test that multiple callbacks can be connected to the same signal
1113
1114   TestSignals signals;
1115
1116   {
1117     TestSlotHandler handler1;
1118     signals.SignalVoidNone().Connect(&handler1, &TestSlotHandler::VoidSlotVoid);
1119     DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
1120
1121     TestSlotHandler handler2;
1122     signals.SignalVoidNone().Connect(&handler2, &TestSlotHandler::VoidSlotVoid);
1123     DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
1124
1125     signals.EmitVoidSignalVoid();
1126     DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
1127     DALI_TEST_EQUALS(handler2.mHandled, true, TEST_LOCATION);
1128
1129     // Remove first connection and repeat
1130     handler1.Reset();
1131     handler2.Reset();
1132     signals.SignalVoidNone().Disconnect(&handler1, &TestSlotHandler::VoidSlotVoid);
1133
1134     signals.EmitVoidSignalVoid();
1135     DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
1136     DALI_TEST_EQUALS(handler2.mHandled, true, TEST_LOCATION);
1137   }
1138
1139   {
1140     TestSlotHandler handler1;
1141     signals.SignalVoid1Ref().Connect(&handler1, &TestSlotHandler::VoidSlotIntRef);
1142     DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
1143
1144     TestSlotHandler handler2;
1145     signals.SignalVoid1Ref().Connect(&handler2, &TestSlotHandler::VoidSlotIntRef);
1146     DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
1147
1148     int x = 7;
1149     signals.EmitVoidSignalIntRef(x);
1150     DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
1151     DALI_TEST_EQUALS(handler2.mHandled, true, TEST_LOCATION);
1152     DALI_TEST_EQUALS(handler1.mIntParam1, 7, TEST_LOCATION);
1153     DALI_TEST_EQUALS(handler2.mIntParam1, 7, TEST_LOCATION);
1154
1155     // Remove second connection and repeat
1156     handler1.Reset();
1157     handler2.Reset();
1158     x = 8;
1159     signals.SignalVoid1Ref().Disconnect(&handler2, &TestSlotHandler::VoidSlotIntRef);
1160
1161     signals.EmitVoidSignalIntRef(x);
1162     DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
1163     DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
1164     DALI_TEST_EQUALS(handler1.mIntParam1, 8, TEST_LOCATION);
1165     DALI_TEST_EQUALS(handler2.mIntParam1, 0, TEST_LOCATION);
1166   }
1167
1168   {
1169     TestSlotHandler handler1;
1170     signals.SignalVoid1Value().Connect(&handler1, &TestSlotHandler::VoidSlotIntValue);
1171     DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
1172
1173     TestSlotHandler handler2;
1174     signals.SignalVoid1Value().Connect(&handler2, &TestSlotHandler::VoidSlotIntValue);
1175     DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
1176
1177     TestSlotHandler handler3;
1178     signals.SignalVoid1Value().Connect(&handler3, &TestSlotHandler::VoidSlotIntValue);
1179     DALI_TEST_EQUALS(handler3.mHandled, false, TEST_LOCATION);
1180
1181     signals.EmitVoidSignal1IntValue(5);
1182     DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
1183     DALI_TEST_EQUALS(handler1.mIntParam1, 5, TEST_LOCATION);
1184     DALI_TEST_EQUALS(handler2.mHandled, true, TEST_LOCATION);
1185     DALI_TEST_EQUALS(handler2.mIntParam1, 5, TEST_LOCATION);
1186     DALI_TEST_EQUALS(handler3.mHandled, true, TEST_LOCATION);
1187     DALI_TEST_EQUALS(handler3.mIntParam1, 5, TEST_LOCATION);
1188
1189     // Remove middle connection and repeat
1190     handler1.Reset();
1191     handler2.Reset();
1192     handler3.Reset();
1193     signals.SignalVoid1Value().Disconnect(&handler2, &TestSlotHandler::VoidSlotIntValue);
1194
1195     signals.EmitVoidSignal1IntValue(6);
1196     DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
1197     DALI_TEST_EQUALS(handler1.mIntParam1, 6, TEST_LOCATION);
1198     DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
1199     DALI_TEST_EQUALS(handler2.mIntParam1, 0, TEST_LOCATION);
1200     DALI_TEST_EQUALS(handler3.mHandled, true, TEST_LOCATION);
1201     DALI_TEST_EQUALS(handler3.mIntParam1, 6, TEST_LOCATION);
1202   }
1203
1204   // Test that multiple callbacks are disconnected when a signal is destroyed
1205
1206   TestSlotHandler handler4;
1207   TestSlotHandler handler5;
1208   TestSlotHandler handler6;
1209
1210   {
1211     TestSignals::VoidRet1ValueParamSignal tempSignal;
1212
1213     DALI_TEST_EQUALS(handler4.GetConnectionCount(), 0u, TEST_LOCATION);
1214     DALI_TEST_EQUALS(handler5.GetConnectionCount(), 0u, TEST_LOCATION);
1215     DALI_TEST_EQUALS(handler6.GetConnectionCount(), 0u, TEST_LOCATION);
1216
1217     tempSignal.Connect(&handler4, &TestSlotHandler::VoidSlotIntValue);
1218     tempSignal.Connect(&handler5, &TestSlotHandler::VoidSlotIntValue);
1219     tempSignal.Connect(&handler6, &TestSlotHandler::VoidSlotIntValue);
1220
1221     DALI_TEST_EQUALS(handler4.GetConnectionCount(), 1u, TEST_LOCATION);
1222     DALI_TEST_EQUALS(handler5.GetConnectionCount(), 1u, TEST_LOCATION);
1223     DALI_TEST_EQUALS(handler6.GetConnectionCount(), 1u, TEST_LOCATION);
1224   }
1225   // End of tempSignal lifetime
1226
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);
1230   END_TEST;
1231 }
1232
1233 int UtcDaliSignalMultipleConnections2(void)
1234 {
1235   TestSignals signals;
1236
1237   // Test that connecting the same callback twice is a NOOP
1238   {
1239     TestSlotHandler handler1;
1240
1241     // Note the double connection is intentional
1242     signals.SignalVoid1Value().Connect(&handler1, &TestSlotHandler::VoidSlotIntValue);
1243     signals.SignalVoid1Value().Connect(&handler1, &TestSlotHandler::VoidSlotIntValue);
1244     DALI_TEST_EQUALS(handler1.mHandledCount, 0, TEST_LOCATION);
1245
1246     signals.EmitVoidSignal1IntValue(6);
1247     DALI_TEST_EQUALS(handler1.mHandledCount, 1, TEST_LOCATION);
1248     DALI_TEST_EQUALS(handler1.mIntParam1, 6, TEST_LOCATION);
1249
1250     // Calling Disconnect once should be enough
1251     signals.SignalVoid1Value().Disconnect(&handler1, &TestSlotHandler::VoidSlotIntValue);
1252     DALI_TEST_CHECK(signals.SignalVoid1Value().Empty());
1253     handler1.mIntParam1 = 0;
1254
1255     signals.EmitVoidSignal1IntValue(7);
1256     DALI_TEST_EQUALS(handler1.mHandledCount, 1 /*not incremented since last check*/, TEST_LOCATION);
1257     DALI_TEST_EQUALS(handler1.mIntParam1, 0, TEST_LOCATION);
1258   }
1259
1260   // Test automatic disconnect after multiple Connect() calls
1261   {
1262     TestSlotHandler handler2;
1263     signals.SignalVoid1Value().Connect(&handler2, &TestSlotHandler::VoidSlotIntValue);
1264     signals.SignalVoid1Value().Connect(&handler2, &TestSlotHandler::VoidSlotIntValue);
1265
1266     TestSlotHandler handler3;
1267     signals.SignalBool1Value().Connect(&handler3, &TestSlotHandler::BoolSlotFloatValue);
1268     signals.SignalBool1Value().Connect(&handler3, &TestSlotHandler::BoolSlotFloatValue);
1269
1270     DALI_TEST_EQUALS(handler2.mHandledCount, 0, TEST_LOCATION);
1271     DALI_TEST_EQUALS(handler3.mHandledCount, 0, TEST_LOCATION);
1272     DALI_TEST_CHECK(!signals.SignalVoid1Value().Empty());
1273     DALI_TEST_CHECK(!signals.SignalBool1Value().Empty());
1274   }
1275   DALI_TEST_CHECK(signals.SignalVoid1Value().Empty());
1276   DALI_TEST_CHECK(signals.SignalBool1Value().Empty());
1277
1278   // Should be NOOP
1279   signals.EmitVoidSignal1IntValue(1);
1280   signals.EmitBoolSignalFloatValue(1.0f);
1281
1282   // Test that connecting the same callback 10 times is a NOOP
1283   TestSlotHandler handler4;
1284   DALI_TEST_EQUALS(handler4.mHandledCount, 0, TEST_LOCATION);
1285   DALI_TEST_EQUALS(handler4.mFloatParam1, 0.0f, TEST_LOCATION);
1286
1287   signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1288   signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1289   signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1290   signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1291   signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1292   signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1293   signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1294   signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1295   signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1296   signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1297
1298   signals.EmitBoolSignalFloatValue(2.0f);
1299   DALI_TEST_EQUALS(handler4.mHandledCount, 1, TEST_LOCATION);
1300   DALI_TEST_EQUALS(handler4.mFloatParam1, 2.0f, TEST_LOCATION);
1301
1302   // Calling Disconnect once should be enough
1303   signals.SignalBool1Value().Disconnect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
1304   DALI_TEST_CHECK(signals.SignalBool1Value().Empty());
1305
1306   signals.EmitBoolSignalFloatValue(3.0f);
1307   DALI_TEST_EQUALS(handler4.mHandledCount, 1 /*not incremented since last check*/, TEST_LOCATION);
1308   DALI_TEST_EQUALS(handler4.mFloatParam1, 2.0f, TEST_LOCATION);
1309   END_TEST;
1310 }
1311
1312 int UtcDaliSignalMultipleConnections3(void)
1313 {
1314   TestSignals signals;
1315
1316   // Test connecting two difference callbacks for the same ConnectionTracker
1317
1318   TestSlotHandler handler1;
1319
1320   {
1321     TestSignals::VoidRet1ValueParamSignal tempSignal;
1322
1323     DALI_TEST_EQUALS(handler1.GetConnectionCount(), 0u, TEST_LOCATION);
1324     DALI_TEST_EQUALS(handler1.mHandledCount, 0, TEST_LOCATION);
1325     DALI_TEST_EQUALS(handler1.mIntParam1, 0, TEST_LOCATION);
1326
1327     // Note that the duplicate connection is deliberate
1328     tempSignal.Connect(&handler1, &TestSlotHandler::VoidSlotIntValue);
1329     tempSignal.Connect(&handler1, &TestSlotHandler::VoidDuplicateSlotIntValue);
1330
1331     DALI_TEST_EQUALS(handler1.GetConnectionCount(), 2u, TEST_LOCATION);
1332     DALI_TEST_EQUALS(handler1.mHandledCount, 0, TEST_LOCATION);
1333
1334     tempSignal.Emit(10);
1335
1336     DALI_TEST_EQUALS(handler1.mHandledCount, 2, TEST_LOCATION);
1337     DALI_TEST_EQUALS(handler1.mIntParam1, 10, TEST_LOCATION);
1338     DALI_TEST_EQUALS(handler1.mIntParam2, 10, TEST_LOCATION);
1339   }
1340   // End of tempSignal lifetime
1341
1342   DALI_TEST_EQUALS(handler1.GetConnectionCount(), 0u, TEST_LOCATION);
1343   END_TEST;
1344 }
1345
1346 int UtcDaliSignalDisconnectStatic(void)
1347 {
1348   // void Func()
1349
1350   {
1351     TestSignals::VoidRetNoParamSignal signal;
1352     DALI_TEST_CHECK(signal.Empty());
1353
1354     signal.Connect(StaticVoidCallbackVoid);
1355     DALI_TEST_CHECK(!signal.Empty());
1356
1357     wasStaticVoidCallbackVoidCalled = false;
1358     signal.Emit();
1359     DALI_TEST_EQUALS(wasStaticVoidCallbackVoidCalled, true, TEST_LOCATION);
1360
1361     signal.Disconnect(StaticVoidCallbackVoid);
1362     DALI_TEST_CHECK(signal.Empty());
1363
1364     wasStaticVoidCallbackVoidCalled = false;
1365     signal.Emit();
1366     DALI_TEST_EQUALS(wasStaticVoidCallbackVoidCalled, false, TEST_LOCATION);
1367   }
1368
1369   // float Func()
1370
1371   {
1372     TestSignals::FloatRet0ParamSignal signal;
1373     DALI_TEST_CHECK(signal.Empty());
1374
1375     signal.Connect(StaticFloatCallbackVoid);
1376     DALI_TEST_CHECK(!signal.Empty());
1377
1378     wasStaticFloatCallbackVoidCalled = false;
1379     float result                     = signal.Emit();
1380     DALI_TEST_EQUALS(wasStaticFloatCallbackVoidCalled, true, TEST_LOCATION);
1381     DALI_TEST_EQUALS(result, 7.0f, TEST_LOCATION);
1382
1383     signal.Disconnect(StaticFloatCallbackVoid);
1384     DALI_TEST_CHECK(signal.Empty());
1385
1386     wasStaticFloatCallbackVoidCalled = false;
1387     result                           = signal.Emit();
1388     DALI_TEST_EQUALS(wasStaticFloatCallbackVoidCalled, false, TEST_LOCATION);
1389     DALI_TEST_EQUALS(result, 0.0f, TEST_LOCATION);
1390   }
1391
1392   // void Func( int )
1393
1394   {
1395     TestSignals::VoidRet1ValueParamSignal signal;
1396     DALI_TEST_CHECK(signal.Empty());
1397
1398     signal.Connect(StaticVoidCallbackIntValue);
1399     DALI_TEST_CHECK(!signal.Empty());
1400
1401     wasStaticVoidCallbackIntValueCalled = false;
1402     staticIntValue                      = 0;
1403     signal.Emit(10);
1404     DALI_TEST_EQUALS(wasStaticVoidCallbackIntValueCalled, true, TEST_LOCATION);
1405     DALI_TEST_EQUALS(staticIntValue, 10, TEST_LOCATION);
1406
1407     signal.Disconnect(StaticVoidCallbackIntValue);
1408     DALI_TEST_CHECK(signal.Empty());
1409
1410     wasStaticVoidCallbackIntValueCalled = false;
1411     staticIntValue                      = 0;
1412     signal.Emit(11);
1413     DALI_TEST_EQUALS(wasStaticVoidCallbackIntValueCalled, false, TEST_LOCATION);
1414     DALI_TEST_EQUALS(staticIntValue, 0, TEST_LOCATION);
1415   }
1416
1417   // float Func( float, float )
1418
1419   {
1420     TestSignals::FloatRet2ValueParamSignal signal;
1421     DALI_TEST_CHECK(signal.Empty());
1422
1423     signal.Connect(StaticFloatCallbackFloatValueFloatValue);
1424     DALI_TEST_CHECK(!signal.Empty());
1425
1426     wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1427     staticFloatValue1                                = 0.0f;
1428     staticFloatValue2                                = 0.0f;
1429     float result                                     = signal.Emit(5.0f, 6.0f);
1430     DALI_TEST_EQUALS(wasStaticFloatCallbackFloatValueFloatValueCalled, true, TEST_LOCATION);
1431     DALI_TEST_EQUALS(staticFloatValue1, 5.0f, TEST_LOCATION);
1432     DALI_TEST_EQUALS(staticFloatValue2, 6.0f, TEST_LOCATION);
1433     DALI_TEST_EQUALS(result, 5.0f + 6.0f, TEST_LOCATION);
1434
1435     signal.Disconnect(StaticFloatCallbackFloatValueFloatValue);
1436     DALI_TEST_CHECK(signal.Empty());
1437
1438     wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1439     staticFloatValue1                                = 0.0f;
1440     staticFloatValue2                                = 0.0f;
1441     result                                           = signal.Emit(7.0f, 8.0f);
1442     DALI_TEST_EQUALS(wasStaticFloatCallbackFloatValueFloatValueCalled, false, TEST_LOCATION);
1443     DALI_TEST_EQUALS(staticFloatValue1, 0.0f, TEST_LOCATION);
1444     DALI_TEST_EQUALS(staticFloatValue2, 0.0f, TEST_LOCATION);
1445     DALI_TEST_EQUALS(result, 0.0f, TEST_LOCATION);
1446   }
1447   END_TEST;
1448 }
1449
1450 int UtcDaliSignalDisconnectDuringCallback(void)
1451 {
1452   // Test disconnection during each callback
1453
1454   TestSignals::VoidRetNoParamSignal signal;
1455   DALI_TEST_CHECK(signal.Empty());
1456
1457   TestSlotDisconnector handler1;
1458   handler1.VoidConnectVoid(signal);
1459   DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
1460   DALI_TEST_CHECK(!signal.Empty());
1461
1462   signal.Emit();
1463   DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
1464   DALI_TEST_CHECK(signal.Empty());
1465
1466   // Repeat with 2 callbacks
1467
1468   handler1.mHandled = false;
1469
1470   TestSlotDisconnector handler2;
1471   handler1.VoidConnectVoid(signal);
1472   handler2.VoidConnectVoid(signal);
1473   DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
1474   DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
1475   DALI_TEST_CHECK(!signal.Empty());
1476
1477   signal.Emit();
1478   DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
1479   DALI_TEST_EQUALS(handler2.mHandled, true, TEST_LOCATION);
1480   DALI_TEST_CHECK(signal.Empty());
1481
1482   // Repeat with no callbacks
1483
1484   handler1.mHandled = false;
1485   handler2.mHandled = false;
1486
1487   signal.Emit();
1488   DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
1489   DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
1490
1491   // Repeat with 3 callbacks
1492
1493   TestSlotDisconnector handler3;
1494   handler1.VoidConnectVoid(signal);
1495   handler2.VoidConnectVoid(signal);
1496   handler3.VoidConnectVoid(signal);
1497   DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
1498   DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
1499   DALI_TEST_EQUALS(handler3.mHandled, false, TEST_LOCATION);
1500   DALI_TEST_CHECK(!signal.Empty());
1501
1502   signal.Emit();
1503   DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
1504   DALI_TEST_EQUALS(handler2.mHandled, true, TEST_LOCATION);
1505   DALI_TEST_EQUALS(handler3.mHandled, true, TEST_LOCATION);
1506   DALI_TEST_CHECK(signal.Empty());
1507
1508   // Repeat with no callbacks
1509
1510   handler1.mHandled = false;
1511   handler2.mHandled = false;
1512   handler3.mHandled = false;
1513
1514   signal.Emit();
1515   DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
1516   DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
1517   DALI_TEST_EQUALS(handler3.mHandled, false, TEST_LOCATION);
1518   END_TEST;
1519 }
1520
1521 int UtcDaliSignalDisconnectDuringCallback2(void)
1522 {
1523   // Test disconnection of some (but not all) callbacks during sigmal emission
1524
1525   TestSignals::VoidRetNoParamSignal signal;
1526   DALI_TEST_CHECK(signal.Empty());
1527
1528   TestSlotMultiDisconnector handler;
1529   handler.ConnectAll(signal);
1530   DALI_TEST_EQUALS(handler.mSlotHandled[0], false, TEST_LOCATION);
1531   DALI_TEST_EQUALS(handler.mSlotHandled[1], false, TEST_LOCATION);
1532   DALI_TEST_EQUALS(handler.mSlotHandled[2], false, TEST_LOCATION);
1533   DALI_TEST_EQUALS(handler.mSlotHandled[3], false, TEST_LOCATION);
1534   DALI_TEST_EQUALS(handler.mSlotHandled[4], false, TEST_LOCATION);
1535   DALI_TEST_EQUALS(handler.mSlotHandled[5], false, TEST_LOCATION);
1536   DALI_TEST_EQUALS(handler.mSlotHandled[6], false, TEST_LOCATION);
1537   DALI_TEST_EQUALS(handler.mSlotHandled[7], false, TEST_LOCATION);
1538   DALI_TEST_EQUALS(handler.mSlotHandled[8], false, TEST_LOCATION);
1539   DALI_TEST_EQUALS(handler.mSlotHandled[9], false, TEST_LOCATION);
1540   DALI_TEST_CHECK(!signal.Empty());
1541
1542   signal.Emit();
1543
1544   // Slots 5, 7, & 9 should be disconnected before being called
1545   DALI_TEST_EQUALS(handler.mSlotHandled[0], true, TEST_LOCATION);
1546   DALI_TEST_EQUALS(handler.mSlotHandled[1], true, TEST_LOCATION);
1547   DALI_TEST_EQUALS(handler.mSlotHandled[2], true, TEST_LOCATION);
1548   DALI_TEST_EQUALS(handler.mSlotHandled[3], true, TEST_LOCATION);
1549   DALI_TEST_EQUALS(handler.mSlotHandled[4], true, TEST_LOCATION);
1550   DALI_TEST_EQUALS(handler.mSlotHandled[5], false, TEST_LOCATION);
1551   DALI_TEST_EQUALS(handler.mSlotHandled[6], true, TEST_LOCATION);
1552   DALI_TEST_EQUALS(handler.mSlotHandled[7], false, TEST_LOCATION);
1553   DALI_TEST_EQUALS(handler.mSlotHandled[8], true, TEST_LOCATION);
1554   DALI_TEST_EQUALS(handler.mSlotHandled[9], false, TEST_LOCATION);
1555   DALI_TEST_CHECK(!signal.Empty());
1556
1557   // Odd slots are disconnected
1558   DALI_TEST_EQUALS(handler.GetConnectionCount(), 5u, TEST_LOCATION);
1559   END_TEST;
1560 }
1561
1562 int UtcDaliSignalEmitDuringCallback(void)
1563 {
1564   TestApplication application; // Create core for debug logging
1565
1566   // for coverage purposes we test the emit guard for each signal type (0,1,2,3 params) void / return value
1567   {
1568     TestSignals::VoidRetNoParamSignal signal;
1569     DALI_TEST_CHECK(signal.Empty());
1570
1571     TestEmitDuringCallback handler1;
1572     handler1.VoidConnectVoid(signal);
1573
1574     // Test that this does not result in an infinite loop!
1575     signal.Emit();
1576   }
1577   {
1578     TestSignals::FloatRet0ParamSignal signal;
1579
1580     DALI_TEST_CHECK(signal.Empty());
1581
1582     TestEmitDuringCallback handler1;
1583     handler1.FloatRet0ParamConnect(signal);
1584
1585     // Test that this does not result in an infinite loop!
1586     signal.Emit();
1587   }
1588   {
1589     TestSignals::FloatRet1ParamSignal signal;
1590
1591     DALI_TEST_CHECK(signal.Empty());
1592
1593     TestEmitDuringCallback handler1;
1594     handler1.FloatRet1ParamConnect(signal);
1595
1596     // Test that this does not result in an infinite loop!
1597     signal.Emit(1.f);
1598   }
1599   {
1600     TestSignals::FloatRet2ValueParamSignal signal;
1601
1602     DALI_TEST_CHECK(signal.Empty());
1603
1604     TestEmitDuringCallback handler1;
1605     handler1.FloatRet2ParamConnect(signal);
1606
1607     // Test that this does not result in an infinite loop!
1608     signal.Emit(1.f, 1.f);
1609   }
1610   {
1611     TestSignals::FloatRet3ValueParamSignal signal;
1612
1613     DALI_TEST_CHECK(signal.Empty());
1614
1615     TestEmitDuringCallback handler1;
1616     handler1.FloatRet3ParamConnect(signal);
1617
1618     // Test that this does not result in an infinite loop!
1619     signal.Emit(1.f, 1.f, 1.f);
1620   }
1621   END_TEST;
1622 }
1623
1624 int UtcDaliSignalDeleteDuringEmit(void)
1625 {
1626   // testing a signal deletion during an emit
1627   // need to dynamically allocate the signal for this to work
1628
1629   TestApplication application; // Create core for debug logging
1630
1631   TestSignals::VoidRetNoParamSignal* signal = new TestSignals::VoidRetNoParamSignal;
1632
1633   TestEmitDuringCallback handler1;
1634   handler1.DeleteDuringEmitConnect(*signal);
1635
1636   // should just log an error
1637   signal->Emit();
1638
1639   tet_result(TET_PASS);
1640
1641   END_TEST;
1642 }
1643
1644 int UtcDaliSignalTestApp01(void)
1645 {
1646   // Test 1 signal connected to 1 Slot.
1647   // Signal dies first.
1648
1649   TestButton* button = new TestButton(1);
1650   TestApp     app;
1651   button->DownSignal().Connect(&app, &TestApp::OnButtonPress);
1652
1653   // check we have both the button, and the app have 1 connection
1654   DALI_TEST_EQUALS(app.GetConnectionCount(), 1u, TEST_LOCATION);
1655   DALI_TEST_EQUALS(button->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
1656
1657   delete button; // should automatically destroy the connection
1658
1659   // check we have a 0 connections
1660   DALI_TEST_EQUALS(app.GetConnectionCount(), 0u, TEST_LOCATION);
1661
1662   END_TEST;
1663 }
1664
1665 int UtcDaliSignalTestApp02(void)
1666 {
1667   // Test 1 signal connected to 1 Slot.
1668   // Slot owning object dies first.
1669
1670   TestButton button(1);
1671   TestApp*   app = new TestApp;
1672   button.DownSignal().Connect(app, &TestApp::OnButtonPress);
1673
1674   // check we have a 1 connection
1675   DALI_TEST_EQUALS(app->GetConnectionCount(), 1u, TEST_LOCATION);
1676   DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
1677
1678   delete app; // should automatically destroy the connection
1679
1680   // check we have a 0 connections
1681   DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION);
1682   END_TEST;
1683 }
1684
1685 int UtcDaliSignalTestApp03(void)
1686 {
1687   // Test 1 Signal connect to 2 slots
1688   // 1 of the slot owners dies. Then the second slot owner dies
1689
1690   TestButton button(1);
1691   TestApp*   app1 = new TestApp;
1692   TestApp*   app2 = new TestApp;
1693
1694   button.DownSignal().Connect(app1, &TestApp::OnButtonPress);
1695   button.DownSignal().Connect(app2, &TestApp::OnButtonPress);
1696
1697   // check we have a 2 connections to the signal
1698   DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 2u, TEST_LOCATION);
1699
1700   // kill the first slot
1701   delete app1; // should automatically destroy the connection
1702
1703   // check we have 1 connection left
1704   DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
1705
1706   button.Press(); // emit the signal (to ensure it doesn't seg fault)
1707
1708   // kill the second slot
1709   delete app2; // should automatically destroy the connection
1710
1711   // check we have 1 connection left
1712   DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION);
1713
1714   END_TEST;
1715 }
1716
1717 int UtcDaliSignalTestApp04(void)
1718 {
1719   // Test 1 Signal connected to 2 slots (with different owners)
1720   // The Signal dies, check the 2 slots disconnect automatically
1721
1722   TestButton* button = new TestButton(1);
1723   TestApp     app1;
1724   TestApp     app2;
1725
1726   button->DownSignal().Connect(&app1, &TestApp::OnButtonPress);
1727   button->DownSignal().Connect(&app2, &TestApp::OnButtonPress);
1728
1729   // check the connection counts
1730   DALI_TEST_EQUALS(app1.GetConnectionCount(), 1u, TEST_LOCATION);
1731   DALI_TEST_EQUALS(app2.GetConnectionCount(), 1u, TEST_LOCATION);
1732   DALI_TEST_EQUALS(button->DownSignal().GetConnectionCount(), 2u, TEST_LOCATION);
1733
1734   delete button; // should automatically destroy the connection
1735
1736   // check both slot owners have zero connections
1737   DALI_TEST_EQUALS(app1.GetConnectionCount(), 0u, TEST_LOCATION);
1738   DALI_TEST_EQUALS(app2.GetConnectionCount(), 0u, TEST_LOCATION);
1739   END_TEST;
1740 }
1741
1742 int UtcDaliSignalTestApp05(void)
1743 {
1744   // Test 2 Signals (with different owners)  connected to 1 slots
1745   // 1 Signal dies, check that the remaining connection is valid
1746
1747   TestButton* button1 = new TestButton(1); // use for signal 1
1748   TestButton* button2 = new TestButton(2); // use for signal 2
1749
1750   TestApp app;
1751
1752   button1->DownSignal().Connect(&app, &TestApp::OnButtonPress);
1753   button2->DownSignal().Connect(&app, &TestApp::OnButtonPress);
1754
1755   // check the connection counts
1756   DALI_TEST_EQUALS(app.GetConnectionCount(), 2u, TEST_LOCATION);
1757   DALI_TEST_EQUALS(button1->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
1758   DALI_TEST_EQUALS(button2->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
1759
1760   // make sure both signals emit ok
1761   button2->Press();
1762   DALI_TEST_EQUALS(app.GetButtonPressedId(), 2, TEST_LOCATION);
1763
1764   button1->Press();
1765   DALI_TEST_EQUALS(app.GetButtonPressedId(), 1, TEST_LOCATION);
1766
1767   delete button1; // should automatically destroy 1 connection
1768
1769   // check both slot owners have zero connections
1770   DALI_TEST_EQUALS(app.GetConnectionCount(), 1u, TEST_LOCATION);
1771
1772   // check remaining connection still works
1773   button2->Press();
1774   DALI_TEST_EQUALS(app.GetButtonPressedId(), 2, TEST_LOCATION);
1775
1776   // kill the last signal
1777   delete button2;
1778   DALI_TEST_EQUALS(app.GetConnectionCount(), 0u, TEST_LOCATION);
1779   END_TEST;
1780 }
1781
1782 int UtcDaliSignalTestApp06(void)
1783 {
1784   Signal<bool()> boolSignal;
1785   TestApp        app;
1786   bool           result(false);
1787
1788   // connect a slot which will return false
1789   boolSignal.Connect(&app, &TestApp::BoolReturnTestFalse);
1790   result = boolSignal.Emit();
1791   DALI_TEST_EQUALS(result, false, TEST_LOCATION);
1792
1793   // disconnect last slot, and connect a slot which returns true
1794   boolSignal.Disconnect(&app, &TestApp::BoolReturnTestFalse);
1795   boolSignal.Connect(&app, &TestApp::BoolReturnTestTrue);
1796   result = boolSignal.Emit();
1797   DALI_TEST_EQUALS(result, true, TEST_LOCATION);
1798   END_TEST;
1799 }
1800
1801 int UtcDaliSlotDelegateConnection(void)
1802 {
1803   TestSignals signals;
1804
1805   {
1806     TestSlotDelegateHandler handlers;
1807     signals.SignalVoidNone().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
1808     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1809     signals.EmitVoidSignalVoid();
1810     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1811
1812     // Test double emission
1813     handlers.mHandled = false;
1814     signals.EmitVoidSignalVoid();
1815     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1816   }
1817   signals.CheckNoConnections();
1818
1819   {
1820     TestSlotDelegateHandler handlers;
1821     signals.SignalVoid1Ref().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
1822     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1823     int x = 7;
1824     signals.EmitVoidSignalIntRef(x);
1825     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1826     DALI_TEST_EQUALS(handlers.mIntParam1, 7, TEST_LOCATION);
1827   }
1828   signals.CheckNoConnections();
1829
1830   {
1831     TestSlotDelegateHandler handlers;
1832     signals.SignalVoid1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
1833     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1834     signals.EmitVoidSignal1IntValue(5);
1835     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1836     DALI_TEST_EQUALS(handlers.mIntParam1, 5, TEST_LOCATION);
1837   }
1838   signals.CheckNoConnections();
1839
1840   {
1841     TestSlotDelegateHandler handlers;
1842     signals.SignalVoid2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
1843     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1844     signals.EmitVoidSignal2IntValue(6, 7);
1845     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1846     DALI_TEST_EQUALS(handlers.mIntParam1, 6, TEST_LOCATION);
1847     DALI_TEST_EQUALS(handlers.mIntParam2, 7, TEST_LOCATION);
1848   }
1849   signals.CheckNoConnections();
1850
1851   {
1852     TestSlotDelegateHandler handlers;
1853     signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
1854     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1855
1856     handlers.mBoolReturn = true;
1857     DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION);
1858     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1859     DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
1860
1861     // repeat with opposite return value
1862     handlers.mBoolReturn = false;
1863     handlers.mHandled    = false;
1864     DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION);
1865     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1866     DALI_TEST_EQUALS(handlers.mFloatParam1, 6.0f, TEST_LOCATION);
1867   }
1868   signals.CheckNoConnections();
1869
1870   {
1871     TestSlotDelegateHandler handlers;
1872     signals.SignalBool2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
1873     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1874     handlers.mBoolReturn = true;
1875     DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION);
1876     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1877     DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
1878     DALI_TEST_EQUALS(handlers.mIntParam2, 10, TEST_LOCATION);
1879   }
1880   signals.CheckNoConnections();
1881
1882   {
1883     TestSlotDelegateHandler handlers;
1884     signals.SignalInt2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
1885     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1886     handlers.mIntReturn = 27;
1887     int x               = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
1888     DALI_TEST_EQUALS(x, 27, TEST_LOCATION);
1889     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1890     DALI_TEST_EQUALS(handlers.mFloatParam1, 33.5f, TEST_LOCATION);
1891     DALI_TEST_EQUALS(handlers.mIntParam2, 5, TEST_LOCATION);
1892   }
1893   signals.CheckNoConnections();
1894
1895   {
1896     TestSlotDelegateHandler handlers;
1897     signals.SignalFloat0().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
1898     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1899     handlers.mFloatReturn = 27.0f;
1900     float f               = signals.EmitFloat0Signal();
1901     DALI_TEST_EQUALS(f, 27.0f, TEST_LOCATION);
1902     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1903     DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
1904     DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
1905   }
1906   signals.CheckNoConnections();
1907
1908   {
1909     TestSlotDelegateHandler handlers;
1910     signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
1911     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1912     handlers.mFloatReturn = 27.0f;
1913     float f               = signals.EmitFloat2VSignal(5, 33.0f);
1914     DALI_TEST_EQUALS(f, 27.0f, TEST_LOCATION);
1915     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1916     DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
1917     DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
1918   }
1919   signals.CheckNoConnections();
1920
1921   {
1922     TestSlotDelegateHandler handlers;
1923     signals.VoidSignalFloatValue3().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotFloatValue3);
1924     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1925     signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
1926     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1927     DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
1928     DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
1929     DALI_TEST_EQUALS(handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION);
1930   }
1931   signals.CheckNoConnections();
1932
1933   {
1934     TestSlotDelegateHandler handlers;
1935     signals.SignalFloat3Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValue3);
1936     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
1937     handlers.mFloatReturn = 27.0f;
1938     float returnValue     = signals.EmitFloat3VSignal(5, 33.0f, 100.0f);
1939     DALI_TEST_EQUALS(returnValue, 27.0f, TEST_LOCATION);
1940     DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
1941     DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
1942     DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
1943     DALI_TEST_EQUALS(handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION);
1944   }
1945   signals.CheckNoConnections();
1946   END_TEST;
1947 }
1948
1949 int UtcDaliSignalSlotDelegateDestruction(void)
1950 {
1951   // Test that signal disconnect works when slot-delegate is destroyed (goes out of scope)
1952
1953   {
1954     TestSignals::VoidRetNoParamSignal signal;
1955     {
1956       DALI_TEST_CHECK(signal.Empty());
1957       TestSlotDelegateHandler handler;
1958       signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
1959       DALI_TEST_CHECK(!signal.Empty());
1960     }
1961     // End of slot lifetime
1962     DALI_TEST_CHECK(signal.Empty());
1963
1964     // Signal emission should be a NOOP
1965     signal.Emit();
1966   }
1967
1968   {
1969     TestSignals::VoidRet1ValueParamSignal signal;
1970     {
1971       DALI_TEST_CHECK(signal.Empty());
1972       TestSlotDelegateHandler handler;
1973       signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
1974       DALI_TEST_CHECK(!signal.Empty());
1975     }
1976     // End of slot lifetime
1977     DALI_TEST_CHECK(signal.Empty());
1978
1979     // Signal emission should be a NOOP
1980     signal.Emit(10);
1981   }
1982
1983   {
1984     TestSignals::VoidRet1RefParamSignal signal;
1985     {
1986       DALI_TEST_CHECK(signal.Empty());
1987       TestSlotDelegateHandler handler;
1988       signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
1989       DALI_TEST_CHECK(!signal.Empty());
1990     }
1991     // End of slot lifetime
1992     DALI_TEST_CHECK(signal.Empty());
1993
1994     // Signal emission should be a NOOP
1995     int temp(5);
1996     signal.Emit(temp);
1997   }
1998
1999   {
2000     TestSignals::VoidRet2ValueParamSignal signal;
2001     {
2002       DALI_TEST_CHECK(signal.Empty());
2003       TestSlotDelegateHandler handler;
2004       signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
2005       DALI_TEST_CHECK(!signal.Empty());
2006     }
2007     // End of slot lifetime
2008     DALI_TEST_CHECK(signal.Empty());
2009
2010     // Signal emission should be a NOOP
2011     signal.Emit(1, 2);
2012   }
2013
2014   {
2015     TestSignals::BoolRet1ValueParamSignal signal;
2016     {
2017       DALI_TEST_CHECK(signal.Empty());
2018       TestSlotDelegateHandler handler;
2019       signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2020       DALI_TEST_CHECK(!signal.Empty());
2021     }
2022     // End of slot lifetime
2023     DALI_TEST_CHECK(signal.Empty());
2024
2025     // Signal emission should be a NOOP
2026     bool blah = signal.Emit(1.0f);
2027     DALI_TEST_CHECK(!blah);
2028   }
2029
2030   {
2031     TestSignals::BoolRet2ValueParamSignal signal;
2032     {
2033       DALI_TEST_CHECK(signal.Empty());
2034       TestSlotDelegateHandler handler;
2035       signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2036       DALI_TEST_CHECK(!signal.Empty());
2037     }
2038     // End of slot lifetime
2039     DALI_TEST_CHECK(signal.Empty());
2040
2041     // Signal emission should be a NOOP
2042     bool blah = signal.Emit(1.0f, 2);
2043     DALI_TEST_CHECK(!blah);
2044   }
2045
2046   {
2047     TestSignals::IntRet2ValueParamSignal signal;
2048     {
2049       DALI_TEST_CHECK(signal.Empty());
2050       TestSlotDelegateHandler handler;
2051       signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2052       DALI_TEST_CHECK(!signal.Empty());
2053     }
2054     // End of slot lifetime
2055     DALI_TEST_CHECK(signal.Empty());
2056
2057     // Signal emission should be a NOOP
2058     int blah = signal.Emit(10.0f, 100);
2059     DALI_TEST_CHECK(0 == blah);
2060   }
2061
2062   {
2063     TestSignals::FloatRet0ParamSignal signal;
2064     {
2065       DALI_TEST_CHECK(signal.Empty());
2066       TestSlotDelegateHandler handler;
2067       signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2068       DALI_TEST_CHECK(!signal.Empty());
2069     }
2070     // End of slot lifetime
2071     DALI_TEST_CHECK(signal.Empty());
2072
2073     // Signal emission should be a NOOP
2074     float blah = signal.Emit();
2075     DALI_TEST_CHECK(0.0f == blah);
2076   }
2077
2078   {
2079     TestSignals::FloatRet2ValueParamSignal signal;
2080     {
2081       DALI_TEST_CHECK(signal.Empty());
2082       TestSlotDelegateHandler handler;
2083       signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2084       DALI_TEST_CHECK(!signal.Empty());
2085     }
2086     // End of slot lifetime
2087     DALI_TEST_CHECK(signal.Empty());
2088
2089     // Signal emission should be a NOOP
2090     float blah = signal.Emit(3.0f, 4.0f);
2091     DALI_TEST_CHECK(0.0f == blah);
2092   }
2093   END_TEST;
2094 }
2095
2096 int UtcDaliSlotHandlerDisconnect(void)
2097 {
2098   // Test that callbacks don't occur if a signal is disconnected before emission
2099
2100   TestSignals signals;
2101
2102   {
2103     TestSlotDelegateHandler handlers;
2104     signals.SignalVoidNone().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
2105     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2106     signals.SignalVoidNone().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
2107     signals.EmitVoidSignalVoid();
2108     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2109   }
2110
2111   {
2112     TestSlotDelegateHandler handlers;
2113     signals.SignalVoid1Ref().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
2114     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2115     int r               = 7;
2116     handlers.mIntReturn = 5;
2117     signals.SignalVoid1Ref().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
2118     signals.EmitVoidSignalIntRef(r);
2119     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2120     DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
2121     DALI_TEST_EQUALS(r, 7, TEST_LOCATION);
2122   }
2123
2124   {
2125     TestSlotDelegateHandler handlers;
2126     signals.SignalVoid1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
2127     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2128     signals.SignalVoid1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
2129     signals.EmitVoidSignal1IntValue(5);
2130     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2131     DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
2132   }
2133
2134   {
2135     TestSlotDelegateHandler handlers;
2136     signals.SignalVoid2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
2137     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2138     signals.SignalVoid2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
2139     signals.EmitVoidSignal2IntValue(5, 10);
2140     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2141     DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
2142     DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
2143   }
2144
2145   {
2146     TestSlotDelegateHandler handlers;
2147     signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2148     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2149     handlers.mBoolReturn = true;
2150     signals.SignalBool1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2151     DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION);
2152     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2153     DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
2154   }
2155
2156   {
2157     TestSlotDelegateHandler handlers;
2158     signals.SignalBool2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2159     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2160     handlers.mBoolReturn = true;
2161     signals.SignalBool2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2162     DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION);
2163     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2164     DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
2165     DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
2166   }
2167
2168   {
2169     TestSlotDelegateHandler handlers;
2170     signals.SignalInt2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2171     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2172     handlers.mIntReturn = 27;
2173     signals.SignalInt2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2174     signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
2175     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2176     DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
2177     DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
2178   }
2179
2180   {
2181     TestSlotDelegateHandler handlers;
2182     signals.SignalFloat0().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2183     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2184     handlers.mFloatReturn = 27.0f;
2185     signals.SignalFloat0().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2186     signals.EmitFloat0Signal();
2187     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2188     DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
2189     DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
2190   }
2191
2192   {
2193     TestSlotDelegateHandler handlers;
2194     signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2195     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2196     handlers.mFloatReturn = 27.0f;
2197     signals.SignalFloat2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2198     signals.EmitFloat2VSignal(5, 33.0f);
2199     DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
2200     DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
2201     DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
2202   }
2203   END_TEST;
2204 }
2205
2206 int UtcDaliCallbackBase(void)
2207 {
2208   // simple constructor for coverage
2209   CallbackBase base;
2210   tet_result(TET_PASS);
2211   END_TEST;
2212 }
2213
2214 int UtcDaliSlotDelegateMethods(void)
2215 {
2216   TestSignals signals;
2217
2218   TestSlotDelegateHandler handlers;
2219   DALI_TEST_EQUALS(0, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION);
2220   signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2221   DALI_TEST_EQUALS(1, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION);
2222   signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2223   DALI_TEST_EQUALS(2, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION);
2224
2225   handlers.mSlotDelegate.DisconnectAll();
2226   DALI_TEST_EQUALS(0, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION);
2227
2228   END_TEST;
2229 }