automated-tests/src/dali/utc-Dali-SignalTemplatesV2.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 SignalV2< void (TestButton&) > PanelDownSignal;
  60   typedef SignalV2< 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 SignalV2<void ()> VoidRetNoParamSignal;
 137
 138   // Void return, 1 value parameter
 139   typedef SignalV2<void (int)> VoidRet1ValueParamSignal;
 140
 141   // Void return, 1 reference parameter
 142   typedef SignalV2< void (int&)> VoidRet1RefParamSignal;
 143
 144   // Void return, 2 value parameters
 145   typedef SignalV2<void (int, int)> VoidRet2ValueParamSignal;
 146
 147   // bool return, 1 value parameter
 148   typedef SignalV2< bool (float)> BoolRet1ValueParamSignal;
 149
 150   // bool return, 2 value parameter
 151   typedef SignalV2<bool (float, int) > BoolRet2ValueParamSignal;
 152
 153   // int return, 2 value parameter
 154   typedef SignalV2<int (float, int)> IntRet2ValueParamSignal;
 155
 156   // float return, 0 parameters
 157   typedef SignalV2< float () > FloatRet0ParamSignal;
 158
 159   // float return, 2 value parameters
 160   typedef SignalV2<float (float, float) > FloatRet2ValueParamSignal;
 161
 162   // void return, 3 value parameters
 163   typedef SignalV2<void (float, float, float) > VoidSignalTypeFloatValue3;
 164
 165   // float return, 3 value parameters
 166   typedef SignalV2<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( mCallback )
 827     {
 828       // Notify signal since the slot has been destroyed
 829       mSlotObserver->SlotDisconnected( mCallback );
 830       delete mCallback;
 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
 875       delete mCallback;
 876       mCallback = NULL;
 877     }
 878   }
 879
 880 private:
 881
 882   TestBasicConnectionTrackerInterface( const TestBasicConnectionTrackerInterface& );            ///< undefined copy constructor
 883   TestBasicConnectionTrackerInterface& operator=( const TestBasicConnectionTrackerInterface& ); ///< undefined assignment operator
 884
 885 public:
 886
 887   bool mCallbackHandled;
 888
 889 private:
 890
 891   CallbackBase* mCallback;     ///< callback, has ownership
 892   SlotObserver* mSlotObserver; ///< a pointer to the slot observer (not owned)
 893 };
 894
 895
 896 bool wasStaticVoidCallbackVoidCalled  = false;
 897 bool wasStaticFloatCallbackVoidCalled = false;
 898 bool wasStaticVoidCallbackIntValueCalled = false;
 899 int staticIntValue = 0;
 900 bool wasStaticFloatCallbackFloatValueFloatValueCalled = false;
 901 float staticFloatValue1 = 0.0f;
 902 float staticFloatValue2 = 0.0f;
 903
 904 static void StaticVoidCallbackVoid()
 905 {
 906   wasStaticVoidCallbackVoidCalled = true;
 907 }
 908
 909 static float StaticFloatCallbackVoid()
 910 {
 911   wasStaticFloatCallbackVoidCalled = true;
 912   return 7.0f;
 913 }
 914
 915 static void StaticVoidCallbackIntValue( int value )
 916 {
 917   wasStaticVoidCallbackIntValueCalled = true;
 918   staticIntValue = value;
 919 }
 920
 921 static float StaticFloatCallbackFloatValueFloatValue( float value1, float value2 )
 922 {
 923   wasStaticFloatCallbackFloatValueFloatValueCalled = true;
 924   staticFloatValue1 = value1;
 925   staticFloatValue2 = value2;
 926   return value1 + value2;
 927 }
 928
 929 } // anon namespace
 930
 931
 932 int UtcDaliSignalEmptyCheck(void)
 933 {
 934   // Test that Empty() check works before & after signal connection
 935
 936   {
 937     TestSignals::VoidRetNoParamSignal signal;
 938     DALI_TEST_CHECK( signal.Empty() );
 939     TestSlotHandler handler;
 940     signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
 941     DALI_TEST_CHECK( ! signal.Empty() );
 942   }
 943
 944   {
 945     TestSignals::VoidRet1ValueParamSignal signal;
 946     DALI_TEST_CHECK( signal.Empty() );
 947     TestSlotHandler handler;
 948     signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValue );
 949     DALI_TEST_CHECK( ! signal.Empty() );
 950   }
 951
 952   {
 953     TestSignals::VoidRet1RefParamSignal signal;
 954     DALI_TEST_CHECK( signal.Empty() );
 955     TestSlotHandler handler;
 956     signal.Connect( &handler, &TestSlotHandler::VoidSlotIntRef );
 957     DALI_TEST_CHECK( ! signal.Empty() );
 958   }
 959
 960   {
 961     TestSignals::VoidRet2ValueParamSignal signal;
 962     DALI_TEST_CHECK( signal.Empty() );
 963     TestSlotHandler handler;
 964     signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValueIntValue );
 965     DALI_TEST_CHECK( ! signal.Empty() );
 966   }
 967
 968   {
 969     TestSignals::BoolRet1ValueParamSignal signal;
 970     DALI_TEST_CHECK( signal.Empty() );
 971     TestSlotHandler handler;
 972     signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValue );
 973     DALI_TEST_CHECK( ! signal.Empty() );
 974   }
 975
 976   {
 977     TestSignals::BoolRet2ValueParamSignal signal;
 978     DALI_TEST_CHECK( signal.Empty() );
 979     TestSlotHandler handler;
 980     signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValueIntValue );
 981     DALI_TEST_CHECK( ! signal.Empty() );
 982   }
 983
 984   {
 985     TestSignals::IntRet2ValueParamSignal signal;
 986     DALI_TEST_CHECK( signal.Empty() );
 987     TestSlotHandler handler;
 988     signal.Connect( &handler, &TestSlotHandler::IntSlotFloatValueIntValue );
 989     DALI_TEST_CHECK( ! signal.Empty() );
 990   }
 991
 992   {
 993     TestSignals::FloatRet0ParamSignal signal;
 994     DALI_TEST_CHECK( signal.Empty() );
 995     TestSlotHandler handler;
 996     signal.Connect( &handler, &TestSlotHandler::FloatSlotVoid );
 997     DALI_TEST_CHECK( ! signal.Empty() );
 998   }
 999
