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

   1 #ifndef SIGNAL_HELPER
   2 #define SIGNAL_HELPER
   3
   4 /*
   5  * Copyright (c) 2021 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 DeleteDuringEmitConnect(TestSignals::FloatRet0ParamSignal& signal)
 724   {
 725     mFloatRet0ParamSignal = &signal;
 726     signal.Connect(this, &TestEmitDuringCallback::DeleteRetSignalDuringEmit);
 727   }
 728
 729   void VoidSlotVoid()
 730   {
 731     // Emitting during Emit is very bad!
 732     mVoidSignalVoid->Emit();
 733     mHandled = true;
 734   }
 735
 736   void DeleteSignalDuringEmit()
 737   {
 738     // deleting the signal during the emit
 739     delete mVoidSignalVoid;
 740   }
 741
 742   float DeleteRetSignalDuringEmit()
 743   {
 744     // deleting the signal during the emit
 745     delete mFloatRet0ParamSignal;
 746     return 0.0f;
 747   }
 748
 749   float FloatRet0Param()
 750   {
 751     // Emitting during Emit is very bad!
 752     mHandled = true;
 753     return mFloatRet0ParamSignal->Emit();
 754   }
 755   float FloatRet1Param(float x)
 756   {
 757     // Emitting during Emit is very bad!
 758     mHandled = true;
 759     return mFloatRet1ParamSignal->Emit(x);
 760   }
 761   float FloatRet2Param(float x, float y)
 762   {
 763     // Emitting during Emit is very bad!
 764     mHandled = true;
 765     return mFloatRet2ParamSignal->Emit(x, y);
 766   }
 767   float FloatRet3Param(float x, float y, float z)
 768   {
 769     // Emitting during Emit is very bad!
 770     mHandled = true;
 771     return mFloatRet3ParamSignal->Emit(x, y, z);
 772   }
 773
 774   TestSignals::VoidRetNoParamSignal*      mVoidSignalVoid;
 775   TestSignals::FloatRet0ParamSignal*      mFloatRet0ParamSignal;
 776   TestSignals::FloatRet1ParamSignal*      mFloatRet1ParamSignal;
 777   TestSignals::FloatRet2ValueParamSignal* mFloatRet2ParamSignal;
 778   TestSignals::FloatRet3ValueParamSignal* mFloatRet3ParamSignal;
 779
 780   bool mHandled;
 781 };
 782
 783 /**
 784  * A version of TestSlotHandler which uses SlotDelegate
 785  */
 786 class TestSlotDelegateHandler // This does not inherit from ConnectionTrackerInterface!
 787 {
 788 public:
 789   TestSlotDelegateHandler()
 790   : mSlotDelegate(this),
 791     mIntParam1(0),
 792     mIntParam2(0),
 793     mIntParam3(0),
 794     mFloatParam1(0.0f),
 795     mFloatParam2(0.0f),
 796     mFloatParam3(0.0f),
 797     mBoolReturn(false),
 798     mIntReturn(0),
 799     mFloatReturn(0.0f),
 800     mHandled(false),
 801     mHandledCount(0)
 802   {
 803   }
 804
 805   void Reset()
 806   {
 807     mIntParam1   = 0;
 808     mIntParam2   = 0;
 809     mIntParam3   = 0;
 810     mFloatParam1 = 0.0f;
 811     mFloatParam2 = 0.0f;
 812     mFloatParam3 = 0.0f;
 813     mBoolReturn  = false;
 814     mIntReturn   = 0;
 815     mFloatReturn = 0.0f;
 816     mHandled     = false;
 817   }
 818
 819   void VoidSlotVoid()
 820   {
 821     mHandled = true;
 822     ++mHandledCount;
 823   }
 824
 825   void AlternativeVoidSlotVoid()
 826   {
 827     mHandled = true;
 828     ++mHandledCount;
 829   }
 830
 831   void VoidSlotIntRef(int& p1)
 832   {
 833     mIntParam1 = p1;
 834     mHandled   = true;
 835     ++mHandledCount;
 836   }
 837
 838   void VoidSlotIntValue(int p1)
 839   {
 840     mIntParam1 = p1;
 841     mHandled   = true;
 842     ++mHandledCount;
 843   }
 844
 845   void VoidDuplicateSlotIntValue(int p1)
 846   {
 847     mIntParam2 = p1;
 848     mHandled   = true;
 849     ++mHandledCount;
 850   }
 851
 852   void VoidSlotIntValueIntValue(int p1, int p2)
 853   {
 854     mIntParam1 = p1;
 855     mIntParam2 = p2;
 856     mHandled   = true;
 857     ++mHandledCount;
 858   }
 859
 860   bool BoolSlotFloatValue(float p1)
 861   {
 862     mFloatParam1 = p1;
 863     mHandled     = true;
 864     ++mHandledCount;
 865     return mBoolReturn;
 866   }
 867
 868   bool BoolSlotFloatValueIntValue(float p1, int p2)
 869   {
 870     mFloatParam1 = p1;
 871     mIntParam2   = p2;
 872     mHandled     = true;
 873     ++mHandledCount;
 874     return mBoolReturn;
 875   }
 876
 877   int IntSlotFloatValueIntValue(float p1, int p2)
 878   {
 879     mFloatParam1 = p1;
 880     mIntParam2   = p2;
 881     mHandled     = true;
 882     ++mHandledCount;
 883     return mIntReturn;
 884   }
 885
 886   float FloatSlotVoid()
 887   {
 888     mHandled = true;
 889     ++mHandledCount;
 890     return mFloatReturn;
 891   }
 892
 893   float FloatSlotFloatValueFloatValue(float p1, float p2)
 894   {
 895     mFloatParam1 = p1;
 896     mFloatParam2 = p2;
 897     mHandled     = true;
 898     ++mHandledCount;
 899     return mFloatReturn;
 900   }
 901
 902   void VoidSlotFloatValue3(float p1, float p2, float p3)
 903   {
 904     mFloatParam1 = p1;
 905     mFloatParam2 = p2;
 906     mFloatParam3 = p3;
 907     mHandled     = true;
 908     ++mHandledCount;
 909   }
 910
 911   float FloatSlotFloatValue3(float p1, float p2, float p3)
 912   {
 913     mFloatParam1 = p1;
 914     mFloatParam2 = p2;
 915     mFloatParam3 = p3;
 916     mHandled     = true;
 917     ++mHandledCount;
 918     return mFloatReturn;
 919   }
 920
 921   SlotDelegate<TestSlotDelegateHandler> mSlotDelegate;
 922
 923   int   mIntParam1, mIntParam2, mIntParam3;
 924   float mFloatParam1, mFloatParam2, mFloatParam3;
 925   bool  mBoolReturn;
 926   int   mIntReturn;
 927   float mFloatReturn;
 928   bool  mHandled;
 929   int   mHandledCount;
 930 };
 931
 932 /**
 933  * Test that reimplmenting ConnectionTrackerInterface actually works.
 934  * This basic connection tracker only allows one callback to be connected.
 935  */
 936 class TestBasicConnectionTrackerInterface : public ConnectionTrackerInterface
 937 {
 938 public:
 939   TestBasicConnectionTrackerInterface()
 940   : mCallbackHandled(false),
 941     mCallback(NULL),
 942     mSlotObserver(NULL)
 943   {
 944   }
 945
 946   ~TestBasicConnectionTrackerInterface()
 947   {
 948     if(mSlotObserver && mCallback)
 949     {
 950       // Notify signal since the slot has been destroyed
 951       mSlotObserver->SlotDisconnected(mCallback);
 952       // mCallback and mSlotObserver are not owned
 953     }
 954   }
 955
 956   /**
 957    * An example slot
 958    */
 959   void VoidSlotVoid()
 960   {
 961     mCallbackHandled = true;
 962   }
 963
 964   /**
 965    * @copydoc ConnectionTrackerInterface::GetConnectionCount
 966    */
 967   virtual std::size_t GetConnectionCount() const
 968   {
 969     if(mCallback)
 970     {
 971       return 1u;
 972     }
 973
 974     return 0u;
 975   }
 976
 977   /**
 978    * @copydoc ConnectionTrackerInterface::SignalConnected
 979    */
 980   virtual void SignalConnected(SlotObserver* slotObserver, CallbackBase* callback)
 981   {
 982     DALI_ASSERT_ALWAYS(NULL == mCallback && "Only one connection supported!");
 983
 984     mCallback     = callback;
 985     mSlotObserver = slotObserver;
 986   }
 987
 988   /**
 989    * @copydoc ConnectionTrackerInterface::SignalDisconnected
 990    */
 991   virtual void SignalDisconnected(SlotObserver* slotObserver, CallbackBase* callback)
 992   {
 993     if(mSlotObserver == slotObserver)
 994     {
 995       mSlotObserver = NULL;
 996       mCallback     = NULL;
 997       // mCallback and mSlotObserver are not owned
 998     }
 999   }
1000
1001   /**
1002    * RemoveNullCallback,
1003    * testing what occurs when we pass a callback that doesn't exist
1004    */
1005   void RemoveNullCallback()
1006   {
1007     mSlotObserver->SlotDisconnected(NULL);
1008   }
1009
1010 private:
1011   TestBasicConnectionTrackerInterface(const TestBasicConnectionTrackerInterface&);            ///< undefined copy constructor
1012   TestBasicConnectionTrackerInterface& operator=(const TestBasicConnectionTrackerInterface&); ///< undefined assignment operator
1013
1014 public:
1015   bool mCallbackHandled;
1016
1017 private:
1018   CallbackBase* mCallback;     ///< callback, has ownership
1019   SlotObserver* mSlotObserver; ///< a pointer to the slot observer (not owned)
1020 };
1021
1022 // for testing static function callbacks
1023 class StaticFunctionHandlers
1024 {
1025 public:
1026   StaticFunctionHandlers()
1027   {
1028     staticFunctionHandled = false;
1029   }
1030   void Reset()
1031   {
1032     staticFunctionHandled = false;
1033   }
1034
1035   static void VoidSlotVoid()
1036   {
1037     staticFunctionHandled = true;
1038   }
1039   static void VoidSlot1Param(int p1)
1040   {
1041     staticFunctionHandled = true;
1042   }
1043   static void VoidSlot2Param(int p1, int p2)
1044   {
1045     staticFunctionHandled = true;
1046   }
1047   static void VoidSlot3Param(int p1, int p2, int p3)
1048   {
1049     staticFunctionHandled = true;
1050   }
1051
1052   static float RetSlot0Param()
1053   {
1054     staticFunctionHandled = true;
1055     return 0;
1056   }
1057   static float RetSlot1Param(float p1)
1058   {
1059     staticFunctionHandled = true;
1060     return 0;
1061   }
1062   static float RetSlot2Param(float p1, float p2)
1063   {
1064     staticFunctionHandled = true;
1065     return 0;
1066   }
1067   static float RetSlot3Param(float p1, float p2, float p3)
1068   {
1069     staticFunctionHandled = true;
1070     return 0;
1071   }
1072
1073   static bool staticFunctionHandled;
1074 };
1075
1076 /**
1077  * test functor, we store a reference to a bool which is outside of the functor
1078  * so when the functor is copied, the copy can reference the original data
1079  */
1080 struct TestFunctor
1081 {
1082   TestFunctor(bool& functorCalled)
1083   : mFunctorCalled(functorCalled){};
1084
1085   void operator()()
1086   {
1087     mFunctorCalled = true;
1088   }
1089
1090   bool& mFunctorCalled;
1091 };
1092
1093 struct VoidFunctorVoid
1094 {
1095   VoidFunctorVoid(bool& functorCalled)
1096   : mFunctorCalled(functorCalled)
1097   {
1098   }
1099
1100   void operator()()
1101   {
1102     mFunctorCalled = true;
1103   }
1104
1105   bool& mFunctorCalled;
1106 };
1107
1108 #endif // #define SIGNAL_HELPER