automated-tests/src/dali/utc-Dali-SignalTemplates.cpp

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