automated-tests/src/common/signal-helper.h

   1 #ifndef SIGNAL_HELPER
   2 #define SIGNAL_HELPER
   3
   4 /*
   5  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // Helper classes for testing DALi signal and slots
  22
  23 class TestButton
  24 {
  25 public:
  26   TestButton(unsigned int id)
  27   : mId(id)
  28   {
  29   }
  30
  31   void Press()
  32   {
  33     mPanelDown.Emit(*this);
  34   }
  35
  36   void Release()
  37   {
  38     mPanelUp.Emit(*this);
  39   }
  40
  41   typedef Signal<void(TestButton&)> PanelDownSignal;
  42   typedef Signal<void(TestButton&)> PanelUpSignal;
  43
  44   PanelDownSignal& DownSignal()
  45   {
  46     return mPanelDown;
  47   }
  48
  49   PanelUpSignal& SignalUp()
  50   {
  51     return mPanelUp;
  52   }
  53
  54   int GetId()
  55   {
  56     return mId;
  57   }
  58
  59 private:
  60   int             mId;
  61   PanelDownSignal mPanelDown;
  62   PanelUpSignal   mPanelUp;
  63 };
  64
  65 class TestApp : public ConnectionTracker
  66 {
  67 public:
  68   TestApp()
  69   : mButtonPressed(false),
  70     mVoidFunctionCalled(false)
  71   {
  72   }
  73
  74   void OnButtonPress(TestButton& button)
  75   {
  76     mButtonPressed = true;
  77     mButtonId      = button.GetId();
  78   }
  79
  80   void OnButtonRelease(TestButton& button)
  81   {
  82     mButtonPressed = false;
  83     mButtonId      = button.GetId();
  84   }
  85
  86   int GetButtonPressedId()
  87   {
  88     return mButtonId;
  89   }
  90
  91   bool BoolReturnTestFalse()
  92   {
  93     return false;
  94   }
  95
  96   bool BoolReturnTestTrue()
  97   {
  98     return true;
  99   }
 100
 101   void VoidFunction()
 102   {
 103     mVoidFunctionCalled = true;
 104   }
 105
 106   bool mButtonPressed;
 107   bool mVoidFunctionCalled;
 108   int  mButtonId;
 109 };
 110
 111 class TestSignals
 112 {
 113 public:
 114   // Void return, no parameters
 115   typedef Signal<void()> VoidRetNoParamSignal;
 116
 117   // Void return, 1 value parameter
 118   typedef Signal<void(int)> VoidRet1ValueParamSignal;
 119
 120   // Void return, 1 reference parameter
 121   typedef Signal<void(int&)> VoidRet1RefParamSignal;
 122
 123   // Void return, 2 value parameters
 124   typedef Signal<void(int, int)> VoidRet2ValueParamSignal;
 125
 126   // Void return, 3 value parameters
 127   typedef Signal<void(int, int, int)> VoidRet3ValueParamSignal;
 128
 129   // bool return, 1 value parameter
 130   typedef Signal<bool(float)> BoolRet1ValueParamSignal;
 131
 132   // bool return, 2 value parameter
 133   typedef Signal<bool(float, int)> BoolRet2ValueParamSignal;
 134
 135   // int return, 2 value parameter
 136   typedef Signal<int(float, int)> IntRet2ValueParamSignal;
 137
 138   // float return, 0 parameters
 139   typedef Signal<float()> FloatRet0ParamSignal;
 140
 141   // float return, 1 value parameters
 142   typedef Signal<float(float)> FloatRet1ParamSignal;
 143
 144   // float return, 2 value parameters
 145   typedef Signal<float(float, float)> FloatRet2ValueParamSignal;
 146
 147   // float return, 3 value parameters
 148   typedef Signal<float(float, float, float)> FloatRet3ValueParamSignal;
 149
 150   // void return, 3 value parameters
 151   typedef Signal<void(float, float, float)> VoidSignalTypeFloatValue3;
 152
 153   VoidRetNoParamSignal& SignalVoidNone()
 154   {
 155     return mSignalVoid0;
 156   }
 157   VoidRet1RefParamSignal& SignalVoid1Ref()
 158   {
 159     return mSignalVoid1R;
 160   }
 161   VoidRet1ValueParamSignal& SignalVoid1Value()
 162   {
 163     return mSignalVoid1V;
 164   }
 165   VoidRet2ValueParamSignal& SignalVoid2Value()
 166   {
 167     return mSignalVoid2V;
 168   }
 169   VoidRet3ValueParamSignal& SignalVoid3Value()
 170   {
 171     return mSignalVoid3V;
 172   }
 173
 174   BoolRet1ValueParamSignal& SignalBool1Value()
 175   {
 176     return mSignalBool1V;
 177   }
 178   BoolRet2ValueParamSignal& SignalBool2Value()
 179   {
 180     return mSignalBool2V;
 181   }
 182   IntRet2ValueParamSignal& SignalInt2Value()
 183   {
 184     return mSignalInt2V;
 185   }
 186   FloatRet0ParamSignal& SignalFloat0()
 187   {
 188     return mSignalFloat0;
 189   }
 190   FloatRet1ParamSignal& SignalFloat1Value()
 191   {
 192     return mSignalFloat1V;
 193   }
 194   FloatRet2ValueParamSignal& SignalFloat2Value()
 195   {
 196     return mSignalFloat2V;
 197   }
 198
 199   VoidSignalTypeFloatValue3& VoidSignalFloatValue3()
 200   {
 201     return mVoidSignalFloatValue3;
 202   }
 203   FloatRet3ValueParamSignal& SignalFloat3Value()
 204   {
 205     return mFloatSignalFloatValue3;
 206   }
 207
 208   TestSignals()
 209   {
 210   }
 211
 212   void CheckNoConnections()
 213   {
 214     DALI_TEST_EQUALS(mSignalVoid0.GetConnectionCount(), 0u, TEST_LOCATION);
 215     DALI_TEST_EQUALS(mSignalVoid1R.GetConnectionCount(), 0u, TEST_LOCATION);
 216     DALI_TEST_EQUALS(mSignalVoid1V.GetConnectionCount(), 0u, TEST_LOCATION);
 217     DALI_TEST_EQUALS(mSignalVoid2V.GetConnectionCount(), 0u, TEST_LOCATION);
 218     DALI_TEST_EQUALS(mSignalVoid3V.GetConnectionCount(), 0u, TEST_LOCATION);
 219     DALI_TEST_EQUALS(mSignalBool1V.GetConnectionCount(), 0u, TEST_LOCATION);
 220     DALI_TEST_EQUALS(mSignalBool2V.GetConnectionCount(), 0u, TEST_LOCATION);
 221     DALI_TEST_EQUALS(mSignalInt2V.GetConnectionCount(), 0u, TEST_LOCATION);
 222     DALI_TEST_EQUALS(mSignalFloat0.GetConnectionCount(), 0u, TEST_LOCATION);
 223     DALI_TEST_EQUALS(mSignalFloat1V.GetConnectionCount(), 0u, TEST_LOCATION);
 224     DALI_TEST_EQUALS(mSignalFloat2V.GetConnectionCount(), 0u, TEST_LOCATION);
 225     DALI_TEST_EQUALS(mVoidSignalFloatValue3.GetConnectionCount(), 0u, TEST_LOCATION);
 226     DALI_TEST_EQUALS(mFloatSignalFloatValue3.GetConnectionCount(), 0u, TEST_LOCATION);
 227   }
 228
 229   void EmitVoidSignalVoid()
 230   {
 231     mSignalVoid0.Emit();
 232   }
 233
 234   void EmitVoidSignalIntRef(int& ref)
 235   {
 236     mSignalVoid1R.Emit(ref);
 237   }
 238
 239   void EmitVoidSignal1IntValue(int p1)
 240   {
 241     mSignalVoid1V.Emit(p1);
 242   }
 243
 244   void EmitVoidSignal2IntValue(int p1, int p2)
 245   {
 246     mSignalVoid2V.Emit(p1, p2);
 247   }
 248
 249   void EmitVoidSignal3IntValue(int p1, int p2, int p3)
 250   {
 251     mSignalVoid3V.Emit(p1, p2, p3);
 252   }
 253
 254   bool EmitBoolSignalFloatValue(float p1)
 255   {
 256     return mSignalBool1V.Emit(p1);
 257   }
 258
 259   bool EmitBoolSignalFloatValueIntValue(float p1, int p2)
 260   {
 261     return mSignalBool2V.Emit(p1, p2);
 262   }
 263
 264   int EmitIntSignalFloatValueIntValue(float p1, int p2)
 265   {
 266     return mSignalInt2V.Emit(p1, p2);
 267   }
 268
 269   float EmitFloat1VSignal(float p1)
 270   {
 271     return mSignalFloat1V.Emit(p1);
 272   }
 273
 274   float EmitFloat2VSignal(float p1, float p2)
 275   {
 276     return mSignalFloat2V.Emit(p1, p2);
 277   }
 278
 279   float EmitFloat0Signal()
 280   {
 281     return mSignalFloat0.Emit();
 282   }
 283
 284   void EmitVoidSignalFloatValue3(float p1, float p2, float p3)
 285   {
 286     mVoidSignalFloatValue3.Emit(p1, p2, p3);
 287   }
 288
 289   float EmitFloat3VSignal(float p1, float p2, float p3)
 290   {
 291     return mFloatSignalFloatValue3.Emit(p1, p2, p3);
 292   }
 293
 294 private:
 295   VoidRetNoParamSignal     mSignalVoid0;
 296   VoidRet1RefParamSignal   mSignalVoid1R;
 297   VoidRet1ValueParamSignal mSignalVoid1V;
 298   VoidRet2ValueParamSignal mSignalVoid2V;
 299   VoidRet3ValueParamSignal mSignalVoid3V;
 300
 301   BoolRet1ValueParamSignal  mSignalBool1V;
 302   BoolRet2ValueParamSignal  mSignalBool2V;
 303   IntRet2ValueParamSignal   mSignalInt2V;
 304   FloatRet0ParamSignal      mSignalFloat0;
 305   FloatRet1ParamSignal      mSignalFloat1V;
 306   FloatRet2ValueParamSignal mSignalFloat2V;
 307   VoidSignalTypeFloatValue3 mVoidSignalFloatValue3;
 308   FloatRet3ValueParamSignal mFloatSignalFloatValue3;
 309 };
 310
 311 /**
 312  * A helper class with various slots
 313  */
 314 class TestSlotHandler : public ConnectionTracker
 315 {
 316 public:
 317   TestSlotHandler()
 318   : mIntParam1(0),
 319     mIntParam2(0),
 320     mIntParam3(0),
 321     mFloatParam1(0.0f),
 322     mFloatParam2(0.0f),
 323     mFloatParam3(0.0f),
 324     mBoolReturn(false),
 325     mIntReturn(0),
 326     mFloatReturn(0.0f),
 327     mHandled(false),
 328     mHandledCount(0)
 329   {
 330   }
 331
 332   void Reset()
 333   {
 334     mIntParam1   = 0;
 335     mIntParam2   = 0;
 336     mIntParam3   = 0;
 337     mFloatParam1 = 0.0f;
 338     mFloatParam2 = 0.0f;
 339     mFloatParam3 = 0.0f;
 340     mBoolReturn  = false;
 341     mIntReturn   = 0;
 342     mFloatReturn = 0.0f;
 343     mHandled     = false;
 344   }
 345
 346   void VoidSlotVoid()
 347   {
 348     mHandled = true;
 349     ++mHandledCount;
 350   }
 351
 352   void VoidSlotVoidAlternative()
 353   {
 354     mHandled = true;
 355     ++mHandledCount;
 356   }
 357
 358   void VoidSlotIntRef(int& p1)
 359   {
 360     mIntParam1 = p1;
 361     mHandled   = true;
 362     ++mHandledCount;
 363   }
 364
 365   void VoidSlotIntValue(int p1)
 366   {
 367     mIntParam1 = p1;
 368     mHandled   = true;
 369     ++mHandledCount;
 370   }
 371
 372   void VoidDuplicateSlotIntValue(int p1)
 373   {
 374     mIntParam2 = p1;
 375     mHandled   = true;
 376     ++mHandledCount;
 377   }
 378
 379   void VoidSlotIntValueIntValue(int p1, int p2)
 380   {
 381     mIntParam1 = p1;
 382     mIntParam2 = p2;
 383     mHandled   = true;
 384     ++mHandledCount;
 385   }
 386
 387   bool BoolSlotFloatValue(float p1)
 388   {
 389     mFloatParam1 = p1;
 390     mHandled     = true;
 391     ++mHandledCount;
 392     return mBoolReturn;
 393   }
 394
 395   bool BoolSlotFloatValueIntValue(float p1, int p2)
 396   {
 397     mFloatParam1 = p1;
 398     mIntParam2   = p2;
 399     mHandled     = true;
 400     ++mHandledCount;
 401     return mBoolReturn;
 402   }
 403
 404   int IntSlotFloatValueIntValue(float p1, int p2)
 405   {
 406     mFloatParam1 = p1;
 407     mIntParam2   = p2;
 408     mHandled     = true;
 409     ++mHandledCount;
 410     return mIntReturn;
 411   }
 412
 413   float FloatSlotVoid()
 414   {
 415     mHandled = true;
 416     ++mHandledCount;
 417     return mFloatReturn;
 418   }
 419
 420   float FloatSlotFloatValueFloatValue(float p1, float p2)
 421   {
 422     mFloatParam1 = p1;
 423     mFloatParam2 = p2;
 424     mHandled     = true;
 425     ++mHandledCount;
 426     return mFloatReturn;
 427   }
 428
 429   void VoidSlotFloatValue3(float p1, float p2, float p3)
 430   {
 431     mFloatParam1 = p1;
 432     mFloatParam2 = p2;
 433     mFloatParam3 = p3;
 434     mHandled     = true;
 435     ++mHandledCount;
 436   }
 437
 438   float FloatSlotFloatValue3(float p1, float p2, float p3)
 439   {
 440     mFloatParam1 = p1;
 441     mFloatParam2 = p2;
 442     mFloatParam3 = p3;
 443     mHandled     = true;
 444     ++mHandledCount;
 445     return mFloatReturn;
 446   }
 447
 448   int   mIntParam1, mIntParam2, mIntParam3;
 449   float mFloatParam1, mFloatParam2, mFloatParam3;
 450   bool  mBoolReturn;
 451   int   mIntReturn;
 452   float mFloatReturn;
 453   bool  mHandled;
 454   int   mHandledCount;
 455 };
 456
 457 /**
 458  * A version of TestSlotHandler which disconnects during the callback
 459  */
 460 class TestSlotDisconnector : public ConnectionTracker
 461 {
 462 public:
 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   static const int NUM_SLOTS = 10;
 582
 583   TestSlotMultiDisconnector()
 584   : mVoidSignalVoid(NULL)
 585   {
 586     Reset();
 587   }
 588
 589   void Reset()
 590   {
 591     for(int i = 0; i < NUM_SLOTS; ++i)
 592     {
 593       mSlotHandled[i] = false;
 594     }
 595   }
 596
 597   void ConnectAll(TestSignals::VoidRetNoParamSignal& signal)
 598   {
 599     mVoidSignalVoid = &signal;
 600     signal.Connect(this, &TestSlotMultiDisconnector::Slot0);
 601     signal.Connect(this, &TestSlotMultiDisconnector::Slot1);
 602     signal.Connect(this, &TestSlotMultiDisconnector::Slot2);
 603     signal.Connect(this, &TestSlotMultiDisconnector::Slot3);
 604     signal.Connect(this, &TestSlotMultiDisconnector::Slot4);
 605     signal.Connect(this, &TestSlotMultiDisconnector::Slot5);
 606     signal.Connect(this, &TestSlotMultiDisconnector::Slot6);
 607     signal.Connect(this, &TestSlotMultiDisconnector::Slot7);
 608     signal.Connect(this, &TestSlotMultiDisconnector::Slot8);
 609     signal.Connect(this, &TestSlotMultiDisconnector::Slot9);
 610   }
 611
 612   void Slot0()
 613   {
 614     mSlotHandled[0] = true;
 615   }
 616
 617   void Slot1()
 618   {
 619     mSlotHandled[1] = true;
 620   }
 621
 622   void Slot2()
 623   {
 624     mSlotHandled[2] = true;
 625   }
 626
 627   void Slot3()
 628   {
 629     mSlotHandled[3] = true;
 630
 631     // Disconnect the odd numbered lots, because we can
 632     mVoidSignalVoid->Disconnect(this, &TestSlotMultiDisconnector::Slot1);
 633     mVoidSignalVoid->Disconnect(this, &TestSlotMultiDisconnector::Slot3);
 634     mVoidSignalVoid->Disconnect(this, &TestSlotMultiDisconnector::Slot5);
 635     mVoidSignalVoid->Disconnect(this, &TestSlotMultiDisconnector::Slot7);
 636     mVoidSignalVoid->Disconnect(this, &TestSlotMultiDisconnector::Slot9);
 637   }
 638
 639   void Slot4()
 640   {
 641     mSlotHandled[4] = true;
 642   }
 643
 644   void Slot5()
 645   {
 646     mSlotHandled[5] = true;
 647   }
 648
 649   void Slot6()
 650   {
 651     mSlotHandled[6] = true;
 652   }
 653
 654   void Slot7()
 655   {
 656     mSlotHandled[7] = true;
 657   }
 658
 659   void Slot8()
 660   {
 661     mSlotHandled[8] = true;
 662   }
 663
 664   void Slot9()
 665   {
 666     mSlotHandled[9] = true;
 667   }
 668
 669   TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
 670
 671   bool mSlotHandled[NUM_SLOTS];
 672 };
 673
 674 /**
 675  * A version of TestSlotHandler which disconnects during the callback
 676  */
 677 class TestEmitDuringCallback : public ConnectionTracker
 678 {
 679 public:
 680   TestEmitDuringCallback()
 681   : mVoidSignalVoid(NULL),
 682     mFloatRet0ParamSignal(NULL),
 683     mFloatRet1ParamSignal(NULL),
 684     mFloatRet2ParamSignal(NULL),
 685     mFloatRet3ParamSignal(NULL),
 686     mHandled(false)
 687   {
 688   }
 689
 690   void VoidConnectVoid(TestSignals::VoidRetNoParamSignal& signal)
 691   {
 692     mVoidSignalVoid = &signal;
 693     signal.Connect(this, &TestEmitDuringCallback::VoidSlotVoid);
 694   }
 695
 696   void FloatRet0ParamConnect(TestSignals::FloatRet0ParamSignal& signal)
 697   {
 698     mFloatRet0ParamSignal = &signal;
 699     signal.Connect(this, &TestEmitDuringCallback::FloatRet0Param);
 700   }
 701   void FloatRet1ParamConnect(TestSignals::FloatRet1ParamSignal& signal)
 702   {
 703     mFloatRet1ParamSignal = &signal;
 704     signal.Connect(this, &TestEmitDuringCallback::FloatRet1Param);
 705   }
 706   void FloatRet2ParamConnect(TestSignals::FloatRet2ValueParamSignal& signal)
 707   {
 708     mFloatRet2ParamSignal = &signal;
 709     signal.Connect(this, &TestEmitDuringCallback::FloatRet2Param);
 710   }
 711   void FloatRet3ParamConnect(TestSignals::FloatRet3ValueParamSignal& signal)
 712   {
 713     mFloatRet3ParamSignal = &signal;
 714     signal.Connect(this, &TestEmitDuringCallback::FloatRet3Param);
 715   }
 716
 717   void DeleteDuringEmitConnect(TestSignals::VoidRetNoParamSignal& signal)
 718   {
 719     mVoidSignalVoid = &signal;
 720     signal.Connect(this, &TestEmitDuringCallback::DeleteSignalDuringEmit);
 721   }
 722
 723   void VoidSlotVoid()
 724   {
 725     // Emitting during Emit is very bad!
 726     mVoidSignalVoid->Emit();
 727     mHandled = true;
 728   }
 729
 730   void DeleteSignalDuringEmit()
 731   {
 732     // deleting the signal during the emit
 733     delete mVoidSignalVoid;
 734   }
 735
 736   float FloatRet0Param()
 737   {
 738     // Emitting during Emit is very bad!
 739     mHandled = true;
 740     return mFloatRet0ParamSignal->Emit();
 741   }
 742   float FloatRet1Param(float x)
 743   {
 744     // Emitting during Emit is very bad!
 745     mHandled = true;
 746     return mFloatRet1ParamSignal->Emit(x);
 747   }
 748   float FloatRet2Param(float x, float y)
 749   {
 750     // Emitting during Emit is very bad!
 751     mHandled = true;
 752     return mFloatRet2ParamSignal->Emit(x, y);
 753   }
 754   float FloatRet3Param(float x, float y, float z)
 755   {
 756     // Emitting during Emit is very bad!
 757     mHandled = true;
 758     return mFloatRet3ParamSignal->Emit(x, y, z);
 759   }
 760
 761   TestSignals::VoidRetNoParamSignal*      mVoidSignalVoid;
 762   TestSignals::FloatRet0ParamSignal*      mFloatRet0ParamSignal;
 763   TestSignals::FloatRet1ParamSignal*      mFloatRet1ParamSignal;
 764   TestSignals::FloatRet2ValueParamSignal* mFloatRet2ParamSignal;
 765   TestSignals::FloatRet3ValueParamSignal* mFloatRet3ParamSignal;
 766
 767   bool mHandled;
 768 };
 769
 770 /**
 771  * A version of TestSlotHandler which uses SlotDelegate
 772  */
 773 class TestSlotDelegateHandler // This does not inherit from ConnectionTrackerInterface!
 774 {
 775 public:
 776   TestSlotDelegateHandler()
 777   : mSlotDelegate(this),
 778     mIntParam1(0),
 779     mIntParam2(0),
 780     mIntParam3(0),
 781     mFloatParam1(0.0f),
 782     mFloatParam2(0.0f),
 783     mFloatParam3(0.0f),
 784     mBoolReturn(false),
 785     mIntReturn(0),
 786     mFloatReturn(0.0f),
 787     mHandled(false),
 788     mHandledCount(0)
 789   {
 790   }
 791
 792   void Reset()
 793   {
 794     mIntParam1   = 0;
 795     mIntParam2   = 0;
 796     mIntParam3   = 0;
 797     mFloatParam1 = 0.0f;
 798     mFloatParam2 = 0.0f;
 799     mFloatParam3 = 0.0f;
 800     mBoolReturn  = false;
 801     mIntReturn   = 0;
 802     mFloatReturn = 0.0f;
 803     mHandled     = false;
 804   }
 805
 806   void VoidSlotVoid()
 807   {
 808     mHandled = true;
 809     ++mHandledCount;
 810   }
 811
 812   void AlternativeVoidSlotVoid()
 813   {
 814     mHandled = true;
 815     ++mHandledCount;
 816   }
 817
 818   void VoidSlotIntRef(int& p1)
 819   {
 820     mIntParam1 = p1;
 821     mHandled   = true;
 822     ++mHandledCount;
 823   }
 824
 825   void VoidSlotIntValue(int p1)
 826   {
 827     mIntParam1 = p1;
 828     mHandled   = true;
 829     ++mHandledCount;
 830   }
 831
 832   void VoidDuplicateSlotIntValue(int p1)
 833   {
 834     mIntParam2 = p1;
 835     mHandled   = true;
 836     ++mHandledCount;
 837   }
 838
 839   void VoidSlotIntValueIntValue(int p1, int p2)
 840   {
 841     mIntParam1 = p1;
 842     mIntParam2 = p2;
 843     mHandled   = true;
 844     ++mHandledCount;
 845   }
 846
 847   bool BoolSlotFloatValue(float p1)
 848   {
 849     mFloatParam1 = p1;
 850     mHandled     = true;
 851     ++mHandledCount;
 852     return mBoolReturn;
 853   }
 854
 855   bool BoolSlotFloatValueIntValue(float p1, int p2)
 856   {
 857     mFloatParam1 = p1;
 858     mIntParam2   = p2;
 859     mHandled     = true;
 860     ++mHandledCount;
 861     return mBoolReturn;
 862   }
 863
 864   int IntSlotFloatValueIntValue(float p1, int p2)
 865   {
 866     mFloatParam1 = p1;
 867     mIntParam2   = p2;
 868     mHandled     = true;
 869     ++mHandledCount;
 870     return mIntReturn;
 871   }
 872
 873   float FloatSlotVoid()
 874   {
 875     mHandled = true;
 876     ++mHandledCount;
 877     return mFloatReturn;
 878   }
 879
 880   float FloatSlotFloatValueFloatValue(float p1, float p2)
 881   {
 882     mFloatParam1 = p1;
 883     mFloatParam2 = p2;
 884     mHandled     = true;
 885     ++mHandledCount;
 886     return mFloatReturn;
 887   }
 888
 889   void VoidSlotFloatValue3(float p1, float p2, float p3)
 890   {
 891     mFloatParam1 = p1;
 892     mFloatParam2 = p2;
 893     mFloatParam3 = p3;
 894     mHandled     = true;
 895     ++mHandledCount;
 896   }
 897
 898   float FloatSlotFloatValue3(float p1, float p2, float p3)
 899   {
 900     mFloatParam1 = p1;
 901     mFloatParam2 = p2;
 902     mFloatParam3 = p3;
 903     mHandled     = true;
 904     ++mHandledCount;
 905     return mFloatReturn;
 906   }
 907
 908   SlotDelegate<TestSlotDelegateHandler> mSlotDelegate;
 909
 910   int   mIntParam1, mIntParam2, mIntParam3;
 911   float mFloatParam1, mFloatParam2, mFloatParam3;
 912   bool  mBoolReturn;
 913   int   mIntReturn;
 914   float mFloatReturn;
 915   bool  mHandled;
 916   int   mHandledCount;
 917 };
 918
 919 /**
 920  * Test that reimplmenting ConnectionTrackerInterface actually works.
 921  * This basic connection tracker only allows one callback to be connected.
 922  */
 923 class TestBasicConnectionTrackerInterface : public ConnectionTrackerInterface
 924 {
 925 public:
 926   TestBasicConnectionTrackerInterface()
 927   : mCallbackHandled(false),
 928     mCallback(NULL),
 929     mSlotObserver(NULL)
 930   {
 931   }
 932
 933   ~TestBasicConnectionTrackerInterface()
 934   {
 935     if(mSlotObserver && mCallback)
 936     {
 937       // Notify signal since the slot has been destroyed
 938       mSlotObserver->SlotDisconnected(mCallback);
 939       // mCallback and mSlotObserver are not owned
 940     }
 941   }
 942
 943   /**
 944    * An example slot
 945    */
 946   void VoidSlotVoid()
 947   {
 948     mCallbackHandled = true;
 949   }
 950
 951   /**
 952    * @copydoc ConnectionTrackerInterface::GetConnectionCount
 953    */
 954   virtual std::size_t GetConnectionCount() const
 955   {
 956     if(mCallback)
 957     {
 958       return 1u;
 959     }
 960
 961     return 0u;
 962   }
 963
 964   /**
 965    * @copydoc ConnectionTrackerInterface::SignalConnected
 966    */
 967   virtual void SignalConnected(SlotObserver* slotObserver, CallbackBase* callback)
 968   {
 969     DALI_ASSERT_ALWAYS(NULL == mCallback && "Only one connection supported!");
 970
 971     mCallback     = callback;
 972     mSlotObserver = slotObserver;
 973   }
 974
 975   /**
 976    * @copydoc ConnectionTrackerInterface::SignalDisconnected
 977    */
 978   virtual void SignalDisconnected(SlotObserver* slotObserver, CallbackBase* callback)
 979   {
 980     if(mSlotObserver == slotObserver)
 981     {
 982       mSlotObserver = NULL;
 983       mCallback     = NULL;
 984       // mCallback and mSlotObserver are not owned
 985     }
 986   }
 987
 988   /**
 989    * RemoveNullCallback,
 990    * testing what occurs when we pass a callback that doesn't exist
 991    */
 992   void RemoveNullCallback()
 993   {
 994     mSlotObserver->SlotDisconnected(NULL);
 995   }
 996
 997 private:
 998   TestBasicConnectionTrackerInterface(const TestBasicConnectionTrackerInterface&);            ///< undefined copy constructor
 999   TestBasicConnectionTrackerInterface& operator=(const TestBasicConnectionTrackerInterface&); ///< undefined assignment operator
1000
1001 public:
1002   bool mCallbackHandled;
1003
1004 private:
1005   CallbackBase* mCallback;     ///< callback, has ownership
1006   SlotObserver* mSlotObserver; ///< a pointer to the slot observer (not owned)
1007 };
1008
1009 // for testing static function callbacks
1010 class StaticFunctionHandlers
1011 {
1012 public:
1013   StaticFunctionHandlers()
1014   {
1015     staticFunctionHandled = false;
1016   }
1017   void Reset()
1018   {
1019     staticFunctionHandled = false;
1020   }
1021
1022   static void VoidSlotVoid()
1023   {
1024     staticFunctionHandled = true;
1025   }
1026   static void VoidSlot1Param(int p1)
1027   {
1028     staticFunctionHandled = true;
1029   }
1030   static void VoidSlot2Param(int p1, int p2)
1031   {
1032     staticFunctionHandled = true;
1033   }
1034   static void VoidSlot3Param(int p1, int p2, int p3)
1035   {
1036     staticFunctionHandled = true;
1037   }
1038
1039   static float RetSlot0Param()
1040   {
1041     staticFunctionHandled = true;
1042     return 0;
1043   }
1044   static float RetSlot1Param(float p1)
1045   {
1046     staticFunctionHandled = true;
1047     return 0;
1048   }
1049   static float RetSlot2Param(float p1, float p2)
1050   {
1051     staticFunctionHandled = true;
1052     return 0;
1053   }
1054   static float RetSlot3Param(float p1, float p2, float p3)
1055   {
1056     staticFunctionHandled = true;
1057     return 0;
1058   }
1059
1060   static bool staticFunctionHandled;
1061 };
1062
1063 /**
1064  * test functor, we store a reference to a bool which is outside of the functor
1065  * so when the functor is copied, the copy can reference the original data
1066  */
1067 struct TestFunctor
1068 {
1069   TestFunctor(bool& functorCalled)
1070   : mFunctorCalled(functorCalled){};
1071
1072   void operator()()
1073   {
1074     mFunctorCalled = true;
1075   }
1076
1077   bool& mFunctorCalled;
1078 };
1079
1080 struct VoidFunctorVoid
1081 {
1082   VoidFunctorVoid(bool& functorCalled)
1083   : mFunctorCalled(functorCalled)
1084   {
1085   }
1086
1087   void operator()()
1088   {
1089     mFunctorCalled = true;
1090   }
1091
1092   bool& mFunctorCalled;
1093 };
1094
1095 #endif // #define SIGNAL_HELPER