1000   {
1001     TestSignals::FloatRet2ValueParamSignal signal;
1002     DALI_TEST_CHECK( signal.Empty() );
1003     TestSlotHandler handler;
1004     signal.Connect(&handler, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1005     DALI_TEST_CHECK( ! signal.Empty() );
1006   }
1007   END_TEST;
1008 }
1009
1010 int UtcDaliSignalEmptyCheckSlotDestruction(void)
1011 {
1012   // Test that signal disconnect works when slot is destroyed (goes out of scope)
1013
1014   {
1015     TestSignals::VoidRetNoParamSignal signal;
1016     {
1017       DALI_TEST_CHECK( signal.Empty() );
1018       TestSlotHandler handler;
1019       signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
1020       DALI_TEST_CHECK( ! signal.Empty() );
1021     }
1022     // End of slot lifetime
1023     DALI_TEST_CHECK( signal.Empty() );
1024
1025     // Signal emission should be a NOOP
1026     signal.Emit();
1027   }
1028
1029   {
1030     TestSignals::VoidRet1ValueParamSignal signal;
1031     {
1032       DALI_TEST_CHECK( signal.Empty() );
1033       TestSlotHandler handler;
1034       signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValue );
1035       DALI_TEST_CHECK( ! signal.Empty() );
1036     }
1037     // End of slot lifetime
1038     DALI_TEST_CHECK( signal.Empty() );
1039
1040     // Signal emission should be a NOOP
1041     signal.Emit( 10 );
1042   }
1043
1044   {
1045     TestSignals::VoidRet1RefParamSignal signal;
1046     {
1047       DALI_TEST_CHECK( signal.Empty() );
1048       TestSlotHandler handler;
1049       signal.Connect( &handler, &TestSlotHandler::VoidSlotIntRef );
1050       DALI_TEST_CHECK( ! signal.Empty() );
1051     }
1052     // End of slot lifetime
1053     DALI_TEST_CHECK( signal.Empty() );
1054
1055     // Signal emission should be a NOOP
1056     int temp( 5 );
1057     signal.Emit( temp );
1058   }
1059
1060   {
1061     TestSignals::VoidRet2ValueParamSignal signal;
1062     {
1063       DALI_TEST_CHECK( signal.Empty() );
1064       TestSlotHandler handler;
1065       signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValueIntValue );
1066       DALI_TEST_CHECK( ! signal.Empty() );
1067     }
1068     // End of slot lifetime
1069     DALI_TEST_CHECK( signal.Empty() );
1070
1071     // Signal emission should be a NOOP
1072     signal.Emit( 1, 2 );
1073   }
1074
1075   {
1076     TestSignals::BoolRet1ValueParamSignal signal;
1077     {
1078       DALI_TEST_CHECK( signal.Empty() );
1079       TestSlotHandler handler;
1080       signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValue );
1081       DALI_TEST_CHECK( ! signal.Empty() );
1082     }
1083     // End of slot lifetime
1084     DALI_TEST_CHECK( signal.Empty() );
1085
1086     // Signal emission should be a NOOP
1087     bool blah = signal.Emit( 1.0f );
1088     DALI_TEST_CHECK( ! blah );
1089   }
1090
1091   {
1092     TestSignals::BoolRet2ValueParamSignal signal;
1093     {
1094       DALI_TEST_CHECK( signal.Empty() );
1095       TestSlotHandler handler;
1096       signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValueIntValue );
1097       DALI_TEST_CHECK( ! signal.Empty() );
1098     }
1099     // End of slot lifetime
1100     DALI_TEST_CHECK( signal.Empty() );
1101
1102     // Signal emission should be a NOOP
1103     bool blah = signal.Emit( 1.0f, 2 );
1104     DALI_TEST_CHECK( ! blah );
1105   }
1106
1107   {
1108     TestSignals::IntRet2ValueParamSignal signal;
1109     {
1110       DALI_TEST_CHECK( signal.Empty() );
1111       TestSlotHandler handler;
1112       signal.Connect( &handler, &TestSlotHandler::IntSlotFloatValueIntValue );
1113       DALI_TEST_CHECK( ! signal.Empty() );
1114     }
1115     // End of slot lifetime
1116     DALI_TEST_CHECK( signal.Empty() );
1117
1118     // Signal emission should be a NOOP
1119     int blah = signal.Emit( 10.0f, 100 );
1120     DALI_TEST_CHECK( 0 == blah );
1121   }
1122
1123   {
1124     TestSignals::FloatRet0ParamSignal signal;
1125     {
1126       DALI_TEST_CHECK( signal.Empty() );
1127       TestSlotHandler handler;
1128       signal.Connect( &handler, &TestSlotHandler::FloatSlotVoid );
1129       DALI_TEST_CHECK( ! signal.Empty() );
1130     }
1131     // End of slot lifetime
1132     DALI_TEST_CHECK( signal.Empty() );
1133
1134     // Signal emission should be a NOOP
1135     float blah = signal.Emit();
1136     DALI_TEST_CHECK( 0.0f == blah );
1137   }
1138
1139   {
1140     TestSignals::FloatRet2ValueParamSignal signal;
1141     {
1142       DALI_TEST_CHECK( signal.Empty() );
1143       TestSlotHandler handler;
1144       signal.Connect(&handler, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1145       DALI_TEST_CHECK( ! signal.Empty() );
1146     }
1147     // End of slot lifetime
1148     DALI_TEST_CHECK( signal.Empty() );
1149
1150     // Signal emission should be a NOOP
1151     float blah = signal.Emit( 3.0f, 4.0f );
1152     DALI_TEST_CHECK( 0.0f == blah );
1153   }
1154   END_TEST;
1155 }
1156
1157 // Positive test case for a method
1158 int UtcDaliSignalConnectAndEmit(void)
1159 {
1160   // Test basic signal emission for each slot type
1161
1162   TestSignals signals;
1163
1164   {
1165     TestSlotHandler handlers;
1166     signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
1167     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1168     signals.EmitVoidSignalVoid();
1169     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1170
1171     // Test double emission
1172     handlers.mHandled = false;
1173     signals.EmitVoidSignalVoid();
1174     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1175   }
1176   signals.CheckNoConnections();
1177
1178   {
1179     TestSlotHandler handlers;
1180     signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1181     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1182     int x = 7;
1183     signals.EmitVoidSignalIntRef(x);
1184     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1185     DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
1186   }
1187   signals.CheckNoConnections();
1188
1189   {
1190     TestSlotHandler handlers;
1191     signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
1192     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1193     signals.EmitVoidSignalIntValue(5);
1194     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1195     DALI_TEST_EQUALS( handlers.mIntParam1, 5, TEST_LOCATION );
1196   }
1197   signals.CheckNoConnections();
1198
1199   {
1200     TestSlotHandler handlers;
1201     signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
1202     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1203     signals.EmitVoidSignalIntValueIntValue(6, 7);
1204     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1205     DALI_TEST_EQUALS( handlers.mIntParam1, 6, TEST_LOCATION );
1206     DALI_TEST_EQUALS( handlers.mIntParam2, 7, TEST_LOCATION );
1207   }
1208   signals.CheckNoConnections();
1209
1210   {
1211     TestSlotHandler handlers;
1212     signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
1213     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1214
1215     handlers.mBoolReturn = true;
1216     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION );
1217     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1218     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1219
1220     // repeat with opposite return value
1221     handlers.mBoolReturn = false;
1222     handlers.mHandled = false;
1223     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION );
1224     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1225     DALI_TEST_EQUALS( handlers.mFloatParam1, 6.0f, TEST_LOCATION );
1226   }
1227   signals.CheckNoConnections();
1228
1229   {
1230     TestSlotHandler handlers;
1231     signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
1232     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1233     handlers.mBoolReturn = true;
1234     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION );
1235     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1236     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1237     DALI_TEST_EQUALS( handlers.mIntParam2, 10, TEST_LOCATION );
1238   }
1239   signals.CheckNoConnections();
1240
1241   {
1242     TestSlotHandler handlers;
1243     signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
1244     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1245     handlers.mIntReturn = 27;
1246     int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
1247     DALI_TEST_EQUALS( x, 27, TEST_LOCATION );
1248     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1249     DALI_TEST_EQUALS( handlers.mFloatParam1, 33.5f, TEST_LOCATION );
1250     DALI_TEST_EQUALS( handlers.mIntParam2, 5, TEST_LOCATION );
1251   }
1252   signals.CheckNoConnections();
1253
1254   {
1255     TestSlotHandler handlers;
1256     signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
1257     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1258     handlers.mFloatReturn = 27.0f;
1259     float f = signals.EmitFloat0Signal();
1260     DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
1261     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1262     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1263     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1264   }
1265   signals.CheckNoConnections();
1266
1267   {
1268     TestSlotHandler handlers;
1269     signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1270     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1271     handlers.mFloatReturn = 27.0f;
1272     float f = signals.EmitFloat2VSignal(5, 33.0f);
1273     DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
1274     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1275     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1276     DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1277   }
1278   signals.CheckNoConnections();
1279
1280   {
1281     TestSlotHandler handlers;
1282     signals.VoidSignalFloatValue3().Connect(&handlers, &TestSlotHandler::VoidSlotFloatValue3);
1283     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1284     signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
1285     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1286     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1287     DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1288     DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
1289   }
1290   signals.CheckNoConnections();
1291
1292   {
1293     TestSlotHandler handlers;
1294     signals.FloatSignalFloatValue3().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValue3);
1295     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1296     handlers.mFloatReturn = 27.0f;
1297     float returnValue = signals.EmitFloatSignalFloatValue3(5, 33.0f, 100.0f);
1298     DALI_TEST_EQUALS( returnValue, 27.0f, TEST_LOCATION );
1299     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1300     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1301     DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1302     DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
1303   }
1304   signals.CheckNoConnections();
1305   END_TEST;
1306 }
1307
1308 int UtcDaliSignalDisconnect(void)
1309 {
1310   // Test that callbacks don't occur if a signal is disconnected before emission
1311
1312   TestSignals signals;
1313
1314   {
1315     TestSlotHandler handlers;
1316     signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
1317     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1318     signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
1319     signals.EmitVoidSignalVoid();
1320     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1321   }
1322
1323   {
1324     TestSlotHandler handlers;
1325     signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1326     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1327     int r = 7;
1328     handlers.mIntReturn = 5;
1329     signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1330     signals.EmitVoidSignalIntRef(r);
1331     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1332     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1333     DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
1334   }
1335
1336   {
1337     TestSlotHandler handlers;
1338     signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
1339     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1340     signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
1341     signals.EmitVoidSignalIntValue(5);
1342     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1343     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1344   }
1345
1346   {
1347     TestSlotHandler handlers;
1348     signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
1349     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1350     signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
1351     signals.EmitVoidSignalIntValueIntValue(5, 10);
1352     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1353     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1354     DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
1355   }
1356
1357   {
1358     TestSlotHandler handlers;
1359     signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
1360     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1361     handlers.mBoolReturn = true;
1362     signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
1363     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
1364     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1365     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1366   }
1367
1368   {
1369     TestSlotHandler handlers;
1370     signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
1371     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1372     handlers.mBoolReturn = true;
1373     signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
1374     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
1375     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1376     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1377     DALI_TEST_EQUALS( handlers.mIntParam2,   0, TEST_LOCATION );
1378   }
1379
1380   {
1381     TestSlotHandler handlers;
1382     signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
1383     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1384     handlers.mIntReturn = 27;
1385     signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
1386     signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
1387     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1388     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1389     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1390   }
1391
1392   {
1393     TestSlotHandler handlers;
1394     signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
1395     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1396     handlers.mFloatReturn = 27.0f;
1397     signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
1398     signals.EmitFloat0Signal();
1399     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1400     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
1401     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1402   }
1403
1404   {
1405     TestSlotHandler handlers;
1406     signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1407     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1408     handlers.mFloatReturn = 27.0f;
1409     signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1410     signals.EmitFloat2VSignal(5, 33.0f);
1411     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1412     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
1413     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1414   }
1415   END_TEST;
1416 }
1417
1418 int UtcDaliSignalDisconnect2(void)
1419 {
1420   // Test that nothing happens when attempting to disconnect an unconnected slot
1421
1422   TestSignals signals;
1423   {
1424     TestSlotHandler handlers;
1425     signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
1426     signals.EmitVoidSignalVoid();
1427     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1428   }
1429
1430   {
1431     TestSlotHandler handlers;
1432     int r = 7;
1433     signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1434     signals.EmitVoidSignalIntRef(r);
1435     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1436     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1437     DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
1438   }
1439
1440   {
1441     TestSlotHandler handlers;
1442     signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
1443     signals.EmitVoidSignalIntValue(5);
1444     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1445     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1446   }
1447
1448   {
1449     TestSlotHandler handlers;
1450     signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
1451     signals.EmitVoidSignalIntValueIntValue(5, 10);
1452     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1453     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1454     DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
1455   }
1456
1457   {
1458     TestSlotHandler handlers;
1459     handlers.mBoolReturn = true;
1460     signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
1461     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
1462     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1463     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1464   }
1465
1466   {
1467     TestSlotHandler handlers;
1468     handlers.mBoolReturn = true;
1469     signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
1470     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
1471     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1472     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1473     DALI_TEST_EQUALS( handlers.mIntParam2,   0, TEST_LOCATION );
1474   }
1475
1476   {
1477     TestSlotHandler handlers;
1478     handlers.mIntReturn = 27;
1479     signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
1480     signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
1481     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1482     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1483     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1484   }
1485
1486   {
1487     TestSlotHandler handlers;
1488     handlers.mFloatReturn = 27.0f;
1489     signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
1490     signals.EmitFloat2VSignal(5, 33.0f);
1491     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1492     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
1493     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1494   }
1495
1496   {
1497     TestSlotHandler handlers;
1498     handlers.mFloatReturn = 27.0f;
1499     signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
1500     signals.EmitFloat0Signal();
1501     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1502     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
1503     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1504   }
1505   END_TEST;
1506 }
1507
1508 int UtcDaliSignalDisconnect3(void)
1509 {
1510   // Test that callbacks stop after a signal is disconnected
1511
1512   TestSignals signals;
1513
1514   {
1515     TestSlotHandler handlers;
1516     signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
1517     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1518
1519     // Emit first
1520     signals.EmitVoidSignalVoid();
1521     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1522
1523     // Disconnect and emit again
1524     handlers.mHandled = false;
1525     signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
1526     signals.EmitVoidSignalVoid();
1527     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1528   }
1529
1530   {
1531     TestSlotHandler handlers;
1532     signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1533     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1534     int r = 7;
1535
1536     // Emit first
1537     signals.EmitVoidSignalIntRef(r);
1538     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1539     DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
1540
1541     // Disconnect and emit again
1542     handlers.mHandled = false;
1543     handlers.mIntParam1 = 0;
1544     signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
1545     signals.EmitVoidSignalIntRef(r);
1546     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1547     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1548     DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
1549   }
1550   END_TEST;
1551 }
1552
1553 int UtcDaliSignalCustomConnectionTracker(void)
1554 {
1555   // Test slot destruction
1556   {
1557     TestSignals::VoidRetNoParamSignal signal;
1558     {
1559       DALI_TEST_CHECK( signal.Empty() );
1560       TestBasicConnectionTrackerInterface customTracker;
1561       signal.Connect( &customTracker, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
1562       DALI_TEST_CHECK( ! signal.Empty() );
1563     }
1564     // End of slot lifetime
1565     DALI_TEST_CHECK( signal.Empty() );
1566
1567     // Signal emission should be a NOOP
1568     signal.Emit();
1569   }
1570
1571   TestBasicConnectionTrackerInterface customTracker2;
1572
1573   // Test signal emission & destruction
1574   {
1575     TestSignals::VoidRetNoParamSignal signal;
1576     DALI_TEST_CHECK( signal.Empty() );
1577     DALI_TEST_EQUALS( 0u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1578
1579     signal.Connect( &customTracker2, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
1580     DALI_TEST_CHECK( ! signal.Empty() );
1581     DALI_TEST_EQUALS( 1u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1582
1583     DALI_TEST_EQUALS( customTracker2.mCallbackHandled, false, TEST_LOCATION );
1584     signal.Emit();
1585     DALI_TEST_EQUALS( customTracker2.mCallbackHandled, true, TEST_LOCATION );
1586   }
1587   DALI_TEST_EQUALS( 0u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1588   END_TEST;
1589 }
1590
1591 int UtcDaliSignalMultipleConnections(void)
1592 {
1593   // Test that multiple callbacks can be connected to the same signal
1594
1595   TestSignals signals;
1596
1597   {
1598     TestSlotHandler handler1;
1599     signals.SignalVoidNone().Connect( &handler1, &TestSlotHandler::VoidSlotVoid );
1600     DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1601
1602     TestSlotHandler handler2;
1603     signals.SignalVoidNone().Connect( &handler2, &TestSlotHandler::VoidSlotVoid );
1604     DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1605
1606     signals.EmitVoidSignalVoid();
1607     DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1608     DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1609
1610     // Remove first connection and repeat
1611     handler1.Reset();
1612     handler2.Reset();
1613     signals.SignalVoidNone().Disconnect( &handler1, &TestSlotHandler::VoidSlotVoid );
1614
1615     signals.EmitVoidSignalVoid();
1616     DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1617     DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1618   }
1619
1620   {
1621     TestSlotHandler handler1;
1622     signals.SignalVoid1Ref().Connect( &handler1, &TestSlotHandler::VoidSlotIntRef );
1623     DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1624
1625     TestSlotHandler handler2;
1626     signals.SignalVoid1Ref().Connect( &handler2, &TestSlotHandler::VoidSlotIntRef );
1627     DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1628
1629     int x = 7;
1630     signals.EmitVoidSignalIntRef(x);
1631     DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1632     DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1633     DALI_TEST_EQUALS( handler1.mIntParam1, 7, TEST_LOCATION );
1634     DALI_TEST_EQUALS( handler2.mIntParam1, 7, TEST_LOCATION );
1635
1636     // Remove second connection and repeat
1637     handler1.Reset();
1638     handler2.Reset();
1639     x = 8;
1640     signals.SignalVoid1Ref().Disconnect( &handler2, &TestSlotHandler::VoidSlotIntRef );
1641
1642     signals.EmitVoidSignalIntRef(x);
1643     DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1644     DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1645     DALI_TEST_EQUALS( handler1.mIntParam1, 8, TEST_LOCATION );
1646     DALI_TEST_EQUALS( handler2.mIntParam1, 0, TEST_LOCATION );
1647   }
1648
1649   {
1650     TestSlotHandler handler1;
1651     signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1652     DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1653
1654     TestSlotHandler handler2;
1655     signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1656     DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1657
1658     TestSlotHandler handler3;
1659     signals.SignalVoid1Value().Connect( &handler3, &TestSlotHandler::VoidSlotIntValue );
1660     DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
1661
1662     signals.EmitVoidSignalIntValue( 5 );
1663     DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1664     DALI_TEST_EQUALS( handler1.mIntParam1, 5, TEST_LOCATION );
1665     DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1666     DALI_TEST_EQUALS( handler2.mIntParam1, 5, TEST_LOCATION );
1667     DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1668     DALI_TEST_EQUALS( handler3.mIntParam1, 5, TEST_LOCATION );
1669
1670     // Remove middle connection and repeat
1671     handler1.Reset();
1672     handler2.Reset();
1673     handler3.Reset();
1674     signals.SignalVoid1Value().Disconnect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1675
1676     signals.EmitVoidSignalIntValue( 6 );
1677     DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1678     DALI_TEST_EQUALS( handler1.mIntParam1, 6, TEST_LOCATION );
1679     DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1680     DALI_TEST_EQUALS( handler2.mIntParam1, 0, TEST_LOCATION );
1681     DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1682     DALI_TEST_EQUALS( handler3.mIntParam1, 6, TEST_LOCATION );
1683   }
1684
1685   // Test that multiple callbacks are disconnected when a signal is destroyed
1686
1687   TestSlotHandler handler4;
1688   TestSlotHandler handler5;
1689   TestSlotHandler handler6;
1690
1691   {
1692     TestSignals::VoidRet1ValueParamSignal tempSignal;
1693
1694     DALI_TEST_EQUALS( handler4.GetConnectionCount(), 0u, TEST_LOCATION );
1695     DALI_TEST_EQUALS( handler5.GetConnectionCount(), 0u, TEST_LOCATION );
1696     DALI_TEST_EQUALS( handler6.GetConnectionCount(), 0u, TEST_LOCATION );
1697
1698     tempSignal.Connect( &handler4, &TestSlotHandler::VoidSlotIntValue );
1699     tempSignal.Connect( &handler5, &TestSlotHandler::VoidSlotIntValue );
1700     tempSignal.Connect( &handler6, &TestSlotHandler::VoidSlotIntValue );
1701
1702     DALI_TEST_EQUALS( handler4.GetConnectionCount(), 1u, TEST_LOCATION );
1703     DALI_TEST_EQUALS( handler5.GetConnectionCount(), 1u, TEST_LOCATION );
1704     DALI_TEST_EQUALS( handler6.GetConnectionCount(), 1u, TEST_LOCATION );
1705   }
1706   // End of tempSignal lifetime
1707
1708   DALI_TEST_EQUALS( handler4.GetConnectionCount(), 0u, TEST_LOCATION );
1709   DALI_TEST_EQUALS( handler5.GetConnectionCount(), 0u, TEST_LOCATION );
1710   DALI_TEST_EQUALS( handler6.GetConnectionCount(), 0u, TEST_LOCATION );
1711   END_TEST;
1712 }
1713
1714 int UtcDaliSignalMultipleConnections2(void)
1715 {
1716   TestSignals signals;
1717
1718   // Test that connecting the same callback twice is a NOOP
1719   {
1720     TestSlotHandler handler1;
1721
1722     // Note the double connection is intentional
1723     signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1724     signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1725     DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1726
1727     signals.EmitVoidSignalIntValue( 6 );
1728     DALI_TEST_EQUALS( handler1.mHandledCount, 1, TEST_LOCATION );
1729     DALI_TEST_EQUALS( handler1.mIntParam1, 6, TEST_LOCATION );
1730
1731     // Calling Disconnect once should be enough
1732     signals.SignalVoid1Value().Disconnect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1733     DALI_TEST_CHECK( signals.SignalVoid1Value().Empty() );
1734     handler1.mIntParam1 = 0;
1735
1736     signals.EmitVoidSignalIntValue( 7 );
1737     DALI_TEST_EQUALS( handler1.mHandledCount, 1/*not incremented since last check*/, TEST_LOCATION );
1738     DALI_TEST_EQUALS( handler1.mIntParam1, 0, TEST_LOCATION );
1739   }
1740
1741   // Test automatic disconnect after multiple Connect() calls
1742   {
1743     TestSlotHandler handler2;
1744     signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1745     signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1746
1747     TestSlotHandler handler3;
1748     signals.SignalBool1Value().Connect( &handler3, &TestSlotHandler::BoolSlotFloatValue );
1749     signals.SignalBool1Value().Connect( &handler3, &TestSlotHandler::BoolSlotFloatValue );
1750
1751     DALI_TEST_EQUALS( handler2.mHandledCount, 0, TEST_LOCATION );
1752     DALI_TEST_EQUALS( handler3.mHandledCount, 0, TEST_LOCATION );
1753     DALI_TEST_CHECK( ! signals.SignalVoid1Value().Empty() );
1754     DALI_TEST_CHECK( ! signals.SignalBool1Value().Empty() );
1755   }
1756   DALI_TEST_CHECK( signals.SignalVoid1Value().Empty() );
1757   DALI_TEST_CHECK( signals.SignalBool1Value().Empty() );
1758
1759   // Should be NOOP
1760   signals.EmitVoidSignalIntValue( 1 );
1761   signals.EmitBoolSignalFloatValue( 1.0f );
1762
1763   // Test that connecting the same callback 10 times is a NOOP
1764   TestSlotHandler handler4;
1765   DALI_TEST_EQUALS( handler4.mHandledCount, 0, TEST_LOCATION );
1766   DALI_TEST_EQUALS( handler4.mFloatParam1, 0.0f, TEST_LOCATION );
1767
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   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1778
1779   signals.EmitBoolSignalFloatValue( 2.0f );
1780   DALI_TEST_EQUALS( handler4.mHandledCount, 1, TEST_LOCATION );
1781   DALI_TEST_EQUALS( handler4.mFloatParam1, 2.0f, TEST_LOCATION );
1782
1783   // Calling Disconnect once should be enough
1784   signals.SignalBool1Value().Disconnect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1785   DALI_TEST_CHECK( signals.SignalBool1Value().Empty() );
1786
1787   signals.EmitBoolSignalFloatValue( 3.0f );
1788   DALI_TEST_EQUALS( handler4.mHandledCount, 1/*not incremented since last check*/, TEST_LOCATION );
1789   DALI_TEST_EQUALS( handler4.mFloatParam1, 2.0f, TEST_LOCATION );
1790   END_TEST;
1791 }
1792
1793 int UtcDaliSignalMultipleConnections3(void)
1794 {
1795   TestSignals signals;
1796
1797   // Test connecting two difference callbacks for the same ConnectionTracker
1798
1799   TestSlotHandler handler1;
1800
1801   {
1802     TestSignals::VoidRet1ValueParamSignal tempSignal;
1803
1804     DALI_TEST_EQUALS( handler1.GetConnectionCount(), 0u, TEST_LOCATION );
1805     DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1806     DALI_TEST_EQUALS( handler1.mIntParam1, 0, TEST_LOCATION );
1807
1808     // Note that the duplicate connection is deliberate
1809     tempSignal.Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1810     tempSignal.Connect( &handler1, &TestSlotHandler::VoidDuplicateSlotIntValue );
1811
1812     DALI_TEST_EQUALS( handler1.GetConnectionCount(), 2u, TEST_LOCATION );
1813     DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1814
1815     tempSignal.Emit( 10 );
1816
1817     DALI_TEST_EQUALS( handler1.mHandledCount, 2, TEST_LOCATION );
1818     DALI_TEST_EQUALS( handler1.mIntParam1, 10, TEST_LOCATION );
1819     DALI_TEST_EQUALS( handler1.mIntParam2, 10, TEST_LOCATION );
1820   }
1821   // End of tempSignal lifetime
1822
1823   DALI_TEST_EQUALS( handler1.GetConnectionCount(), 0u, TEST_LOCATION );
1824   END_TEST;
1825 }
1826
1827
1828 int UtcDaliSignalDisconnectStatic(void)
1829 {
1830   // void Func()
1831
1832   {
1833     TestSignals::VoidRetNoParamSignal signal;
1834     DALI_TEST_CHECK( signal.Empty() );
1835
1836     signal.Connect( StaticVoidCallbackVoid );
1837     DALI_TEST_CHECK( ! signal.Empty() );
1838
1839     wasStaticVoidCallbackVoidCalled = false;
1840     signal.Emit();
1841     DALI_TEST_EQUALS( wasStaticVoidCallbackVoidCalled, true, TEST_LOCATION );
1842
1843     signal.Disconnect( StaticVoidCallbackVoid );
1844     DALI_TEST_CHECK( signal.Empty() );
1845
1846     wasStaticVoidCallbackVoidCalled = false;
1847     signal.Emit();
1848     DALI_TEST_EQUALS( wasStaticVoidCallbackVoidCalled, false, TEST_LOCATION );
1849   }
1850
1851   // float Func()
1852
1853   {
1854     TestSignals::FloatRet0ParamSignal signal;
1855     DALI_TEST_CHECK( signal.Empty() );
1856
1857     signal.Connect( StaticFloatCallbackVoid );
1858     DALI_TEST_CHECK( ! signal.Empty() );
1859
1860     wasStaticFloatCallbackVoidCalled = false;
1861     float result = signal.Emit();
1862     DALI_TEST_EQUALS( wasStaticFloatCallbackVoidCalled, true, TEST_LOCATION );
1863     DALI_TEST_EQUALS( result, 7.0f, TEST_LOCATION );
1864
1865     signal.Disconnect( StaticFloatCallbackVoid );
1866     DALI_TEST_CHECK( signal.Empty() );
1867
1868     wasStaticFloatCallbackVoidCalled = false;
1869     result = signal.Emit();
1870     DALI_TEST_EQUALS( wasStaticFloatCallbackVoidCalled, false, TEST_LOCATION );
1871     DALI_TEST_EQUALS( result, 0.0f, TEST_LOCATION );
1872   }
1873
1874   // void Func( int )
1875
1876   {
1877     TestSignals::VoidRet1ValueParamSignal signal;
1878     DALI_TEST_CHECK( signal.Empty() );
1879
1880     signal.Connect( StaticVoidCallbackIntValue );
1881     DALI_TEST_CHECK( ! signal.Empty() );
1882
1883     wasStaticVoidCallbackIntValueCalled = false;
1884     staticIntValue = 0;
1885     signal.Emit( 10 );
1886     DALI_TEST_EQUALS( wasStaticVoidCallbackIntValueCalled, true, TEST_LOCATION );
1887     DALI_TEST_EQUALS( staticIntValue, 10, TEST_LOCATION );
1888
1889     signal.Disconnect( StaticVoidCallbackIntValue );
1890     DALI_TEST_CHECK( signal.Empty() );
1891
1892     wasStaticVoidCallbackIntValueCalled = false;
1893     staticIntValue = 0;
1894     signal.Emit( 11 );
1895     DALI_TEST_EQUALS( wasStaticVoidCallbackIntValueCalled, false, TEST_LOCATION );
1896     DALI_TEST_EQUALS( staticIntValue, 0, TEST_LOCATION );
1897   }
1898
1899   // float Func( float, float )
1900
1901   {
1902     TestSignals::FloatRet2ValueParamSignal signal;
1903     DALI_TEST_CHECK( signal.Empty() );
1904
1905     signal.Connect( StaticFloatCallbackFloatValueFloatValue );
1906     DALI_TEST_CHECK( ! signal.Empty() );
1907
1908     wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1909     staticFloatValue1 = 0.0f;
1910     staticFloatValue2 = 0.0f;
1911     float result = signal.Emit( 5.0f, 6.0f );
1912     DALI_TEST_EQUALS( wasStaticFloatCallbackFloatValueFloatValueCalled, true, TEST_LOCATION );
1913     DALI_TEST_EQUALS( staticFloatValue1, 5.0f, TEST_LOCATION );
1914     DALI_TEST_EQUALS( staticFloatValue2, 6.0f, TEST_LOCATION );
1915     DALI_TEST_EQUALS( result, 5.0f+6.0f, TEST_LOCATION );
1916
1917     signal.Disconnect( StaticFloatCallbackFloatValueFloatValue );
1918     DALI_TEST_CHECK( signal.Empty() );
1919
1920     wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1921     staticFloatValue1 = 0.0f;
1922     staticFloatValue2 = 0.0f;
1923     result = signal.Emit( 7.0f, 8.0f );
1924     DALI_TEST_EQUALS( wasStaticFloatCallbackFloatValueFloatValueCalled, false, TEST_LOCATION );
1925     DALI_TEST_EQUALS( staticFloatValue1, 0.0f, TEST_LOCATION );
1926     DALI_TEST_EQUALS( staticFloatValue2, 0.0f, TEST_LOCATION );
1927     DALI_TEST_EQUALS( result, 0.0f, TEST_LOCATION );
1928   }
1929   END_TEST;
1930 }
1931
1932 int UtcDaliSignalDisconnectDuringCallback(void)
1933 {
1934   // Test disconnection during each callback
1935
1936   TestSignals::VoidRetNoParamSignal signal;
1937   DALI_TEST_CHECK( signal.Empty() );
1938
1939   TestSlotDisconnector handler1;
1940   handler1.VoidConnectVoid( signal );
1941   DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1942   DALI_TEST_CHECK( ! signal.Empty() );
1943
1944   signal.Emit();
1945   DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1946   DALI_TEST_CHECK( signal.Empty() );
1947
1948   // Repeat with 2 callbacks
1949
1950   handler1.mHandled = false;
1951
1952   TestSlotDisconnector handler2;
1953   handler1.VoidConnectVoid( signal );
1954   handler2.VoidConnectVoid( signal );
1955   DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1956   DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1957   DALI_TEST_CHECK( ! signal.Empty() );
1958
1959   signal.Emit();
1960   DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1961   DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1962   DALI_TEST_CHECK( signal.Empty() );
1963
1964   // Repeat with no callbacks
1965
1966   handler1.mHandled = false;
1967   handler2.mHandled = false;
1968
1969   signal.Emit();
1970   DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1971   DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1972
1973   // Repeat with 3 callbacks
1974
1975   TestSlotDisconnector handler3;
1976   handler1.VoidConnectVoid( signal );
1977   handler2.VoidConnectVoid( signal );
1978   handler3.VoidConnectVoid( signal );
1979   DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1980   DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1981   DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
1982   DALI_TEST_CHECK( ! signal.Empty() );
1983
1984   signal.Emit();
1985   DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1986   DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1987   DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1988   DALI_TEST_CHECK( signal.Empty() );
1989
1990   // Repeat with no callbacks
1991
1992   handler1.mHandled = false;
1993   handler2.mHandled = false;
1994   handler3.mHandled = false;
1995
1996   signal.Emit();
1997   DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1998   DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1999   DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
2000   END_TEST;
2001 }
2002
2003 int UtcDaliSignalDisconnectDuringCallback2(void)
2004 {
2005   // Test disconnection of some (but not all) callbacks during sigmal emission
2006
2007   TestSignals::VoidRetNoParamSignal signal;
2008   DALI_TEST_CHECK( signal.Empty() );
2009
2010   TestSlotMultiDisconnector handler;
2011   handler.ConnectAll( signal );
2012   DALI_TEST_EQUALS( handler.mSlotHandled[0], false, TEST_LOCATION );
2013   DALI_TEST_EQUALS( handler.mSlotHandled[1], false, TEST_LOCATION );
2014   DALI_TEST_EQUALS( handler.mSlotHandled[2], false, TEST_LOCATION );
2015   DALI_TEST_EQUALS( handler.mSlotHandled[3], false, TEST_LOCATION );
2016   DALI_TEST_EQUALS( handler.mSlotHandled[4], false, TEST_LOCATION );
2017   DALI_TEST_EQUALS( handler.mSlotHandled[5], false, TEST_LOCATION );
2018   DALI_TEST_EQUALS( handler.mSlotHandled[6], false, TEST_LOCATION );
2019   DALI_TEST_EQUALS( handler.mSlotHandled[7], false, TEST_LOCATION );
2020   DALI_TEST_EQUALS( handler.mSlotHandled[8], false, TEST_LOCATION );
2021   DALI_TEST_EQUALS( handler.mSlotHandled[9], false, TEST_LOCATION );
2022   DALI_TEST_CHECK( ! signal.Empty() );
2023
2024   signal.Emit();
2025
2026   // Slots 5, 7, & 9 should be disconnected before being called
2027   DALI_TEST_EQUALS( handler.mSlotHandled[0], true, TEST_LOCATION );
2028   DALI_TEST_EQUALS( handler.mSlotHandled[1], true, TEST_LOCATION );
2029   DALI_TEST_EQUALS( handler.mSlotHandled[2], true, TEST_LOCATION );
2030   DALI_TEST_EQUALS( handler.mSlotHandled[3], true, TEST_LOCATION );
2031   DALI_TEST_EQUALS( handler.mSlotHandled[4], true, TEST_LOCATION );
2032   DALI_TEST_EQUALS( handler.mSlotHandled[5], false, TEST_LOCATION );
2033   DALI_TEST_EQUALS( handler.mSlotHandled[6], true, TEST_LOCATION );
2034   DALI_TEST_EQUALS( handler.mSlotHandled[7], false, TEST_LOCATION );
2035   DALI_TEST_EQUALS( handler.mSlotHandled[8], true, TEST_LOCATION );
2036   DALI_TEST_EQUALS( handler.mSlotHandled[9], false, TEST_LOCATION );
2037   DALI_TEST_CHECK( ! signal.Empty() );
2038
2039   // Odd slots are disconnected
2040   DALI_TEST_EQUALS( handler.GetConnectionCount(), 5u, TEST_LOCATION );
2041   END_TEST;
2042 }
2043
2044 int UtcDaliSignalEmitDuringCallback(void)
2045 {
2046   TestApplication app; // Create core for debug logging
2047
2048   TestSignals::VoidRetNoParamSignal signal;
2049   DALI_TEST_CHECK( signal.Empty() );
2050
2051   TestEmitDuringCallback handler1;
2052   handler1.VoidConnectVoid( signal );
2053
2054   // Test that this does not result in an infinite loop!
2055   signal.Emit();
2056   END_TEST;
2057 }
2058
2059 int UtcDaliSignalTestApp01(void)
2060 {
2061   // Test 1 signal connected to 1 Slot.
2062   // Signal dies first.
2063
2064   TestButton* button = new TestButton(1);
2065   TestApp app;
2066   button->DownSignal().Connect(&app,&TestApp::OnButtonPress);
2067
2068   // check we have both the button, and the app have 1 connection
2069   DALI_TEST_EQUALS( app.GetConnectionCount(), 1u, TEST_LOCATION );
2070   DALI_TEST_EQUALS( button->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2071
2072   delete button;  // should automatically destroy the connection
2073
2074   // check we have a 0 connections
2075   DALI_TEST_EQUALS( app.GetConnectionCount(), 0u, TEST_LOCATION );
2076
2077   END_TEST;
2078 }
2079
2080 int UtcDaliSignalTestApp02(void)
2081 {
2082   // Test 1 signal connected to 1 Slot.
2083   // Slot owning object dies first.
2084
2085   TestButton button(1);
2086   TestApp *app = new TestApp;
2087   button.DownSignal().Connect( app, &TestApp::OnButtonPress);
2088
2089   // check we have a 1 connection
2090   DALI_TEST_EQUALS( app->GetConnectionCount(), 1u, TEST_LOCATION );
2091   DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2092
2093   delete app;  // should automatically destroy the connection
2094
2095   // check we have a 0 connections
2096   DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION );
2097   END_TEST;
2098 }
2099
2100 int UtcDaliSignalTestApp03(void)
2101 {
2102   // Test 1 Signal connect to 2 slots
2103   // 1 of the slot owners dies. Then the second slot owner dies
2104
2105   TestButton button(1);
2106   TestApp *app1 = new TestApp;
2107   TestApp *app2 = new TestApp;
2108
2109   button.DownSignal().Connect( app1, &TestApp::OnButtonPress);
2110   button.DownSignal().Connect( app2, &TestApp::OnButtonPress);
2111
2112     // check we have a 2 connections to the signal
2113   DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 2u, TEST_LOCATION );
2114
2115   // kill the first slot
2116   delete app1;  // should automatically destroy the connection
2117
2118   // check we have 1 connection left
2119   DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2120
2121   button.Press();   // emit the signal (to ensure it doesn't seg fault)
2122
2123   // kill the second slot
2124   delete app2;  // should automatically destroy the connection
2125
2126   // check we have 1 connection left
2127   DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION );
2128
2129   END_TEST;
2130 }
2131
2132 int UtcDaliSignalTestApp04(void)
2133 {
2134   // Test 1 Signal connected to 2 slots (with different owners)
2135   // The Signal dies, check the 2 slots disconnect automatically
2136
2137   TestButton* button = new TestButton(1);
2138   TestApp app1;
2139   TestApp app2;
2140
2141   button->DownSignal().Connect(&app1,&TestApp::OnButtonPress);
2142   button->DownSignal().Connect(&app2,&TestApp::OnButtonPress);
2143
2144   // check the connection counts
2145   DALI_TEST_EQUALS( app1.GetConnectionCount(), 1u, TEST_LOCATION );
2146   DALI_TEST_EQUALS( app2.GetConnectionCount(), 1u, TEST_LOCATION );
2147   DALI_TEST_EQUALS( button->DownSignal().GetConnectionCount(), 2u, TEST_LOCATION );
2148
2149   delete button;  // should automatically destroy the connection
2150
2151   // check both slot owners have zero connections
2152   DALI_TEST_EQUALS( app1.GetConnectionCount(), 0u, TEST_LOCATION );
2153   DALI_TEST_EQUALS( app2.GetConnectionCount(), 0u, TEST_LOCATION );
2154   END_TEST;
2155 }
2156
2157 int UtcDaliSignalTestApp05(void)
2158 {
2159   // Test 2 Signals (with different owners)  connected to 1 slots
2160   // 1 Signal dies, check that the remaining connection is valid
2161
2162   TestButton* button1 = new TestButton(1); // use for signal 1
2163   TestButton* button2 = new TestButton(2); // use for signal 2
2164
2165   TestApp app;
2166
2167   button1->DownSignal().Connect(&app,&TestApp::OnButtonPress);
2168   button2->DownSignal().Connect(&app,&TestApp::OnButtonPress);
2169
2170   // check the connection counts
2171   DALI_TEST_EQUALS( app.GetConnectionCount(), 2u, TEST_LOCATION );
2172   DALI_TEST_EQUALS( button1->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2173   DALI_TEST_EQUALS( button2->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
2174
2175   // make sure both signals emit ok
2176   button2->Press();
2177   DALI_TEST_EQUALS( app.GetButtonPressedId() , 2 , TEST_LOCATION );
2178
2179   button1->Press();
2180   DALI_TEST_EQUALS( app.GetButtonPressedId() , 1 , TEST_LOCATION );
2181
2182   delete button1;  // should automatically destroy 1 connection
2183
2184   // check both slot owners have zero connections
2185   DALI_TEST_EQUALS( app.GetConnectionCount(), 1u, TEST_LOCATION );
2186
2187   // check remaining connection still works
2188   button2->Press();
2189   DALI_TEST_EQUALS( app.GetButtonPressedId() , 2 , TEST_LOCATION );
2190
2191   // kill the last signal
2192   delete button2;
2193   DALI_TEST_EQUALS( app.GetConnectionCount(), 0u, TEST_LOCATION );
2194   END_TEST;
2195 }
2196
2197 int UtcDaliSignalTestApp06(void)
2198 {
2199   SignalV2< bool () > boolSignal;
2200   TestApp app;
2201   bool result(false);
2202
2203   // connect a slot which will return false
2204   boolSignal.Connect( &app, &TestApp::BoolReturnTestFalse);
2205   result = boolSignal.Emit();
2206   DALI_TEST_EQUALS( result, false, TEST_LOCATION );
2207
2208   // disconnect last slot, and connect a slot which returns true
2209   boolSignal.Disconnect( &app, &TestApp::BoolReturnTestFalse);
2210   boolSignal.Connect( &app, &TestApp::BoolReturnTestTrue);
2211   result = boolSignal.Emit();
2212   DALI_TEST_EQUALS( result, true, TEST_LOCATION );
2213   END_TEST;
2214 }
2215
2216 int UtcDaliSlotDelegateConnection(void)
2217 {
2218   TestSignals signals;
2219
2220   {
2221     TestSlotDelegateHandler handlers;
2222     signals.SignalVoidNone().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
2223     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2224     signals.EmitVoidSignalVoid();
2225     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2226
2227     // Test double emission
2228     handlers.mHandled = false;
2229     signals.EmitVoidSignalVoid();
2230     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2231   }
2232   signals.CheckNoConnections();
2233
2234   {
2235     TestSlotDelegateHandler handlers;
2236     signals.SignalVoid1Ref().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef );
2237     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2238     int x = 7;
2239     signals.EmitVoidSignalIntRef(x);
2240     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2241     DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
2242   }
2243   signals.CheckNoConnections();
2244
2245   {
2246     TestSlotDelegateHandler handlers;
2247     signals.SignalVoid1Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue );
2248     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2249     signals.EmitVoidSignalIntValue(5);
2250     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2251     DALI_TEST_EQUALS( handlers.mIntParam1, 5, TEST_LOCATION );
2252   }
2253   signals.CheckNoConnections();
2254
2255   {
2256     TestSlotDelegateHandler handlers;
2257     signals.SignalVoid2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue );
2258     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2259     signals.EmitVoidSignalIntValueIntValue(6, 7);
2260     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2261     DALI_TEST_EQUALS( handlers.mIntParam1, 6, TEST_LOCATION );
2262     DALI_TEST_EQUALS( handlers.mIntParam2, 7, TEST_LOCATION );
2263   }
2264   signals.CheckNoConnections();
2265
2266   {
2267     TestSlotDelegateHandler handlers;
2268     signals.SignalBool1Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue );
2269     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2270
2271     handlers.mBoolReturn = true;
2272     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION );
2273     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2274     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2275
2276     // repeat with opposite return value
2277     handlers.mBoolReturn = false;
2278     handlers.mHandled = false;
2279     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION );
2280     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2281     DALI_TEST_EQUALS( handlers.mFloatParam1, 6.0f, TEST_LOCATION );
2282   }
2283   signals.CheckNoConnections();
2284
2285   {
2286     TestSlotDelegateHandler handlers;
2287     signals.SignalBool2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue );
2288     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2289     handlers.mBoolReturn = true;
2290     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION );
2291     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2292     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2293     DALI_TEST_EQUALS( handlers.mIntParam2, 10, TEST_LOCATION );
2294   }
2295   signals.CheckNoConnections();
2296
2297   {
2298     TestSlotDelegateHandler handlers;
2299     signals.SignalInt2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue );
2300     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2301     handlers.mIntReturn = 27;
2302     int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
2303     DALI_TEST_EQUALS( x, 27, TEST_LOCATION );
2304     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2305     DALI_TEST_EQUALS( handlers.mFloatParam1, 33.5f, TEST_LOCATION );
2306     DALI_TEST_EQUALS( handlers.mIntParam2, 5, TEST_LOCATION );
2307   }
2308   signals.CheckNoConnections();
2309
2310   {
2311     TestSlotDelegateHandler handlers;
2312     signals.SignalFloat0().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid );
2313     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2314     handlers.mFloatReturn = 27.0f;
2315     float f = signals.EmitFloat0Signal();
2316     DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
2317     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2318     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
2319     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2320   }
2321   signals.CheckNoConnections();
2322
2323   {
2324     TestSlotDelegateHandler handlers;
2325     signals.SignalFloat2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue );
2326     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2327     handlers.mFloatReturn = 27.0f;
2328     float f = signals.EmitFloat2VSignal(5, 33.0f);
2329     DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
2330     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2331     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2332     DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
2333   }
2334   signals.CheckNoConnections();
2335
2336   {
2337     TestSlotDelegateHandler handlers;
2338     signals.VoidSignalFloatValue3().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotFloatValue3 );
2339     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2340     signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
2341     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2342     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2343     DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
2344     DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
2345   }
2346   signals.CheckNoConnections();
2347
2348   {
2349     TestSlotDelegateHandler handlers;
2350     signals.FloatSignalFloatValue3().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValue3 );
2351     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2352     handlers.mFloatReturn = 27.0f;
2353     float returnValue = signals.EmitFloatSignalFloatValue3(5, 33.0f, 100.0f);
2354     DALI_TEST_EQUALS( returnValue, 27.0f, TEST_LOCATION );
2355     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
2356     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
2357     DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
2358     DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
2359   }
2360   signals.CheckNoConnections();
2361   END_TEST;
2362 }
2363
2364 int UtcDaliSignalSlotDelegateDestruction(void)
2365 {
2366   // Test that signal disconnect works when slot-delegate is destroyed (goes out of scope)
2367
2368   {
2369     TestSignals::VoidRetNoParamSignal signal;
2370     {
2371       DALI_TEST_CHECK( signal.Empty() );
2372       TestSlotDelegateHandler handler;
2373       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
2374       DALI_TEST_CHECK( ! signal.Empty() );
2375     }
2376     // End of slot lifetime
2377     DALI_TEST_CHECK( signal.Empty() );
2378
2379     // Signal emission should be a NOOP
2380     signal.Emit();
2381   }
2382
2383   {
2384     TestSignals::VoidRet1ValueParamSignal signal;
2385     {
2386       DALI_TEST_CHECK( signal.Empty() );
2387       TestSlotDelegateHandler handler;
2388       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue );
2389       DALI_TEST_CHECK( ! signal.Empty() );
2390     }
2391     // End of slot lifetime
2392     DALI_TEST_CHECK( signal.Empty() );
2393
2394     // Signal emission should be a NOOP
2395     signal.Emit( 10 );
2396   }
2397
2398   {
2399     TestSignals::VoidRet1RefParamSignal signal;
2400     {
2401       DALI_TEST_CHECK( signal.Empty() );
2402       TestSlotDelegateHandler handler;
2403       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef );
2404       DALI_TEST_CHECK( ! signal.Empty() );
2405     }
2406     // End of slot lifetime
2407     DALI_TEST_CHECK( signal.Empty() );
2408
2409     // Signal emission should be a NOOP
2410     int temp( 5 );
2411     signal.Emit( temp );
2412   }
2413
2414   {
2415     TestSignals::VoidRet2ValueParamSignal signal;
2416     {
2417       DALI_TEST_CHECK( signal.Empty() );
2418       TestSlotDelegateHandler handler;
2419       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue );
2420       DALI_TEST_CHECK( ! signal.Empty() );
2421     }
2422     // End of slot lifetime
2423     DALI_TEST_CHECK( signal.Empty() );
2424
2425     // Signal emission should be a NOOP
2426     signal.Emit( 1, 2 );
2427   }
2428
2429   {
2430     TestSignals::BoolRet1ValueParamSignal signal;
2431     {
2432       DALI_TEST_CHECK( signal.Empty() );
2433       TestSlotDelegateHandler handler;
2434       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue );
2435       DALI_TEST_CHECK( ! signal.Empty() );
2436     }
2437     // End of slot lifetime
2438     DALI_TEST_CHECK( signal.Empty() );
2439
2440     // Signal emission should be a NOOP
2441     bool blah = signal.Emit( 1.0f );
2442     DALI_TEST_CHECK( ! blah );
2443   }
2444
2445   {
2446     TestSignals::BoolRet2ValueParamSignal signal;
2447     {
2448       DALI_TEST_CHECK( signal.Empty() );
2449       TestSlotDelegateHandler handler;
2450       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue );
2451       DALI_TEST_CHECK( ! signal.Empty() );
2452     }
2453     // End of slot lifetime
2454     DALI_TEST_CHECK( signal.Empty() );
2455
2456     // Signal emission should be a NOOP
2457     bool blah = signal.Emit( 1.0f, 2 );
2458     DALI_TEST_CHECK( ! blah );
2459   }
2460
2461   {
2462     TestSignals::IntRet2ValueParamSignal signal;
2463     {
2464       DALI_TEST_CHECK( signal.Empty() );
2465       TestSlotDelegateHandler handler;
2466       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue );
2467       DALI_TEST_CHECK( ! signal.Empty() );
2468     }
2469     // End of slot lifetime
2470     DALI_TEST_CHECK( signal.Empty() );
2471
2472     // Signal emission should be a NOOP
2473     int blah = signal.Emit( 10.0f, 100 );
2474     DALI_TEST_CHECK( 0 == blah );
2475   }
2476
2477   {
2478     TestSignals::FloatRet0ParamSignal signal;
2479     {
2480       DALI_TEST_CHECK( signal.Empty() );
2481       TestSlotDelegateHandler handler;
2482       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid );
2483       DALI_TEST_CHECK( ! signal.Empty() );
2484     }
2485     // End of slot lifetime
2486     DALI_TEST_CHECK( signal.Empty() );
2487
2488     // Signal emission should be a NOOP
2489     float blah = signal.Emit();
2490     DALI_TEST_CHECK( 0.0f == blah );
2491   }
2492
2493   {
2494     TestSignals::FloatRet2ValueParamSignal signal;
2495     {
2496       DALI_TEST_CHECK( signal.Empty() );
2497       TestSlotDelegateHandler handler;
2498       signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2499       DALI_TEST_CHECK( ! signal.Empty() );
2500     }
2501     // End of slot lifetime
2502     DALI_TEST_CHECK( signal.Empty() );
2503
2504     // Signal emission should be a NOOP
2505     float blah = signal.Emit( 3.0f, 4.0f );
2506     DALI_TEST_CHECK( 0.0f == blah );
2507   }
2508   END_TEST;
2509 }
2510
2511 int UtcDaliSlotHandlerDisconnect(void)
2512 {
2513   // Test that callbacks don't occur if a signal is disconnected before emission
2514
2515   TestSignals signals;
2516
2517   {
2518     TestSlotDelegateHandler handlers;
2519     signals.SignalVoidNone().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
2520     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2521     signals.SignalVoidNone().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
2522     signals.EmitVoidSignalVoid();
2523     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2524   }
2525
2526   {
2527     TestSlotDelegateHandler handlers;
2528     signals.SignalVoid1Ref().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
2529     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2530     int r = 7;
2531     handlers.mIntReturn = 5;
2532     signals.SignalVoid1Ref().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
2533     signals.EmitVoidSignalIntRef(r);
2534     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2535     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2536     DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
2537   }
2538
2539   {
2540     TestSlotDelegateHandler handlers;
2541     signals.SignalVoid1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
2542     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2543     signals.SignalVoid1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
2544     signals.EmitVoidSignalIntValue(5);
2545     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2546     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2547   }
2548
2549   {
2550     TestSlotDelegateHandler handlers;
2551     signals.SignalVoid2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
2552     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2553     signals.SignalVoid2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
2554     signals.EmitVoidSignalIntValueIntValue(5, 10);
2555     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2556     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2557     DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
2558   }
2559
2560   {
2561     TestSlotDelegateHandler handlers;
2562     signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2563     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2564     handlers.mBoolReturn = true;
2565     signals.SignalBool1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
2566     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
2567     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2568     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
2569   }
2570
2571   {
2572     TestSlotDelegateHandler handlers;
2573     signals.SignalBool2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2574     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2575     handlers.mBoolReturn = true;
2576     signals.SignalBool2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2577     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
2578     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2579     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
2580     DALI_TEST_EQUALS( handlers.mIntParam2,   0, TEST_LOCATION );
2581   }
2582
2583   {
2584     TestSlotDelegateHandler handlers;
2585     signals.SignalInt2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2586     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2587     handlers.mIntReturn = 27;
2588     signals.SignalInt2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2589     signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
2590     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2591     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2592     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2593   }
2594
2595   {
2596     TestSlotDelegateHandler handlers;
2597     signals.SignalFloat0().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2598     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2599     handlers.mFloatReturn = 27.0f;
2600     signals.SignalFloat0().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2601     signals.EmitFloat0Signal();
2602     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2603     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
2604     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2605   }
2606
2607   {
2608     TestSlotDelegateHandler handlers;
2609     signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2610     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2611     handlers.mFloatReturn = 27.0f;
2612     signals.SignalFloat2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2613     signals.EmitFloat2VSignal(5, 33.0f);
2614     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2615     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
2616     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2617   }
2618   END_TEST;
2619 }