automated-tests/TET/dali-test-suite/signals/utc-Dali-SignalTemplatesV2.cpp

   1 //
   2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.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://floralicense.org/license/
   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 // EXTERNAL INCLUDES
  18 #include <iostream>
  19 #include <stdlib.h>
  20 #include <tet_api.h>
  21
  22 // INTERNAL INCLUDES
  23 #include <dali/public-api/common/dali-vector.h>
  24 #include <dali/public-api/dali-core.h>
  25
  26 #include <dali-test-suite-utils.h>
  27
  28 using namespace Dali;
  29
  30 static void Startup();
  31 static void Cleanup();
  32
  33 extern "C" {
  34   void (*tet_startup)() = Startup;
  35   void (*tet_cleanup)() = Cleanup;
  36 }
  37
  38 enum {
  39   POSITIVE_TC_IDX = 0x01,
  40   NEGATIVE_TC_IDX,
  41 };
  42
  43 #define MAX_NUMBER_OF_TESTS 10000
  44 extern "C" {
  45   struct tet_testlist tet_testlist[MAX_NUMBER_OF_TESTS];
  46 }
  47
  48 TEST_FUNCTION( UtcDaliSignalEmptyCheck,                POSITIVE_TC_IDX );
  49 TEST_FUNCTION( UtcDaliSignalEmptyCheckSlotDestruction, POSITIVE_TC_IDX );
  50 TEST_FUNCTION( UtcDaliSignalConnectAndEmit,            POSITIVE_TC_IDX );
  51 TEST_FUNCTION( UtcDaliSignalDisconnect,                POSITIVE_TC_IDX );
  52 TEST_FUNCTION( UtcDaliSignalDisconnect2,               NEGATIVE_TC_IDX );
  53 TEST_FUNCTION( UtcDaliSignalDisconnect3,               POSITIVE_TC_IDX );
  54 TEST_FUNCTION( UtcDaliSignalCustomConnectionTracker,   POSITIVE_TC_IDX );
  55 TEST_FUNCTION( UtcDaliSignalMultipleConnections,       POSITIVE_TC_IDX );
  56 TEST_FUNCTION( UtcDaliSignalMultipleConnections2,      NEGATIVE_TC_IDX );
  57 TEST_FUNCTION( UtcDaliSignalMultipleConnections3,      POSITIVE_TC_IDX );
  58
  59 TEST_FUNCTION( UtcDaliSignalDisconnectStatic,          POSITIVE_TC_IDX );
  60 TEST_FUNCTION( UtcDaliSignalDisconnectDuringCallback,  POSITIVE_TC_IDX );
  61 TEST_FUNCTION( UtcDaliSignalDisconnectDuringCallback2, POSITIVE_TC_IDX );
  62 TEST_FUNCTION( UtcDaliSignalEmitDuringCallback,        NEGATIVE_TC_IDX );
  63 TEST_FUNCTION( UtcDaliSignalTestApp01,                 POSITIVE_TC_IDX );
  64 TEST_FUNCTION( UtcDaliSignalTestApp02,                 POSITIVE_TC_IDX );
  65 TEST_FUNCTION( UtcDaliSignalTestApp03,                 POSITIVE_TC_IDX );
  66 TEST_FUNCTION( UtcDaliSignalTestApp04,                 POSITIVE_TC_IDX );
  67 TEST_FUNCTION( UtcDaliSignalTestApp05,                 POSITIVE_TC_IDX );
  68 TEST_FUNCTION( UtcDaliSignalTestApp06,                 POSITIVE_TC_IDX );
  69 TEST_FUNCTION( UtcDaliSlotDelegateConnection,          POSITIVE_TC_IDX );
  70
  71 TEST_FUNCTION( UtcDaliSignalSlotDelegateDestruction,   POSITIVE_TC_IDX );
  72 TEST_FUNCTION( UtcDaliSlotHandlerDisconnect,           POSITIVE_TC_IDX );
  73
  74 // Called only once before first test is run.
  75 static void Startup()
  76 {
  77 }
  78
  79 // Called only once after last test is run
  80 static void Cleanup()
  81 {
  82 }
  83
  84 class TestButton
  85 {
  86 public:
  87
  88   TestButton( unsigned int id )
  89   : mId(id)
  90   {
  91   }
  92
  93   void Press()
  94   {
  95     mPanelDown.Emit( *this );
  96   }
  97
  98   void Release()
  99   {
 100     mPanelUp.Emit( *this );
 101   }
 102
 103   typedef SignalV2< void (TestButton&) > PanelDownSignal;
 104   typedef SignalV2< void (TestButton&) > PanelUpSignal;
 105
 106   PanelDownSignal& DownSignal()
 107   {
 108     return mPanelDown;
 109   }
 110
 111   PanelUpSignal& SignalUp()
 112   {
 113     return mPanelUp;
 114   }
 115
 116   int GetId()
 117   {
 118     return mId;
 119   }
 120
 121 private:
 122
 123   int mId;
 124   PanelDownSignal mPanelDown;
 125   PanelUpSignal   mPanelUp;
 126 };
 127
 128 class TestApp : public ConnectionTracker
 129 {
 130 public:
 131
 132   TestApp()
 133   : mButtonPressed( false ),
 134     mVoidFunctionCalled( false )
 135   {
 136   }
 137
 138   void OnButtonPress( TestButton& button )
 139   {
 140     mButtonPressed = true;
 141     mButtonId = button.GetId();
 142   }
 143
 144   void OnButtonRelease( TestButton& button )
 145   {
 146     mButtonPressed = false;
 147     mButtonId = button.GetId();
 148   }
 149
 150   int GetButtonPressedId()
 151   {
 152     return mButtonId;
 153   }
 154
 155   bool BoolReturnTestFalse()
 156   {
 157     return false;
 158   }
 159
 160   bool BoolReturnTestTrue()
 161   {
 162     return true;
 163   }
 164
 165   void VoidFunction()
 166   {
 167     mVoidFunctionCalled = true;
 168   }
 169
 170   bool mButtonPressed;
 171   bool mVoidFunctionCalled;
 172   int mButtonId;
 173 };
 174
 175 class TestSignals
 176 {
 177 public:
 178
 179   // Void return, no parameters
 180   typedef SignalV2<void ()> VoidRetNoParamSignal;
 181
 182   // Void return, 1 value parameter
 183   typedef SignalV2<void (int)> VoidRet1ValueParamSignal;
 184
 185   // Void return, 1 reference parameter
 186   typedef SignalV2< void (int&)> VoidRet1RefParamSignal;
 187
 188   // Void return, 2 value parameters
 189   typedef SignalV2<void (int, int)> VoidRet2ValueParamSignal;
 190
 191   // bool return, 1 value parameter
 192   typedef SignalV2< bool (float)> BoolRet1ValueParamSignal;
 193
 194   // bool return, 2 value parameter
 195   typedef SignalV2<bool (float, int) > BoolRet2ValueParamSignal;
 196
 197   // int return, 2 value parameter
 198   typedef SignalV2<int (float, int)> IntRet2ValueParamSignal;
 199
 200   // float return, 0 parameters
 201   typedef SignalV2< float () > FloatRet0ParamSignal;
 202
 203   // float return, 2 value parameters
 204   typedef SignalV2<float (float, float) > FloatRet2ValueParamSignal;
 205
 206   // void return, 3 value parameters
 207   typedef SignalV2<void (float, float, float) > VoidSignalTypeFloatValue3;
 208
 209   // float return, 3 value parameters
 210   typedef SignalV2<float (float, float, float) > FloatSignalTypeFloatValue3;
 211
 212   VoidRetNoParamSignal&       SignalVoidNone()    { return mSignalVoid0;  }
 213   VoidRet1RefParamSignal&     SignalVoid1Ref()    { return mSignalVoid1R; }
 214   VoidRet1ValueParamSignal&   SignalVoid1Value()  { return mSignalVoid1V; }
 215   VoidRet2ValueParamSignal&   SignalVoid2Value()  { return mSignalVoid2V; }
 216
 217   BoolRet1ValueParamSignal&   SignalBool1Value()  { return mSignalBool1V;  }
 218   BoolRet2ValueParamSignal&   SignalBool2Value()  { return mSignalBool2V;  }
 219   IntRet2ValueParamSignal&    SignalInt2Value()   { return mSignalInt2V;   }
 220   FloatRet0ParamSignal&       SignalFloat0()      { return mSignalFloat0;  }
 221   FloatRet2ValueParamSignal&  SignalFloat2Value() { return mSignalFloat2V; }
 222
 223   VoidSignalTypeFloatValue3&  VoidSignalFloatValue3()  { return mVoidSignalFloatValue3;  }
 224   FloatSignalTypeFloatValue3& FloatSignalFloatValue3() { return mFloatSignalFloatValue3; }
 225
 226   TestSignals()
 227   {
 228   }
 229
 230   void CheckNoConnections()
 231   {
 232     DALI_TEST_EQUALS( mSignalVoid0.GetConnectionCount(), 0u, TEST_LOCATION );
 233     DALI_TEST_EQUALS( mSignalVoid1R.GetConnectionCount(), 0u, TEST_LOCATION );
 234     DALI_TEST_EQUALS( mSignalVoid1V.GetConnectionCount(), 0u, TEST_LOCATION );
 235     DALI_TEST_EQUALS( mSignalVoid2V.GetConnectionCount(), 0u, TEST_LOCATION );
 236     DALI_TEST_EQUALS( mSignalBool1V.GetConnectionCount(), 0u, TEST_LOCATION );
 237     DALI_TEST_EQUALS( mSignalBool2V.GetConnectionCount(), 0u, TEST_LOCATION );
 238     DALI_TEST_EQUALS( mSignalInt2V.GetConnectionCount(), 0u, TEST_LOCATION );
 239     DALI_TEST_EQUALS( mSignalFloat0.GetConnectionCount(), 0u, TEST_LOCATION );
 240     DALI_TEST_EQUALS( mSignalFloat2V.GetConnectionCount(), 0u, TEST_LOCATION );
 241     DALI_TEST_EQUALS( mVoidSignalFloatValue3.GetConnectionCount(), 0u, TEST_LOCATION );
 242     DALI_TEST_EQUALS( mFloatSignalFloatValue3.GetConnectionCount(), 0u, TEST_LOCATION );
 243   }
 244
 245   void EmitVoidSignalVoid()
 246   {
 247     mSignalVoid0.Emit();
 248   }
 249
 250   void EmitVoidSignalIntRef(int& ref)
 251   {
 252     mSignalVoid1R.Emit(ref);
 253   }
 254
 255   void EmitVoidSignalIntValue(int p1)
 256   {
 257     mSignalVoid1V.Emit(p1);
 258   }
 259
 260   void EmitVoidSignalIntValueIntValue(int p1, int p2)
 261   {
 262     mSignalVoid2V.Emit(p1,p2);
 263   }
 264
 265   bool EmitBoolSignalFloatValue(float p1)
 266   {
 267     return mSignalBool1V.Emit(p1);
 268   }
 269
 270   bool EmitBoolSignalFloatValueIntValue(float p1, int p2)
 271   {
 272     return mSignalBool2V.Emit(p1, p2);
 273   }
 274
 275   int EmitIntSignalFloatValueIntValue(float p1, int p2)
 276   {
 277     return mSignalInt2V.Emit(p1, p2);
 278   }
 279
 280   float EmitFloat2VSignal(float p1, float p2)
 281   {
 282     return mSignalFloat2V.Emit(p1, p2);
 283   }
 284
 285   float EmitFloat0Signal()
 286   {
 287     return mSignalFloat0.Emit();
 288   }
 289
 290   void EmitVoidSignalFloatValue3(float p1, float p2, float p3)
 291   {
 292     mVoidSignalFloatValue3.Emit(p1, p2, p3);
 293   }
 294
 295   float EmitFloatSignalFloatValue3(float p1, float p2, float p3)
 296   {
 297     return mFloatSignalFloatValue3.Emit(p1, p2, p3);
 298   }
 299
 300 private:
 301
 302   VoidRetNoParamSignal         mSignalVoid0;
 303   VoidRet1RefParamSignal       mSignalVoid1R;
 304   VoidRet1ValueParamSignal     mSignalVoid1V;
 305   VoidRet2ValueParamSignal     mSignalVoid2V;
 306   BoolRet1ValueParamSignal     mSignalBool1V;
 307   BoolRet2ValueParamSignal     mSignalBool2V;
 308   IntRet2ValueParamSignal      mSignalInt2V;
 309   FloatRet0ParamSignal         mSignalFloat0;
 310   FloatRet2ValueParamSignal    mSignalFloat2V;
 311   VoidSignalTypeFloatValue3    mVoidSignalFloatValue3;
 312   FloatSignalTypeFloatValue3   mFloatSignalFloatValue3;
 313 };
 314
 315 /**
 316  * A helper class with various slots
 317  */
 318 class TestSlotHandler : public ConnectionTracker
 319 {
 320 public:
 321
 322   TestSlotHandler()
 323   : mIntParam1( 0 ),
 324     mIntParam2( 0 ),
 325     mIntParam3( 0 ),
 326     mFloatParam1( 0.0f ),
 327     mFloatParam2( 0.0f ),
 328     mFloatParam3( 0.0f ),
 329     mBoolReturn( false ),
 330     mIntReturn( 0 ),
 331     mFloatReturn( 0.0f ),
 332     mHandled( false ),
 333     mHandledCount( 0 )
 334   {
 335   }
 336
 337   void Reset()
 338   {
 339     mIntParam1 = 0;
 340     mIntParam2 = 0;
 341     mIntParam3 = 0;
 342     mFloatParam1 = 0.0f;
 343     mFloatParam2 = 0.0f;
 344     mFloatParam3 = 0.0f;
 345     mBoolReturn = false;
 346     mIntReturn = 0;
 347     mFloatReturn = 0.0f;
 348     mHandled = false;
 349   }
 350
 351   void VoidSlotVoid()
 352   {
 353     mHandled = true;
 354     ++mHandledCount;
 355   }
 356
 357   void VoidSlotIntRef( int& p1 )
 358   {
 359     mIntParam1 = p1;
 360     mHandled = true;
 361     ++mHandledCount;
 362   }
 363
 364   void VoidSlotIntValue( int p1 )
 365   {
 366     mIntParam1 = p1;
 367     mHandled = true;
 368     ++mHandledCount;
 369   }
 370
 371   void VoidDuplicateSlotIntValue( int p1 )
 372   {
 373     mIntParam2 = p1;
 374     mHandled = true;
 375     ++mHandledCount;
 376   }
 377
 378   void VoidSlotIntValueIntValue( int p1, int p2 )
 379   {
 380     mIntParam1 = p1;
 381     mIntParam2 = p2;
 382     mHandled = true;
 383     ++mHandledCount;
 384   }
 385
 386   bool BoolSlotFloatValue( float p1 )
 387   {
 388     mFloatParam1 = p1;
 389     mHandled = true;
 390     ++mHandledCount;
 391     return mBoolReturn;
 392   }
 393
 394   bool BoolSlotFloatValueIntValue( float p1, int p2 )
 395   {
 396     mFloatParam1 = p1;
 397     mIntParam2 = p2;
 398     mHandled = true;
 399     ++mHandledCount;
 400     return mBoolReturn;
 401   }
 402
 403   int IntSlotFloatValueIntValue( float p1, int p2 )
 404   {
 405     mFloatParam1 = p1;
 406     mIntParam2 = p2;
 407     mHandled = true;
 408     ++mHandledCount;
 409     return mIntReturn;
 410   }
 411
 412   float FloatSlotVoid()
 413   {
 414     mHandled = true;
 415     ++mHandledCount;
 416     return mFloatReturn;
 417   }
 418
 419   float FloatSlotFloatValueFloatValue( float p1, float p2 )
 420   {
 421     mFloatParam1 = p1;
 422     mFloatParam2 = p2;
 423     mHandled = true;
 424     ++mHandledCount;
 425     return mFloatReturn;
 426   }
 427
 428   void VoidSlotFloatValue3( float p1, float p2, float p3 )
 429   {
 430     mFloatParam1 = p1;
 431     mFloatParam2 = p2;
 432     mFloatParam3 = p3;
 433     mHandled = true;
 434     ++mHandledCount;
 435   }
 436
 437   float FloatSlotFloatValue3( float p1, float p2, float p3 )
 438   {
 439     mFloatParam1 = p1;
 440     mFloatParam2 = p2;
 441     mFloatParam3 = p3;
 442     mHandled = true;
 443     ++mHandledCount;
 444     return mFloatReturn;
 445   }
 446
 447   int mIntParam1, mIntParam2, mIntParam3;
 448   float mFloatParam1, mFloatParam2, mFloatParam3;
 449   bool mBoolReturn;
 450   int mIntReturn;
 451   float mFloatReturn;
 452   bool mHandled;
 453   int mHandledCount;
 454 };
 455
 456 /**
 457  * A version of TestSlotHandler which disconnects during the callback
 458  */
 459 class TestSlotDisconnector : public ConnectionTracker
 460 {
 461 public:
 462
 463   TestSlotDisconnector()
 464   : mIntParam1( 0 ),
 465     mIntParam2( 0 ),
 466     mIntParam3( 0 ),
 467     mFloatParam1( 0.0f ),
 468     mFloatParam2( 0.0f ),
 469     mBoolReturn( false ),
 470     mIntReturn( 0 ),
 471     mFloatReturn( 0.0f ),
 472     mHandled( false )
 473   {
 474   }
 475
 476   void Reset()
 477   {
 478     mIntParam1 = 0;
 479     mIntParam2 = 0;
 480     mIntParam3 = 0;
 481     mFloatParam1 = 0.0f;
 482     mFloatParam2 = 0.0f;
 483     mBoolReturn = false;
 484     mIntReturn = 0;
 485     mFloatReturn = 0.0f;
 486     mHandled = false;
 487   }
 488
 489   void VoidConnectVoid( TestSignals::VoidRetNoParamSignal& signal )
 490   {
 491     mVoidSignalVoid = &signal;
 492     signal.Connect( this, &TestSlotDisconnector::VoidSlotVoid );
 493   }
 494
 495   void VoidSlotVoid()
 496   {
 497     mVoidSignalVoid->Disconnect( this, &TestSlotDisconnector::VoidSlotVoid );
 498     mHandled = true;
 499   }
 500
 501   void VoidConnectIntRef( TestSignals::VoidRet1RefParamSignal& signal )
 502   {
 503     mVoidSignalIntRef = &signal;
 504     signal.Connect( this, &TestSlotDisconnector::VoidSlotIntRef );
 505   }
 506
 507   void VoidSlotIntRef( int& p1 )
 508   {
 509     mVoidSignalIntRef->Disconnect( this, &TestSlotDisconnector::VoidSlotIntRef );
 510     mIntParam1 = p1;
 511     mHandled = true;
 512   }
 513
 514   void VoidSlotIntValue( int p1 )
 515   {
 516     mIntParam1 = p1;
 517     mHandled = true;
 518   }
 519
 520   void VoidSlotIntValueIntValue( int p1, int p2 )
 521   {
 522     mIntParam1 = p1;
 523     mIntParam2 = p2;
 524     mHandled = true;
 525   }
 526
 527   bool BoolSlotFloatValue( float p1 )
 528   {
 529     mFloatParam1 = p1;
 530     mHandled = true;
 531     return mBoolReturn;
 532   }
 533
 534   bool BoolSlotFloatValueIntValue( float p1, int p2 )
 535   {
 536     mFloatParam1 = p1;
 537     mIntParam2 = p2;
 538     mHandled = true;
 539     return mBoolReturn;
 540   }
 541
 542   int IntSlotFloatValueIntValue( float p1, int p2 )
 543   {
 544     mFloatParam1 = p1;
 545     mIntParam2 = p2;
 546     mHandled = true;
 547     return mIntReturn;
 548   }
 549
 550   float FloatSlotVoid()
 551   {
 552     mHandled = true;
 553     return mFloatReturn;
 554   }
 555
 556   float FloatSlotFloatValueFloatValue( float p1, float p2 )
 557   {
 558     mFloatParam1 = p1;
 559     mFloatParam2 = p2;
 560     mHandled = true;
 561     return mFloatReturn;
 562   }
 563
 564   TestSignals::VoidRetNoParamSignal*   mVoidSignalVoid;
 565   TestSignals::VoidRet1RefParamSignal* mVoidSignalIntRef;
 566
 567   int mIntParam1, mIntParam2, mIntParam3;
 568   float mFloatParam1, mFloatParam2;
 569   bool mBoolReturn;
 570   int mIntReturn;
 571   float mFloatReturn;
 572   bool mHandled;
 573 };
 574
 575 /**
 576  * A more complicated version of TestSlotDisconnector, which disconnects some but not all callbacks
 577  */
 578 class TestSlotMultiDisconnector : public ConnectionTracker
 579 {
 580 public:
 581
 582   static const int NUM_SLOTS = 10;
 583
 584   TestSlotMultiDisconnector()
 585   : mVoidSignalVoid( NULL )
 586   {
 587     Reset();
 588   }
 589
 590   void Reset()
 591   {
 592     for( int i=0; i<NUM_SLOTS; ++i )
 593     {
 594       mSlotHandled[i] = false;
 595     }
 596   }
 597
 598   void ConnectAll( TestSignals::VoidRetNoParamSignal& signal )
 599   {
 600     mVoidSignalVoid = &signal;
 601     signal.Connect( this, &TestSlotMultiDisconnector::Slot0 );
 602     signal.Connect( this, &TestSlotMultiDisconnector::Slot1 );
 603     signal.Connect( this, &TestSlotMultiDisconnector::Slot2 );
 604     signal.Connect( this, &TestSlotMultiDisconnector::Slot3 );
 605     signal.Connect( this, &TestSlotMultiDisconnector::Slot4 );
 606     signal.Connect( this, &TestSlotMultiDisconnector::Slot5 );
 607     signal.Connect( this, &TestSlotMultiDisconnector::Slot6 );
 608     signal.Connect( this, &TestSlotMultiDisconnector::Slot7 );
 609     signal.Connect( this, &TestSlotMultiDisconnector::Slot8 );
 610     signal.Connect( this, &TestSlotMultiDisconnector::Slot9 );
 611   }
 612
 613   void Slot0()
 614   {
 615     mSlotHandled[0] = true;
 616   }
 617
 618   void Slot1()
 619   {
 620     mSlotHandled[1] = true;
 621   }
 622
 623   void Slot2()
 624   {
 625     mSlotHandled[2] = true;
 626   }
 627
 628   void Slot3()
 629   {
 630     mSlotHandled[3] = true;
 631
 632     // Disconnect the odd numbered lots, because we can
 633     mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot1 );
 634     mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot3 );
 635     mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot5 );
 636     mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot7 );
 637     mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot9 );
 638   }
 639
 640   void Slot4()
 641   {
 642     mSlotHandled[4] = true;
 643   }
 644
 645   void Slot5()
 646   {
 647     mSlotHandled[5] = true;
 648   }
 649
 650   void Slot6()
 651   {
 652     mSlotHandled[6] = true;
 653   }
 654
 655   void Slot7()
 656   {
 657     mSlotHandled[7] = true;
 658   }
 659
 660   void Slot8()
 661   {
 662     mSlotHandled[8] = true;
 663   }
 664
 665   void Slot9()
 666   {
 667     mSlotHandled[9] = true;
 668   }
 669
 670   TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
 671
 672   bool mSlotHandled[NUM_SLOTS];
 673 };
 674
 675
 676 /**
 677  * A version of TestSlotHandler which disconnects during the callback
 678  */
 679 class TestEmitDuringCallback : public ConnectionTracker
 680 {
 681 public:
 682
 683   TestEmitDuringCallback()
 684   : mVoidSignalVoid( NULL ),
 685     mHandled( false )
 686   {
 687   }
 688
 689   void VoidConnectVoid( TestSignals::VoidRetNoParamSignal& signal )
 690   {
 691     mVoidSignalVoid = &signal;
 692     signal.Connect( this, &TestEmitDuringCallback::VoidSlotVoid );
 693   }
 694
 695   void VoidSlotVoid()
 696   {
 697     // Emitting during Emit is very bad!
 698     mVoidSignalVoid->Emit();
 699
 700     mHandled = true;
 701   }
 702
 703   TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
 704
 705   bool mHandled;
 706 };
 707
 708
 709 /**
 710  * A version of TestSlotHandler which uses SlotDelegate
 711  */
 712 class TestSlotDelegateHandler // This does not inherit from ConnectionTrackerInterface!
 713 {
 714 public:
 715
 716   TestSlotDelegateHandler()
 717   : mSlotDelegate( this ),
 718     mIntParam1( 0 ),
 719     mIntParam2( 0 ),
 720     mIntParam3( 0 ),
 721     mFloatParam1( 0.0f ),
 722     mFloatParam2( 0.0f ),
 723     mFloatParam3( 0.0f ),
 724     mBoolReturn( false ),
 725     mIntReturn( 0 ),
 726     mFloatReturn( 0.0f ),
 727     mHandled( false ),
 728     mHandledCount( 0 )
 729   {
 730   }
 731
 732   void Reset()
 733   {
 734     mIntParam1 = 0;
 735     mIntParam2 = 0;
 736     mIntParam3 = 0;
 737     mFloatParam1 = 0.0f;
 738     mFloatParam2 = 0.0f;
 739     mFloatParam3 = 0.0f;
 740     mBoolReturn = false;
 741     mIntReturn = 0;
 742     mFloatReturn = 0.0f;
 743     mHandled = false;
 744   }
 745
 746   void VoidSlotVoid()
 747   {
 748     mHandled = true;
 749     ++mHandledCount;
 750   }
 751
 752   void VoidSlotIntRef( int& p1 )
 753   {
 754     mIntParam1 = p1;
 755     mHandled = true;
 756     ++mHandledCount;
 757   }
 758
 759   void VoidSlotIntValue( int p1 )
 760   {
 761     mIntParam1 = p1;
 762     mHandled = true;
 763     ++mHandledCount;
 764   }
 765
 766   void VoidDuplicateSlotIntValue( int p1 )
 767   {
 768     mIntParam2 = p1;
 769     mHandled = true;
 770     ++mHandledCount;
 771   }
 772
 773   void VoidSlotIntValueIntValue( int p1, int p2 )
 774   {
 775     mIntParam1 = p1;
 776     mIntParam2 = p2;
 777     mHandled = true;
 778     ++mHandledCount;
 779   }
 780
 781   bool BoolSlotFloatValue( float p1 )
 782   {
 783     mFloatParam1 = p1;
 784     mHandled = true;
 785     ++mHandledCount;
 786     return mBoolReturn;
 787   }
 788
 789   bool BoolSlotFloatValueIntValue( float p1, int p2 )
 790   {
 791     mFloatParam1 = p1;
 792     mIntParam2 = p2;
 793     mHandled = true;
 794     ++mHandledCount;
 795     return mBoolReturn;
 796   }
 797
 798   int IntSlotFloatValueIntValue( float p1, int p2 )
 799   {
 800     mFloatParam1 = p1;
 801     mIntParam2 = p2;
 802     mHandled = true;
 803     ++mHandledCount;
 804     return mIntReturn;
 805   }
 806
 807   float FloatSlotVoid()
 808   {
 809     mHandled = true;
 810     ++mHandledCount;
 811     return mFloatReturn;
 812   }
 813
 814   float FloatSlotFloatValueFloatValue( float p1, float p2 )
 815   {
 816     mFloatParam1 = p1;
 817     mFloatParam2 = p2;
 818     mHandled = true;
 819     ++mHandledCount;
 820     return mFloatReturn;
 821   }
 822
 823   void VoidSlotFloatValue3( float p1, float p2, float p3 )
 824   {
 825     mFloatParam1 = p1;
 826     mFloatParam2 = p2;
 827     mFloatParam3 = p3;
 828     mHandled = true;
 829     ++mHandledCount;
 830   }
 831
 832   float FloatSlotFloatValue3( float p1, float p2, float p3 )
 833   {
 834     mFloatParam1 = p1;
 835     mFloatParam2 = p2;
 836     mFloatParam3 = p3;
 837     mHandled = true;
 838     ++mHandledCount;
 839     return mFloatReturn;
 840   }
 841
 842   SlotDelegate<TestSlotDelegateHandler> mSlotDelegate;
 843
 844   int mIntParam1, mIntParam2, mIntParam3;
 845   float mFloatParam1, mFloatParam2, mFloatParam3;
 846   bool mBoolReturn;
 847   int mIntReturn;
 848   float mFloatReturn;
 849   bool mHandled;
 850   int mHandledCount;
 851 };
 852
 853 /**
 854  * Test that reimplmenting ConnectionTrackerInterface actually works.
 855  * This basic connection tracker only allows one callback to be connected.
 856  */
 857 class TestBasicConnectionTrackerInterface : public ConnectionTrackerInterface
 858 {
 859 public:
 860
 861   TestBasicConnectionTrackerInterface()
 862   : mCallbackHandled( false ),
 863     mCallback( NULL ),
 864     mSlotObserver( NULL )
 865   {
 866   }
 867
 868   ~TestBasicConnectionTrackerInterface()
 869   {
 870     if( mCallback )
 871     {
 872       // Notify signal since the slot has been destroyed
 873       mSlotObserver->SlotDisconnected( mCallback );
 874       delete mCallback;
 875     }
 876   }
 877
 878   /**
 879    * An example slot
 880    */
 881   void VoidSlotVoid()
 882   {
 883     mCallbackHandled = true;
 884   }
 885
 886   /**
 887    * @copydoc ConnectionTrackerInterface::GetConnectionCount
 888    */
 889   virtual std::size_t GetConnectionCount() const
 890   {
 891     if( mCallback )
 892     {
 893       return 1u;
 894     }
 895
 896     return 0u;
 897   }
 898
 899   /**
 900    * @copydoc ConnectionTrackerInterface::SignalConnected
 901    */
 902   virtual void SignalConnected( SlotObserver* slotObserver, CallbackBase* callback )
 903   {
 904     DALI_ASSERT_ALWAYS( NULL == mCallback && "Only one connection supported!" );
 905
 906     mCallback = callback;
 907     mSlotObserver = slotObserver;
 908   }
 909
 910   /**
 911    * @copydoc ConnectionTrackerInterface::SignalDisconnected
 912    */
 913   virtual void SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback )
 914   {
 915     if( mSlotObserver == slotObserver )
 916     {
 917       mSlotObserver = NULL;
 918
 919       delete mCallback;
 920       mCallback = NULL;
 921     }
 922   }
 923
 924 private:
 925
 926   TestBasicConnectionTrackerInterface( const TestBasicConnectionTrackerInterface& );            ///< undefined copy constructor
 927   TestBasicConnectionTrackerInterface& operator=( const TestBasicConnectionTrackerInterface& ); ///< undefined assignment operator
 928
 929 public:
 930
 931   bool mCallbackHandled;
 932
 933 private:
 934
 935   CallbackBase* mCallback;     ///< callback, has ownership
 936   SlotObserver* mSlotObserver; ///< a pointer to the slot observer (not owned)
 937 };
 938
 939 static void UtcDaliSignalEmptyCheck()
 940 {
 941   // Test that Empty() check works before & after signal connection
 942
 943   {
 944     TestSignals::VoidRetNoParamSignal signal;
 945     DALI_TEST_CHECK( signal.Empty() );
 946     TestSlotHandler handler;
 947     signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
 948     DALI_TEST_CHECK( ! signal.Empty() );
 949   }
 950
 951   {
 952     TestSignals::VoidRet1ValueParamSignal signal;
 953     DALI_TEST_CHECK( signal.Empty() );
 954     TestSlotHandler handler;
 955     signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValue );
 956     DALI_TEST_CHECK( ! signal.Empty() );
 957   }
 958
 959   {
 960     TestSignals::VoidRet1RefParamSignal signal;
 961     DALI_TEST_CHECK( signal.Empty() );
 962     TestSlotHandler handler;
 963     signal.Connect( &handler, &TestSlotHandler::VoidSlotIntRef );
 964     DALI_TEST_CHECK( ! signal.Empty() );
 965   }
 966
 967   {
 968     TestSignals::VoidRet2ValueParamSignal signal;
 969     DALI_TEST_CHECK( signal.Empty() );
 970     TestSlotHandler handler;
 971     signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValueIntValue );
 972     DALI_TEST_CHECK( ! signal.Empty() );
 973   }
 974
 975   {
 976     TestSignals::BoolRet1ValueParamSignal signal;
 977     DALI_TEST_CHECK( signal.Empty() );
 978     TestSlotHandler handler;
 979     signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValue );
 980     DALI_TEST_CHECK( ! signal.Empty() );
 981   }
 982
 983   {
 984     TestSignals::BoolRet2ValueParamSignal signal;
 985     DALI_TEST_CHECK( signal.Empty() );
 986     TestSlotHandler handler;
 987     signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValueIntValue );
 988     DALI_TEST_CHECK( ! signal.Empty() );
 989   }
 990
 991   {
 992     TestSignals::IntRet2ValueParamSignal signal;
 993     DALI_TEST_CHECK( signal.Empty() );
 994     TestSlotHandler handler;
 995     signal.Connect( &handler, &TestSlotHandler::IntSlotFloatValueIntValue );
 996     DALI_TEST_CHECK( ! signal.Empty() );
 997   }
 998
 999   {
1000     TestSignals::FloatRet0ParamSignal signal;
1001     DALI_TEST_CHECK( signal.Empty() );
1002     TestSlotHandler handler;
1003     signal.Connect( &handler, &TestSlotHandler::FloatSlotVoid );
1004     DALI_TEST_CHECK( ! signal.Empty() );
1005   }
1006
1007   {
1008     TestSignals::FloatRet2ValueParamSignal signal;
1009     DALI_TEST_CHECK( signal.Empty() );
1010     TestSlotHandler handler;
1011     signal.Connect(&handler, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1012     DALI_TEST_CHECK( ! signal.Empty() );
1013   }
1014 }
1015
1016 static void UtcDaliSignalEmptyCheckSlotDestruction()
1017 {
1018   // Test that signal disconnect works when slot is destroyed (goes out of scope)
1019
1020   {
1021     TestSignals::VoidRetNoParamSignal signal;
1022     {
1023       DALI_TEST_CHECK( signal.Empty() );
1024       TestSlotHandler handler;
1025       signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
1026       DALI_TEST_CHECK( ! signal.Empty() );
1027     }
1028     // End of slot lifetime
1029     DALI_TEST_CHECK( signal.Empty() );
1030
1031     // Signal emission should be a NOOP
1032     signal.Emit();
1033   }
1034
1035   {
1036     TestSignals::VoidRet1ValueParamSignal signal;
1037     {
1038       DALI_TEST_CHECK( signal.Empty() );
1039       TestSlotHandler handler;
1040       signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValue );
1041       DALI_TEST_CHECK( ! signal.Empty() );
1042     }
1043     // End of slot lifetime
1044     DALI_TEST_CHECK( signal.Empty() );
1045
1046     // Signal emission should be a NOOP
1047     signal.Emit( 10 );
1048   }
1049
1050   {
1051     TestSignals::VoidRet1RefParamSignal signal;
1052     {
1053       DALI_TEST_CHECK( signal.Empty() );
1054       TestSlotHandler handler;
1055       signal.Connect( &handler, &TestSlotHandler::VoidSlotIntRef );
1056       DALI_TEST_CHECK( ! signal.Empty() );
1057     }
1058     // End of slot lifetime
1059     DALI_TEST_CHECK( signal.Empty() );
1060
1061     // Signal emission should be a NOOP
1062     int temp( 5 );
1063     signal.Emit( temp );
1064   }
1065
1066   {
1067     TestSignals::VoidRet2ValueParamSignal signal;
1068     {
1069       DALI_TEST_CHECK( signal.Empty() );
1070       TestSlotHandler handler;
1071       signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValueIntValue );
1072       DALI_TEST_CHECK( ! signal.Empty() );
1073     }
1074     // End of slot lifetime
1075     DALI_TEST_CHECK( signal.Empty() );
1076
1077     // Signal emission should be a NOOP
1078     signal.Emit( 1, 2 );
1079   }
1080
1081   {
1082     TestSignals::BoolRet1ValueParamSignal signal;
1083     {
1084       DALI_TEST_CHECK( signal.Empty() );
1085       TestSlotHandler handler;
1086       signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValue );
1087       DALI_TEST_CHECK( ! signal.Empty() );
1088     }
1089     // End of slot lifetime
1090     DALI_TEST_CHECK( signal.Empty() );
1091
1092     // Signal emission should be a NOOP
1093     bool blah = signal.Emit( 1.0f );
1094     DALI_TEST_CHECK( ! blah );
1095   }
1096
1097   {
1098     TestSignals::BoolRet2ValueParamSignal signal;
1099     {
1100       DALI_TEST_CHECK( signal.Empty() );
1101       TestSlotHandler handler;
1102       signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValueIntValue );
1103       DALI_TEST_CHECK( ! signal.Empty() );
1104     }
1105     // End of slot lifetime
1106     DALI_TEST_CHECK( signal.Empty() );
1107
1108     // Signal emission should be a NOOP
1109     bool blah = signal.Emit( 1.0f, 2 );
1110     DALI_TEST_CHECK( ! blah );
1111   }
1112
1113   {
1114     TestSignals::IntRet2ValueParamSignal signal;
1115     {
1116       DALI_TEST_CHECK( signal.Empty() );
1117       TestSlotHandler handler;
1118       signal.Connect( &handler, &TestSlotHandler::IntSlotFloatValueIntValue );
1119       DALI_TEST_CHECK( ! signal.Empty() );
1120     }
1121     // End of slot lifetime
1122     DALI_TEST_CHECK( signal.Empty() );
1123
1124     // Signal emission should be a NOOP
1125     int blah = signal.Emit( 10.0f, 100 );
1126     DALI_TEST_CHECK( 0 == blah );
1127   }
1128
1129   {
1130     TestSignals::FloatRet0ParamSignal signal;
1131     {
1132       DALI_TEST_CHECK( signal.Empty() );
1133       TestSlotHandler handler;
1134       signal.Connect( &handler, &TestSlotHandler::FloatSlotVoid );
1135       DALI_TEST_CHECK( ! signal.Empty() );
1136     }
1137     // End of slot lifetime
1138     DALI_TEST_CHECK( signal.Empty() );
1139
1140     // Signal emission should be a NOOP
1141     float blah = signal.Emit();
1142     DALI_TEST_CHECK( 0.0f == blah );
1143   }
1144
1145   {
1146     TestSignals::FloatRet2ValueParamSignal signal;
1147     {
1148       DALI_TEST_CHECK( signal.Empty() );
1149       TestSlotHandler handler;
1150       signal.Connect(&handler, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1151       DALI_TEST_CHECK( ! signal.Empty() );
1152     }
1153     // End of slot lifetime
1154     DALI_TEST_CHECK( signal.Empty() );
1155
1156     // Signal emission should be a NOOP
1157     float blah = signal.Emit( 3.0f, 4.0f );
1158     DALI_TEST_CHECK( 0.0f == blah );
1159   }
1160 }
1161
1162 // Positive test case for a method
1163 static void UtcDaliSignalConnectAndEmit()
1164 {
1165   // Test basic signal emission for each slot type
1166
1167   TestSignals signals;
1168
1169   {
1170     TestSlotHandler handlers;
1171     signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
1172     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1173     signals.EmitVoidSignalVoid();
1174     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1175
1176     // Test double emission
1177     handlers.mHandled = false;
1178     signals.EmitVoidSignalVoid();
1179     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1180   }
1181   signals.CheckNoConnections();
1182
1183   {
1184     TestSlotHandler handlers;
1185     signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1186     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1187     int x = 7;
1188     signals.EmitVoidSignalIntRef(x);
1189     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1190     DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
1191   }
1192   signals.CheckNoConnections();
1193
1194   {
1195     TestSlotHandler handlers;
1196     signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
1197     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1198     signals.EmitVoidSignalIntValue(5);
1199     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1200     DALI_TEST_EQUALS( handlers.mIntParam1, 5, TEST_LOCATION );
1201   }
1202   signals.CheckNoConnections();
1203
1204   {
1205     TestSlotHandler handlers;
1206     signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
1207     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1208     signals.EmitVoidSignalIntValueIntValue(6, 7);
1209     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1210     DALI_TEST_EQUALS( handlers.mIntParam1, 6, TEST_LOCATION );
1211     DALI_TEST_EQUALS( handlers.mIntParam2, 7, TEST_LOCATION );
1212   }
1213   signals.CheckNoConnections();
1214
1215   {
1216     TestSlotHandler handlers;
1217     signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
1218     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1219
1220     handlers.mBoolReturn = true;
1221     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION );
1222     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1223     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1224
1225     // repeat with opposite return value
1226     handlers.mBoolReturn = false;
1227     handlers.mHandled = false;
1228     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION );
1229     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1230     DALI_TEST_EQUALS( handlers.mFloatParam1, 6.0f, TEST_LOCATION );
1231   }
1232   signals.CheckNoConnections();
1233
1234   {
1235     TestSlotHandler handlers;
1236     signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
1237     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1238     handlers.mBoolReturn = true;
1239     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION );
1240     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1241     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1242     DALI_TEST_EQUALS( handlers.mIntParam2, 10, TEST_LOCATION );
1243   }
1244   signals.CheckNoConnections();
1245
1246   {
1247     TestSlotHandler handlers;
1248     signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
1249     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1250     handlers.mIntReturn = 27;
1251     int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
1252     DALI_TEST_EQUALS( x, 27, TEST_LOCATION );
1253     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1254     DALI_TEST_EQUALS( handlers.mFloatParam1, 33.5f, TEST_LOCATION );
1255     DALI_TEST_EQUALS( handlers.mIntParam2, 5, TEST_LOCATION );
1256   }
1257   signals.CheckNoConnections();
1258
1259   {
1260     TestSlotHandler handlers;
1261     signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
1262     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1263     handlers.mFloatReturn = 27.0f;
1264     float f = signals.EmitFloat0Signal();
1265     DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
1266     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1267     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1268     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1269   }
1270   signals.CheckNoConnections();
1271
1272   {
1273     TestSlotHandler handlers;
1274     signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1275     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1276     handlers.mFloatReturn = 27.0f;
1277     float f = signals.EmitFloat2VSignal(5, 33.0f);
1278     DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
1279     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1280     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1281     DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1282   }
1283   signals.CheckNoConnections();
1284
1285   {
1286     TestSlotHandler handlers;
1287     signals.VoidSignalFloatValue3().Connect(&handlers, &TestSlotHandler::VoidSlotFloatValue3);
1288     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1289     signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
1290     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1291     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1292     DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1293     DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
1294   }
1295   signals.CheckNoConnections();
1296
1297   {
1298     TestSlotHandler handlers;
1299     signals.FloatSignalFloatValue3().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValue3);
1300     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1301     handlers.mFloatReturn = 27.0f;
1302     float returnValue = signals.EmitFloatSignalFloatValue3(5, 33.0f, 100.0f);
1303     DALI_TEST_EQUALS( returnValue, 27.0f, TEST_LOCATION );
1304     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1305     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1306     DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1307     DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
1308   }
1309   signals.CheckNoConnections();
1310 }
1311
1312 static void UtcDaliSignalDisconnect()
1313 {
1314   // Test that callbacks don't occur if a signal is disconnected before emission
1315
1316   TestSignals signals;
1317
1318   {
1319     TestSlotHandler handlers;
1320     signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
1321     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1322     signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
1323     signals.EmitVoidSignalVoid();
1324     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1325   }
1326
1327   {
1328     TestSlotHandler handlers;
1329     signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1330     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1331     int r = 7;
1332     handlers.mIntReturn = 5;
1333     signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1334     signals.EmitVoidSignalIntRef(r);
1335     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1336     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1337     DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
1338   }
1339
1340   {
1341     TestSlotHandler handlers;
1342     signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
1343     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1344     signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
1345     signals.EmitVoidSignalIntValue(5);
1346     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1347     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1348   }
1349
1350   {
1351     TestSlotHandler handlers;
1352     signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
1353     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1354     signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
1355     signals.EmitVoidSignalIntValueIntValue(5, 10);
1356     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1357     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1358     DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
1359   }
1360
1361   {
1362     TestSlotHandler handlers;
1363     signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
1364     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1365     handlers.mBoolReturn = true;
1366     signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
1367     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
1368     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1369     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1370   }
1371
1372   {
1373     TestSlotHandler handlers;
1374     signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
1375     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1376     handlers.mBoolReturn = true;
1377     signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
1378     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
1379     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1380     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1381     DALI_TEST_EQUALS( handlers.mIntParam2,   0, TEST_LOCATION );
1382   }
1383
1384   {
1385     TestSlotHandler handlers;
1386     signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
1387     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1388     handlers.mIntReturn = 27;
1389     signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
1390     signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
1391     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1392     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1393     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1394   }
1395
1396   {
1397     TestSlotHandler handlers;
1398     signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
1399     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1400     handlers.mFloatReturn = 27.0f;
1401     signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
1402     signals.EmitFloat0Signal();
1403     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1404     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
1405     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1406   }
1407
1408   {
1409     TestSlotHandler handlers;
1410     signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1411     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1412     handlers.mFloatReturn = 27.0f;
1413     signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1414     signals.EmitFloat2VSignal(5, 33.0f);
1415     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1416     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
1417     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1418   }
1419 }
1420
1421 static void UtcDaliSignalDisconnect2()
1422 {
1423   // Test that nothing happens when attempting to disconnect an unconnected slot
1424
1425   TestSignals signals;
1426   {
1427     TestSlotHandler handlers;
1428     signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
1429     signals.EmitVoidSignalVoid();
1430     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1431   }
1432
1433   {
1434     TestSlotHandler handlers;
1435     int r = 7;
1436     signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1437     signals.EmitVoidSignalIntRef(r);
1438     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1439     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1440     DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
1441   }
1442
1443   {
1444     TestSlotHandler handlers;
1445     signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
1446     signals.EmitVoidSignalIntValue(5);
1447     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1448     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1449   }
1450
1451   {
1452     TestSlotHandler handlers;
1453     signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
1454     signals.EmitVoidSignalIntValueIntValue(5, 10);
1455     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1456     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1457     DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
1458   }
1459
1460   {
1461     TestSlotHandler handlers;
1462     handlers.mBoolReturn = true;
1463     signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
1464     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
1465     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1466     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1467   }
1468
1469   {
1470     TestSlotHandler handlers;
1471     handlers.mBoolReturn = true;
1472     signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
1473     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
1474     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1475     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1476     DALI_TEST_EQUALS( handlers.mIntParam2,   0, TEST_LOCATION );
1477   }
1478
1479   {
1480     TestSlotHandler handlers;
1481     handlers.mIntReturn = 27;
1482     signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
1483     signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
1484     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1485     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1486     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1487   }
1488
1489   {
1490     TestSlotHandler handlers;
1491     handlers.mFloatReturn = 27.0f;
1492     signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1493     signals.EmitFloat2VSignal(5, 33.0f);
1494     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1495     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
1496     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1497   }
1498
1499   {
1500     TestSlotHandler handlers;
1501     handlers.mFloatReturn = 27.0f;
1502     signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
1503     signals.EmitFloat0Signal();
1504     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1505     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
1506     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1507   }
1508 }
1509
1510 static void UtcDaliSignalDisconnect3()
1511 {
1512   // Test that callbacks stop after a signal is disconnected
1513
1514   TestSignals signals;
1515
1516   {
1517     TestSlotHandler handlers;
1518     signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
1519     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1520
1521     // Emit first
1522     signals.EmitVoidSignalVoid();
1523     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1524
1525     // Disconnect and emit again
1526     handlers.mHandled = false;
1527     signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
1528     signals.EmitVoidSignalVoid();
1529     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1530   }
1531
1532   {
1533     TestSlotHandler handlers;
1534     signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1535     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1536     int r = 7;
1537
1538     // Emit first
1539     signals.EmitVoidSignalIntRef(r);
1540     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1541     DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
1542
1543     // Disconnect and emit again
1544     handlers.mHandled = false;
1545     handlers.mIntParam1 = 0;
1546     signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1547     signals.EmitVoidSignalIntRef(r);
1548     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1549     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1550     DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
1551   }
1552 }
1553
1554 static void UtcDaliSignalCustomConnectionTracker()
1555 {
1556   // Test slot destruction
1557   {
1558     TestSignals::VoidRetNoParamSignal signal;
1559     {
1560       DALI_TEST_CHECK( signal.Empty() );
1561       TestBasicConnectionTrackerInterface customTracker;
1562       signal.Connect( &customTracker, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
1563       DALI_TEST_CHECK( ! signal.Empty() );
1564     }
1565     // End of slot lifetime
1566     DALI_TEST_CHECK( signal.Empty() );
1567
1568     // Signal emission should be a NOOP
1569     signal.Emit();
1570   }
1571
1572   TestBasicConnectionTrackerInterface customTracker2;
1573
1574   // Test signal emission & destruction
1575   {
1576     TestSignals::VoidRetNoParamSignal signal;
1577     DALI_TEST_CHECK( signal.Empty() );
1578     DALI_TEST_EQUALS( 0u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1579
1580     signal.Connect( &customTracker2, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
1581     DALI_TEST_CHECK( ! signal.Empty() );
1582     DALI_TEST_EQUALS( 1u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1583
1584     DALI_TEST_EQUALS( customTracker2.mCallbackHandled, false, TEST_LOCATION );
1585     signal.Emit();
1586     DALI_TEST_EQUALS( customTracker2.mCallbackHandled, true, TEST_LOCATION );
1587   }
1588   DALI_TEST_EQUALS( 0u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1589 }
1590
1591 static void UtcDaliSignalMultipleConnections()
1592 {
1593   // Test that multiple callbacks can be connected to the same signal
1594
1595   TestSignals signals;
1596
1597   {
1598     TestSlotHandler handler1;
1599     signals.SignalVoidNone().Connect( &handler1, &TestSlotHandler::VoidSlotVoid );
1600     DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1601
1602     TestSlotHandler handler2;
1603     signals.SignalVoidNone().Connect( &handler2, &TestSlotHandler::VoidSlotVoid );
1604     DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1605
1606     signals.EmitVoidSignalVoid();
1607     DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1608     DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1609
1610     // Remove first connection and repeat
1611     handler1.Reset();
1612     handler2.Reset();
1613     signals.SignalVoidNone().Disconnect( &handler1, &TestSlotHandler::VoidSlotVoid );
1614
1615     signals.EmitVoidSignalVoid();
1616     DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1617     DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1618   }
1619
1620   {
1621     TestSlotHandler handler1;
1622     signals.SignalVoid1Ref().Connect( &handler1, &TestSlotHandler::VoidSlotIntRef );
1623     DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1624
1625     TestSlotHandler handler2;
1626     signals.SignalVoid1Ref().Connect( &handler2, &TestSlotHandler::VoidSlotIntRef );
1627     DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1628
1629     int x = 7;
1630     signals.EmitVoidSignalIntRef(x);
1631     DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1632     DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1633     DALI_TEST_EQUALS( handler1.mIntParam1, 7, TEST_LOCATION );
1634     DALI_TEST_EQUALS( handler2.mIntParam1, 7, TEST_LOCATION );
1635
1636     // Remove second connection and repeat
1637     handler1.Reset();
1638     handler2.Reset();
1639     x = 8;
1640     signals.SignalVoid1Ref().Disconnect( &handler2, &TestSlotHandler::VoidSlotIntRef );
1641
1642     signals.EmitVoidSignalIntRef(x);
1643     DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1644     DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1645     DALI_TEST_EQUALS( handler1.mIntParam1, 8, TEST_LOCATION );
1646     DALI_TEST_EQUALS( handler2.mIntParam1, 0, TEST_LOCATION );
1647   }
1648
1649   {
1650     TestSlotHandler handler1;
1651     signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1652     DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1653
1654     TestSlotHandler handler2;
1655     signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1656     DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1657
1658     TestSlotHandler handler3;
1659     signals.SignalVoid1Value().Connect( &handler3, &TestSlotHandler::VoidSlotIntValue );
1660     DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
1661
1662     signals.EmitVoidSignalIntValue( 5 );
1663     DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1664     DALI_TEST_EQUALS( handler1.mIntParam1, 5, TEST_LOCATION );
1665     DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1666     DALI_TEST_EQUALS( handler2.mIntParam1, 5, TEST_LOCATION );
1667     DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1668     DALI_TEST_EQUALS( handler3.mIntParam1, 5, TEST_LOCATION );
1669
1670     // Remove middle connection and repeat
1671     handler1.Reset();
1672     handler2.Reset();
1673     handler3.Reset();
1674     signals.SignalVoid1Value().Disconnect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1675
1676     signals.EmitVoidSignalIntValue( 6 );
1677     DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1678     DALI_TEST_EQUALS( handler1.mIntParam1, 6, TEST_LOCATION );
1679     DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1680     DALI_TEST_EQUALS( handler2.mIntParam1, 0, TEST_LOCATION );
1681     DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1682     DALI_TEST_EQUALS( handler3.mIntParam1, 6, TEST_LOCATION );
1683   }
1684
1685   // Test that multiple callbacks are disconnected when a signal is destroyed
1686
1687   TestSlotHandler handler4;
1688   TestSlotHandler handler5;
1689   TestSlotHandler handler6;
1690
1691   {
1692     TestSignals::VoidRet1ValueParamSignal tempSignal;
1693
1694     DALI_TEST_EQUALS( handler4.GetConnectionCount(), 0u, TEST_LOCATION );
1695     DALI_TEST_EQUALS( handler5.GetConnectionCount(), 0u, TEST_LOCATION );
1696     DALI_TEST_EQUALS( handler6.GetConnectionCount(), 0u, TEST_LOCATION );
1697
1698     tempSignal.Connect( &handler4, &TestSlotHandler::VoidSlotIntValue );
1699     tempSignal.Connect( &handler5, &TestSlotHandler::VoidSlotIntValue );
1700     tempSignal.Connect( &handler6, &TestSlotHandler::VoidSlotIntValue );
1701
1702     DALI_TEST_EQUALS( handler4.GetConnectionCount(), 1u, TEST_LOCATION );
1703     DALI_TEST_EQUALS( handler5.GetConnectionCount(), 1u, TEST_LOCATION );
1704     DALI_TEST_EQUALS( handler6.GetConnectionCount(), 1u, TEST_LOCATION );
1705   }
1706   // End of tempSignal lifetime
1707
1708   DALI_TEST_EQUALS( handler4.GetConnectionCount(), 0u, TEST_LOCATION );
1709   DALI_TEST_EQUALS( handler5.GetConnectionCount(), 0u, TEST_LOCATION );
1710   DALI_TEST_EQUALS( handler6.GetConnectionCount(), 0u, TEST_LOCATION );
1711 }
1712
1713 static void UtcDaliSignalMultipleConnections2()
1714 {
1715   TestSignals signals;
1716
1717   // Test that connecting the same callback twice is a NOOP
1718   {
1719     TestSlotHandler handler1;
1720
1721     // Note the double connection is intentional
1722     signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1723     signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1724     DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1725
1726     signals.EmitVoidSignalIntValue( 6 );
1727     DALI_TEST_EQUALS( handler1.mHandledCount, 1, TEST_LOCATION );
1728     DALI_TEST_EQUALS( handler1.mIntParam1, 6, TEST_LOCATION );
1729
1730     // Calling Disconnect once should be enough
1731     signals.SignalVoid1Value().Disconnect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1732     DALI_TEST_CHECK( signals.SignalVoid1Value().Empty() );
1733     handler1.mIntParam1 = 0;
1734
1735     signals.EmitVoidSignalIntValue( 7 );
1736     DALI_TEST_EQUALS( handler1.mHandledCount, 1/*not incremented since last check*/, TEST_LOCATION );
1737     DALI_TEST_EQUALS( handler1.mIntParam1, 0, TEST_LOCATION );
1738   }
1739
1740   // Test automatic disconnect after multiple Connect() calls
1741   {
1742     TestSlotHandler handler2;
1743     signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1744     signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1745
1746     TestSlotHandler handler3;
1747     signals.SignalBool1Value().Connect( &handler3, &TestSlotHandler::BoolSlotFloatValue );
1748     signals.SignalBool1Value().Connect( &handler3, &TestSlotHandler::BoolSlotFloatValue );
1749
1750     DALI_TEST_EQUALS( handler2.mHandledCount, 0, TEST_LOCATION );
1751     DALI_TEST_EQUALS( handler3.mHandledCount, 0, TEST_LOCATION );
1752     DALI_TEST_CHECK( ! signals.SignalVoid1Value().Empty() );
1753     DALI_TEST_CHECK( ! signals.SignalBool1Value().Empty() );
1754   }
1755   DALI_TEST_CHECK( signals.SignalVoid1Value().Empty() );
1756   DALI_TEST_CHECK( signals.SignalBool1Value().Empty() );
1757
1758   // Should be NOOP
1759   signals.EmitVoidSignalIntValue( 1 );
1760   signals.EmitBoolSignalFloatValue( 1.0f );
1761
1762   // Test that connecting the same callback 10 times is a NOOP
1763   TestSlotHandler handler4;
1764   DALI_TEST_EQUALS( handler4.mHandledCount, 0, TEST_LOCATION );
1765   DALI_TEST_EQUALS( handler4.mFloatParam1, 0.0f, TEST_LOCATION );
1766
1767   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1768   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1769   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1770   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1771   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1772   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1773   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1774   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1775   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1776   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1777
1778   signals.EmitBoolSignalFloatValue( 2.0f );
1779   DALI_TEST_EQUALS( handler4.mHandledCount, 1, TEST_LOCATION );
1780   DALI_TEST_EQUALS( handler4.mFloatParam1, 2.0f, TEST_LOCATION );
1781
1782   // Calling Disconnect once should be enough
1783   signals.SignalBool1Value().Disconnect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1784   DALI_TEST_CHECK( signals.SignalBool1Value().Empty() );
1785
1786   signals.EmitBoolSignalFloatValue( 3.0f );
1787   DALI_TEST_EQUALS( handler4.mHandledCount, 1/*not incremented since last check*/, TEST_LOCATION );
1788   DALI_TEST_EQUALS( handler4.mFloatParam1, 2.0f, TEST_LOCATION );
1789 }
1790
1791 static void UtcDaliSignalMultipleConnections3()
1792 {
1793   TestSignals signals;
1794
1795   // Test connecting two difference callbacks for the same ConnectionTracker
1796
1797   TestSlotHandler handler1;
1798
1799   {
1800     TestSignals::VoidRet1ValueParamSignal tempSignal;
1801
1802     DALI_TEST_EQUALS( handler1.GetConnectionCount(), 0u, TEST_LOCATION );
1803     DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1804     DALI_TEST_EQUALS( handler1.mIntParam1, 0, TEST_LOCATION );
1805
1806     // Note that the duplicate connection is deliberate
1807     tempSignal.Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1808     tempSignal.Connect( &handler1, &TestSlotHandler::VoidDuplicateSlotIntValue );
1809
1810     DALI_TEST_EQUALS( handler1.GetConnectionCount(), 2u, TEST_LOCATION );
1811     DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1812
1813     tempSignal.Emit( 10 );
1814
1815     DALI_TEST_EQUALS( handler1.mHandledCount, 2, TEST_LOCATION );
1816     DALI_TEST_EQUALS( handler1.mIntParam1, 10, TEST_LOCATION );
1817     DALI_TEST_EQUALS( handler1.mIntParam2, 10, TEST_LOCATION );
1818   }
1819   // End of tempSignal lifetime
1820
1821   DALI_TEST_EQUALS( handler1.GetConnectionCount(), 0u, TEST_LOCATION );
1822 }
1823
1824 bool wasStaticVoidCallbackVoidCalled  = false;
1825 bool wasStaticFloatCallbackVoidCalled = false;
1826 bool wasStaticVoidCallbackIntValueCalled = false;
1827 int staticIntValue = 0;
1828 bool wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1829 float staticFloatValue1 = 0.0f;
1830 float staticFloatValue2 = 0.0f;
1831
1832 static void StaticVoidCallbackVoid()
1833 {
1834   wasStaticVoidCallbackVoidCalled = true;
1835 }
1836
1837 static float StaticFloatCallbackVoid()
1838 {
1839   wasStaticFloatCallbackVoidCalled = true;
1840   return 7.0f;
1841 }
1842
1843 static void StaticVoidCallbackIntValue( int value )
1844 {
1845   wasStaticVoidCallbackIntValueCalled = true;
1846   staticIntValue = value;
1847 }
1848
1849 static float StaticFloatCallbackFloatValueFloatValue( float value1, float value2 )
1850 {
1851   wasStaticFloatCallbackFloatValueFloatValueCalled = true;
1852   staticFloatValue1 = value1;
1853   staticFloatValue2 = value2;
1854   return value1 + value2;
1855 }
1856
1857 static void UtcDaliSignalDisconnectStatic()
1858 {
1859   // void Func()
1860
1861   {
1862     TestSignals::VoidRetNoParamSignal signal;
1863     DALI_TEST_CHECK( signal.Empty() );
1864
1865     signal.Connect( StaticVoidCallbackVoid );
1866     DALI_TEST_CHECK( ! signal.Empty() );
1867
1868     wasStaticVoidCallbackVoidCalled = false;
1869     signal.Emit();
1870     DALI_TEST_EQUALS( wasStaticVoidCallbackVoidCalled, true, TEST_LOCATION );
1871
1872     signal.Disconnect( StaticVoidCallbackVoid );
1873     DALI_TEST_CHECK( signal.Empty() );
1874
1875     wasStaticVoidCallbackVoidCalled = false;
1876     signal.Emit();
1877     DALI_TEST_EQUALS( wasStaticVoidCallbackVoidCalled, false, TEST_LOCATION );
1878   }
1879
1880   // float Func()
1881
1882   {
1883     TestSignals::FloatRet0ParamSignal signal;
1884     DALI_TEST_CHECK( signal.Empty() );
1885
1886     signal.Connect( StaticFloatCallbackVoid );
1887     DALI_TEST_CHECK( ! signal.Empty() );
1888
1889     wasStaticFloatCallbackVoidCalled = false;
1890     float result = signal.Emit();
1891     DALI_TEST_EQUALS( wasStaticFloatCallbackVoidCalled, true, TEST_LOCATION );
1892     DALI_TEST_EQUALS( result, 7.0f, TEST_LOCATION );
1893
1894     signal.Disconnect( StaticFloatCallbackVoid );
1895     DALI_TEST_CHECK( signal.Empty() );
1896
1897     wasStaticFloatCallbackVoidCalled = false;
1898     result = signal.Emit();
1899     DALI_TEST_EQUALS( wasStaticFloatCallbackVoidCalled, false, TEST_LOCATION );
1900     DALI_TEST_EQUALS( result, 0.0f, TEST_LOCATION );
1901   }
1902
1903   // void Func( int )
1904
1905   {
1906     TestSignals::VoidRet1ValueParamSignal signal;
1907     DALI_TEST_CHECK( signal.Empty() );
1908
1909     signal.Connect( StaticVoidCallbackIntValue );
1910     DALI_TEST_CHECK( ! signal.Empty() );
1911
1912     wasStaticVoidCallbackIntValueCalled = false;
1913     staticIntValue = 0;
1914     signal.Emit( 10 );
1915     DALI_TEST_EQUALS( wasStaticVoidCallbackIntValueCalled, true, TEST_LOCATION );
1916     DALI_TEST_EQUALS( staticIntValue, 10, TEST_LOCATION );
1917
1918     signal.Disconnect( StaticVoidCallbackIntValue );
1919     DALI_TEST_CHECK( signal.Empty() );
1920
1921     wasStaticVoidCallbackIntValueCalled = false;
1922     staticIntValue = 0;
1923     signal.Emit( 11 );
1924     DALI_TEST_EQUALS( wasStaticVoidCallbackIntValueCalled, false, TEST_LOCATION );
1925     DALI_TEST_EQUALS( staticIntValue, 0, TEST_LOCATION );
1926   }
1927
1928   // float Func( float, float )
1929
1930   {
1931     TestSignals::FloatRet2ValueParamSignal signal;
1932     DALI_TEST_CHECK( signal.Empty() );
1933
1934     signal.Connect( StaticFloatCallbackFloatValueFloatValue );
1935     DALI_TEST_CHECK( ! signal.Empty() );
1936
1937     wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1938     staticFloatValue1 = 0.0f;
1939     staticFloatValue2 = 0.0f;
1940     float result = signal.Emit( 5.0f, 6.0f );
1941     DALI_TEST_EQUALS( wasStaticFloatCallbackFloatValueFloatValueCalled, true, TEST_LOCATION );
1942     DALI_TEST_EQUALS( staticFloatValue1, 5.0f, TEST_LOCATION );
1943     DALI_TEST_EQUALS( staticFloatValue2, 6.0f, TEST_LOCATION );
1944     DALI_TEST_EQUALS( result, 5.0f+6.0f, TEST_LOCATION );
1945
1946     signal.Disconnect( StaticFloatCallbackFloatValueFloatValue );
1947     DALI_TEST_CHECK( signal.Empty() );
1948
1949     wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1950     staticFloatValue1 = 0.0f;
1951     staticFloatValue2 = 0.0f;
1952     result = signal.Emit( 7.0f, 8.0f );
1953     DALI_TEST_EQUALS( wasStaticFloatCallbackFloatValueFloatValueCalled, false, TEST_LOCATION );
1954     DALI_TEST_EQUALS( staticFloatValue1, 0.0f, TEST_LOCATION );
1955     DALI_TEST_EQUALS( staticFloatValue2, 0.0f, TEST_LOCATION );
1956     DALI_TEST_EQUALS( result, 0.0f, TEST_LOCATION );
1957   }
1958 }
1959
1960 static void UtcDaliSignalDisconnectDuringCallback()
1961 {
1962   // Test disconnection during each callback
1963
1964   TestSignals::VoidRetNoParamSignal signal;
1965   DALI_TEST_CHECK( signal.Empty() );
1966
1967   TestSlotDisconnector handler1;
1968   handler1.VoidConnectVoid( signal );
1969   DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1970   DALI_TEST_CHECK( ! signal.Empty() );
1971
1972   signal.Emit();
1973   DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1974   DALI_TEST_CHECK( signal.Empty() );
1975
1976   // Repeat with 2 callbacks
1977
1978   handler1.mHandled = false;
1979
1980   TestSlotDisconnector handler2;
1981   handler1.VoidConnectVoid( signal );
1982   handler2.VoidConnectVoid( signal );
1983   DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1984   DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1985   DALI_TEST_CHECK( ! signal.Empty() );
1986
1987   signal.Emit();
1988   DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1989   DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1990   DALI_TEST_CHECK( signal.Empty() );
1991
1992   // Repeat with no callbacks
1993
1994   handler1.mHandled = false;
1995   handler2.mHandled = false;
1996
1997   signal.Emit();
1998   DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1999   DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
2000
2001   // Repeat with 3 callbacks
2002
2003   TestSlotDisconnector handler3;
2004   handler1.VoidConnectVoid( signal );
2005   handler2.VoidConnectVoid( signal );
2006   handler3.VoidConnectVoid( signal );
2007   DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
2008   DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
2009   DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
2010   DALI_TEST_CHECK( ! signal.Empty() );
2011
2012   signal.Emit();
2013   DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
2014   DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
2015   DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
2016   DALI_TEST_CHECK( signal.Empty() );
2017
2018   // Repeat with no callbacks
2019
2020   handler1.mHandled = false;
2021   handler2.mHandled = false;
2022   handler3.mHandled = false;
2023
2024   signal.Emit();
2025   DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
2026   DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
2027   DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
2028 }
2029
2030 static void UtcDaliSignalDisconnectDuringCallback2()
2031 {
2032   // Test disconnection of some (but not all) callbacks during sigmal emission
2033
2034   TestSignals::VoidRetNoParamSignal signal;
2035   DALI_TEST_CHECK( signal.Empty() );
2036
2037   TestSlotMultiDisconnector handler;
2038   handler.ConnectAll( signal );
2039   DALI_TEST_EQUALS( handler.mSlotHandled[0], false, TEST_LOCATION );
2040   DALI_TEST_EQUALS( handler.mSlotHandled[1], false, TEST_LOCATION );
2041   DALI_TEST_EQUALS( handler.mSlotHandled[2], false, TEST_LOCATION );
2042   DALI_TEST_EQUALS( handler.mSlotHandled[3], false, TEST_LOCATION );
2043   DALI_TEST_EQUALS( handler.mSlotHandled[4], false, TEST_LOCATION );
2044   DALI_TEST_EQUALS( handler.mSlotHandled[5], false, TEST_LOCATION );
2045   DALI_TEST_EQUALS( handler.mSlotHandled[6], false, TEST_LOCATION );
2046   DALI_TEST_EQUALS( handler.mSlotHandled[7], false, TEST_LOCATION );
2047   DALI_TEST_EQUALS( handler.mSlotHandled[8], false, TEST_LOCATION );
2048   DALI_TEST_EQUALS( handler.mSlotHandled[9], false, TEST_LOCATION );
2049   DALI_TEST_CHECK( ! signal.Empty() );
2050
2051   signal.Emit();
2052
2053   // Slots 5, 7, & 9 should be disconnected before being called
2054   DALI_TEST_EQUALS( handler.mSlotHandled[0], true, TEST_LOCATION );
2055   DALI_TEST_EQUALS( handler.mSlotHandled[1], true, TEST_LOCATION );
2056   DALI_TEST_EQUALS( handler.mSlotHandled[2], true, TEST_LOCATION );
2057   DALI_TEST_EQUALS( handler.mSlotHandled[3], true, TEST_LOCATION );
2058   DALI_TEST_EQUALS( handler.mSlotHandled[4], true, TEST_LOCATION );
2059   DALI_TEST_EQUALS( handler.mSlotHandled[5], false, TEST_LOCATION );
2060   DALI_TEST_EQUALS( handler.mSlotHandled[6], true, TEST_LOCATION );
2061   DALI_TEST_EQUALS( handler.mSlotHandled[7], false, TEST_LOCATION );
2062   DALI_TEST_EQUALS( handler.mSlotHandled[8], true, TEST_LOCATION );
2063   DALI_TEST_EQUALS( handler.mSlotHandled[9], false, TEST_LOCATION );
2064   DALI_TEST_CHECK( ! signal.Empty() );
2065
2066   // Odd slots are disconnected
2067   DALI_TEST_EQUALS( handler.GetConnectionCount(), 5u, TEST_LOCATION );
2068 }
2069
2070 static void UtcDaliSignalEmitDuringCallback()
2071 {
2072   TestApplication app; // Create core for debug logging
2073
2074   TestSignals::VoidRetNoParamSignal signal;
2075   DALI_TEST_CHECK( signal.Empty() );
2076
2077   TestEmitDuringCallback handler1;
2078   handler1.VoidConnectVoid( signal );
2079
2080   // Test that this does not result in an infinite loop!
2081   signal.Emit();
2082 }
2083
2084 static void UtcDaliSignalTestApp01()
2085 {
2086   // Test 1 signal connected to 1 Slot.
2087   // Signal dies first.
2088
2089   TestButton* button = new TestButton(1);
2090   TestApp app;
2091   button->DownSignal().Connect(&app,&TestApp::OnButtonPress);
2092
2093   // check we have both the button, and the app have 1 connection
2094   DALI_TEST_EQUALS( app.GetConnectionCount(), 1u, TEST_LOCATION );
2095   DALI_TEST_EQUALS( button->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2096
2097   delete button;  // should automatically destroy the connection
2098
2099   // check we have a 0 connections
2100   DALI_TEST_EQUALS( app.GetConnectionCount(), 0u, TEST_LOCATION );
2101
2102 }
2103 static void UtcDaliSignalTestApp02()
2104 {
2105   // Test 1 signal connected to 1 Slot.
2106   // Slot owning object dies first.
2107
2108   TestButton button(1);
2109   TestApp *app = new TestApp;
2110   button.DownSignal().Connect( app, &TestApp::OnButtonPress);
2111
2112   // check we have a 1 connection
2113   DALI_TEST_EQUALS( app->GetConnectionCount(), 1u, TEST_LOCATION );
2114   DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2115
2116   delete app;  // should automatically destroy the connection
2117
2118   // check we have a 0 connections
2119   DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION );
2120 }
2121
2122 static void UtcDaliSignalTestApp03()
2123 {
2124   // Test 1 Signal connect to 2 slots
2125   // 1 of the slot owners dies. Then the second slot owner dies
2126
2127   TestButton button(1);
2128   TestApp *app1 = new TestApp;
2129   TestApp *app2 = new TestApp;
2130
2131   button.DownSignal().Connect( app1, &TestApp::OnButtonPress);
2132   button.DownSignal().Connect( app2, &TestApp::OnButtonPress);
2133
2134     // check we have a 2 connections to the signal
2135   DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 2u, TEST_LOCATION );
2136
2137   // kill the first slot
2138   delete app1;  // should automatically destroy the connection
2139
2140   // check we have 1 connection left
2141   DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2142
2143   button.Press();   // emit the signal (to ensure it doesn't seg fault)
2144
2145   // kill the second slot
2146   delete app2;  // should automatically destroy the connection
2147
2148   // check we have 1 connection left
2149   DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION );
2150
2151 }
2152 static void UtcDaliSignalTestApp04()
2153 {
2154   // Test 1 Signal connected to 2 slots (with different owners)
2155   // The Signal dies, check the 2 slots disconnect automatically
2156
2157   TestButton* button = new TestButton(1);
2158   TestApp app1;
2159   TestApp app2;
2160
2161   button->DownSignal().Connect(&app1,&TestApp::OnButtonPress);
2162   button->DownSignal().Connect(&app2,&TestApp::OnButtonPress);
2163
2164   // check the connection counts
2165   DALI_TEST_EQUALS( app1.GetConnectionCount(), 1u, TEST_LOCATION );
2166   DALI_TEST_EQUALS( app2.GetConnectionCount(), 1u, TEST_LOCATION );
2167   DALI_TEST_EQUALS( button->DownSignal().GetConnectionCount(), 2u, TEST_LOCATION );
2168
2169   delete button;  // should automatically destroy the connection
2170
2171   // check both slot owners have zero connections
2172   DALI_TEST_EQUALS( app1.GetConnectionCount(), 0u, TEST_LOCATION );
2173   DALI_TEST_EQUALS( app2.GetConnectionCount(), 0u, TEST_LOCATION );
2174 }
2175
2176 static void UtcDaliSignalTestApp05()
2177 {
2178   // Test 2 Signals (with different owners)  connected to 1 slots
2179   // 1 Signal dies, check that the remaining connection is valid
2180
2181   TestButton* button1 = new TestButton(1); // use for signal 1
2182   TestButton* button2 = new TestButton(2); // use for signal 2
2183
2184   TestApp app;
2185
2186   button1->DownSignal().Connect(&app,&TestApp::OnButtonPress);
2187   button2->DownSignal().Connect(&app,&TestApp::OnButtonPress);
2188
2189   // check the connection counts
2190   DALI_TEST_EQUALS( app.GetConnectionCount(), 2u, TEST_LOCATION );
2191   DALI_TEST_EQUALS( button1->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2192   DALI_TEST_EQUALS( button2->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2193
2194   // make sure both signals emit ok
2195   button2->Press();
2196   DALI_TEST_EQUALS( app.GetButtonPressedId() , 2 , TEST_LOCATION );
2197
2198   button1->Press();
2199   DALI_TEST_EQUALS( app.GetButtonPressedId() , 1 , TEST_LOCATION );
2200
2201   delete button1;  // should automatically destroy 1 connection
2202
2203   // check both slot owners have zero connections
2204   DALI_TEST_EQUALS( app.GetConnectionCount(), 1u, TEST_LOCATION );
2205
2206   // check remaining connection still works
2207   button2->Press();
2208   DALI_TEST_EQUALS( app.GetButtonPressedId() , 2 , TEST_LOCATION );
2209
2210   // kill the last signal
2211   delete button2;
2212   DALI_TEST_EQUALS( app.GetConnectionCount(), 0u, TEST_LOCATION );
2213 }
2214
2215 static void UtcDaliSignalTestApp06()
2216 {
2217   SignalV2< bool () > boolSignal;
2218   TestApp app;
2219   bool result(false);
2220
2221   // connect a slot which will return false
2222   boolSignal.Connect( &app, &TestApp::BoolReturnTestFalse);
2223   result = boolSignal.Emit();
2224   DALI_TEST_EQUALS( result, false, TEST_LOCATION );
2225
2226   // disconnect last slot, and connect a slot which returns true
2227   boolSignal.Disconnect( &app, &TestApp::BoolReturnTestFalse);
2228   boolSignal.Connect( &app, &TestApp::BoolReturnTestTrue);
2229   result = boolSignal.Emit();
2230   DALI_TEST_EQUALS( result, true, TEST_LOCATION );
2231 }
2232
2233 static void UtcDaliSlotDelegateConnection()
2234 {
2235   TestSignals signals;
2236
2237   {
2238     TestSlotDelegateHandler handlers;
2239     signals.SignalVoidNone().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
2240     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2241     signals.EmitVoidSignalVoid();
2242     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2243
2244     // Test double emission
2245     handlers.mHandled = false;
2246     signals.EmitVoidSignalVoid();
2247     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2248   }
2249   signals.CheckNoConnections();
2250
2251   {
2252     TestSlotDelegateHandler handlers;
2253     signals.SignalVoid1Ref().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef );
2254     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2255     int x = 7;
2256     signals.EmitVoidSignalIntRef(x);
2257     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2258     DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
2259   }
2260   signals.CheckNoConnections();
2261
2262   {
2263     TestSlotDelegateHandler handlers;
2264     signals.SignalVoid1Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue );
2265     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2266     signals.EmitVoidSignalIntValue(5);
2267     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2268     DALI_TEST_EQUALS( handlers.mIntParam1, 5, TEST_LOCATION );
2269   }
2270   signals.CheckNoConnections();
2271
2272   {
2273     TestSlotDelegateHandler handlers;
2274     signals.SignalVoid2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue );
2275     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2276     signals.EmitVoidSignalIntValueIntValue(6, 7);
2277     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2278     DALI_TEST_EQUALS( handlers.mIntParam1, 6, TEST_LOCATION );
2279     DALI_TEST_EQUALS( handlers.mIntParam2, 7, TEST_LOCATION );
2280   }
2281   signals.CheckNoConnections();
2282
2283   {
2284     TestSlotDelegateHandler handlers;
2285     signals.SignalBool1Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue );
2286     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2287
2288     handlers.mBoolReturn = true;
2289     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION );
2290     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2291     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2292
2293     // repeat with opposite return value
2294     handlers.mBoolReturn = false;
2295     handlers.mHandled = false;
2296     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION );
2297     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2298     DALI_TEST_EQUALS( handlers.mFloatParam1, 6.0f, TEST_LOCATION );
2299   }
2300   signals.CheckNoConnections();
2301
2302   {
2303     TestSlotDelegateHandler handlers;
2304     signals.SignalBool2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue );
2305     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2306     handlers.mBoolReturn = true;
2307     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION );
2308     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2309     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2310     DALI_TEST_EQUALS( handlers.mIntParam2, 10, TEST_LOCATION );
2311   }
2312   signals.CheckNoConnections();
2313
2314   {
2315     TestSlotDelegateHandler handlers;
2316     signals.SignalInt2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue );
2317     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2318     handlers.mIntReturn = 27;
2319     int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
2320     DALI_TEST_EQUALS( x, 27, TEST_LOCATION );
2321     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2322     DALI_TEST_EQUALS( handlers.mFloatParam1, 33.5f, TEST_LOCATION );
2323     DALI_TEST_EQUALS( handlers.mIntParam2, 5, TEST_LOCATION );
2324   }
2325   signals.CheckNoConnections();
2326
2327   {
2328     TestSlotDelegateHandler handlers;
2329     signals.SignalFloat0().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid );
2330     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2331     handlers.mFloatReturn = 27.0f;
2332     float f = signals.EmitFloat0Signal();
2333     DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
2334     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2335     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
2336     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2337   }
2338   signals.CheckNoConnections();
2339
2340   {
2341     TestSlotDelegateHandler handlers;
2342     signals.SignalFloat2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue );
2343     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2344     handlers.mFloatReturn = 27.0f;
2345     float f = signals.EmitFloat2VSignal(5, 33.0f);
2346     DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
2347     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2348     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2349     DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
2350   }
2351   signals.CheckNoConnections();
2352
2353   {
2354     TestSlotDelegateHandler handlers;
2355     signals.VoidSignalFloatValue3().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotFloatValue3 );
2356     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2357     signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
2358     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2359     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2360     DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
2361     DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
2362   }
2363   signals.CheckNoConnections();
2364
2365   {
2366     TestSlotDelegateHandler handlers;
2367     signals.FloatSignalFloatValue3().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValue3 );
2368     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2369     handlers.mFloatReturn = 27.0f;
2370     float returnValue = signals.EmitFloatSignalFloatValue3(5, 33.0f, 100.0f);
2371     DALI_TEST_EQUALS( returnValue, 27.0f, TEST_LOCATION );
2372     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2373     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2374     DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
2375     DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
2376   }
2377   signals.CheckNoConnections();
2378 }
2379
2380 static void UtcDaliSignalSlotDelegateDestruction()
2381 {
2382   // Test that signal disconnect works when slot-delegate is destroyed (goes out of scope)
2383
2384   {
2385     TestSignals::VoidRetNoParamSignal signal;
2386     {
2387       DALI_TEST_CHECK( signal.Empty() );
2388       TestSlotDelegateHandler handler;
2389       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
2390       DALI_TEST_CHECK( ! signal.Empty() );
2391     }
2392     // End of slot lifetime
2393     DALI_TEST_CHECK( signal.Empty() );
2394
2395     // Signal emission should be a NOOP
2396     signal.Emit();
2397   }
2398
2399   {
2400     TestSignals::VoidRet1ValueParamSignal signal;
2401     {
2402       DALI_TEST_CHECK( signal.Empty() );
2403       TestSlotDelegateHandler handler;
2404       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue );
2405       DALI_TEST_CHECK( ! signal.Empty() );
2406     }
2407     // End of slot lifetime
2408     DALI_TEST_CHECK( signal.Empty() );
2409
2410     // Signal emission should be a NOOP
2411     signal.Emit( 10 );
2412   }
2413
2414   {
2415     TestSignals::VoidRet1RefParamSignal signal;
2416     {
2417       DALI_TEST_CHECK( signal.Empty() );
2418       TestSlotDelegateHandler handler;
2419       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef );
2420       DALI_TEST_CHECK( ! signal.Empty() );
2421     }
2422     // End of slot lifetime
2423     DALI_TEST_CHECK( signal.Empty() );
2424
2425     // Signal emission should be a NOOP
2426     int temp( 5 );
2427     signal.Emit( temp );
2428   }
2429
2430   {
2431     TestSignals::VoidRet2ValueParamSignal signal;
2432     {
2433       DALI_TEST_CHECK( signal.Empty() );
2434       TestSlotDelegateHandler handler;
2435       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue );
2436       DALI_TEST_CHECK( ! signal.Empty() );
2437     }
2438     // End of slot lifetime
2439     DALI_TEST_CHECK( signal.Empty() );
2440
2441     // Signal emission should be a NOOP
2442     signal.Emit( 1, 2 );
2443   }
2444
2445   {
2446     TestSignals::BoolRet1ValueParamSignal signal;
2447     {
2448       DALI_TEST_CHECK( signal.Empty() );
2449       TestSlotDelegateHandler handler;
2450       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue );
2451       DALI_TEST_CHECK( ! signal.Empty() );
2452     }
2453     // End of slot lifetime
2454     DALI_TEST_CHECK( signal.Empty() );
2455
2456     // Signal emission should be a NOOP
2457     bool blah = signal.Emit( 1.0f );
2458     DALI_TEST_CHECK( ! blah );
2459   }
2460
2461   {
2462     TestSignals::BoolRet2ValueParamSignal signal;
2463     {
2464       DALI_TEST_CHECK( signal.Empty() );
2465       TestSlotDelegateHandler handler;
2466       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue );
2467       DALI_TEST_CHECK( ! signal.Empty() );
2468     }
2469     // End of slot lifetime
2470     DALI_TEST_CHECK( signal.Empty() );
2471
2472     // Signal emission should be a NOOP
2473     bool blah = signal.Emit( 1.0f, 2 );
2474     DALI_TEST_CHECK( ! blah );
2475   }
2476
2477   {
2478     TestSignals::IntRet2ValueParamSignal signal;
2479     {
2480       DALI_TEST_CHECK( signal.Empty() );
2481       TestSlotDelegateHandler handler;
2482       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue );
2483       DALI_TEST_CHECK( ! signal.Empty() );
2484     }
2485     // End of slot lifetime
2486     DALI_TEST_CHECK( signal.Empty() );
2487
2488     // Signal emission should be a NOOP
2489     int blah = signal.Emit( 10.0f, 100 );
2490     DALI_TEST_CHECK( 0 == blah );
2491   }
2492
2493   {
2494     TestSignals::FloatRet0ParamSignal signal;
2495     {
2496       DALI_TEST_CHECK( signal.Empty() );
2497       TestSlotDelegateHandler handler;
2498       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid );
2499       DALI_TEST_CHECK( ! signal.Empty() );
2500     }
2501     // End of slot lifetime
2502     DALI_TEST_CHECK( signal.Empty() );
2503
2504     // Signal emission should be a NOOP
2505     float blah = signal.Emit();
2506     DALI_TEST_CHECK( 0.0f == blah );
2507   }
2508
2509   {
2510     TestSignals::FloatRet2ValueParamSignal signal;
2511     {
2512       DALI_TEST_CHECK( signal.Empty() );
2513       TestSlotDelegateHandler handler;
2514       signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2515       DALI_TEST_CHECK( ! signal.Empty() );
2516     }
2517     // End of slot lifetime
2518     DALI_TEST_CHECK( signal.Empty() );
2519
2520     // Signal emission should be a NOOP
2521     float blah = signal.Emit( 3.0f, 4.0f );
2522     DALI_TEST_CHECK( 0.0f == blah );
2523   }
2524 }
2525
2526 static void UtcDaliSlotHandlerDisconnect()
2527 {
2528   // Test that callbacks don't occur if a signal is disconnected before emission
2529
2530   TestSignals signals;
2531
2532   {
2533     TestSlotDelegateHandler handlers;
2534     signals.SignalVoidNone().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
2535     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2536     signals.SignalVoidNone().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
2537     signals.EmitVoidSignalVoid();
2538     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2539   }
2540
2541   {
2542     TestSlotDelegateHandler handlers;
2543     signals.SignalVoid1Ref().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
2544     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2545     int r = 7;
2546     handlers.mIntReturn = 5;
2547     signals.SignalVoid1Ref().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
2548     signals.EmitVoidSignalIntRef(r);
2549     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2550     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2551     DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
2552   }
2553
2554   {
2555     TestSlotDelegateHandler handlers;
2556     signals.SignalVoid1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
2557     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2558     signals.SignalVoid1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
2559     signals.EmitVoidSignalIntValue(5);
2560     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2561     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2562   }
2563
2564   {
2565     TestSlotDelegateHandler handlers;
2566     signals.SignalVoid2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
2567     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2568     signals.SignalVoid2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
2569     signals.EmitVoidSignalIntValueIntValue(5, 10);
2570     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2571     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2572     DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
2573   }
2574
2575   {
2576     TestSlotDelegateHandler handlers;
2577     signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2578     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2579     handlers.mBoolReturn = true;
2580     signals.SignalBool1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2581     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
2582     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2583     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
2584   }
2585
2586   {
2587     TestSlotDelegateHandler handlers;
2588     signals.SignalBool2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2589     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2590     handlers.mBoolReturn = true;
2591     signals.SignalBool2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2592     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
2593     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2594     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
2595     DALI_TEST_EQUALS( handlers.mIntParam2,   0, TEST_LOCATION );
2596   }
2597
2598   {
2599     TestSlotDelegateHandler handlers;
2600     signals.SignalInt2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2601     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2602     handlers.mIntReturn = 27;
2603     signals.SignalInt2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2604     signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
2605     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2606     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2607     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2608   }
2609
2610   {
2611     TestSlotDelegateHandler handlers;
2612     signals.SignalFloat0().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2613     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2614     handlers.mFloatReturn = 27.0f;
2615     signals.SignalFloat0().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2616     signals.EmitFloat0Signal();
2617     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2618     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
2619     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2620   }
2621
2622   {
2623     TestSlotDelegateHandler handlers;
2624     signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2625     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2626     handlers.mFloatReturn = 27.0f;
2627     signals.SignalFloat2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2628     signals.EmitFloat2VSignal(5, 33.0f);
2629     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2630     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
2631     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2632   }
2633 }