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