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

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