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

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // EXTERNAL INCLUDES
  19 #include <iostream>
  20 #include <stdlib.h>
  21
  22 // INTERNAL INCLUDES
  23 #include <dali/public-api/dali-core.h>
  24 #include <dali-test-suite-utils.h>
  25 #include "signal-helper.h"
  26
  27 using namespace Dali;
  28
  29 void utc_dali_signal_templates_startup(void)
  30 {
  31   test_return_value = TET_UNDEF;
  32 }
  33
  34 void utc_dali_signal_templates_cleanup(void)
  35 {
  36   test_return_value = TET_PASS;
  37 }
  38
  39 namespace {
  40
  41
  42 bool wasStaticVoidCallbackVoidCalled  = false;
  43 bool wasStaticFloatCallbackVoidCalled = false;
  44 bool wasStaticVoidCallbackIntValueCalled = false;
  45 int staticIntValue = 0;
  46 bool wasStaticFloatCallbackFloatValueFloatValueCalled = false;
  47 float staticFloatValue1 = 0.0f;
  48 float staticFloatValue2 = 0.0f;
  49
  50 void StaticVoidCallbackVoid()
  51 {
  52   wasStaticVoidCallbackVoidCalled = true;
  53 }
  54
  55 void AlternativeVoidCallbackVoid()
  56 {
  57 }
  58
  59 float StaticFloatCallbackVoid()
  60 {
  61   wasStaticFloatCallbackVoidCalled = true;
  62   return 7.0f;
  63 }
  64
  65 void StaticVoidCallbackIntValue( int value )
  66 {
  67   wasStaticVoidCallbackIntValueCalled = true;
  68   staticIntValue = value;
  69 }
  70
  71 float StaticFloatCallbackFloatValueFloatValue( float value1, float value2 )
  72 {
  73   wasStaticFloatCallbackFloatValueFloatValueCalled = true;
  74   staticFloatValue1 = value1;
  75   staticFloatValue2 = value2;
  76   return value1 + value2;
  77 }
  78
  79 } // anon namespace
  80
  81
  82
  83 /*******************************************
  84  *
  85  * Start of Utc test cases.
  86  * Test cases performed in order of API listed in dali-signal.h
  87  * UtcDaliSignal + FunctionName + P=positive test, N = Negative test
  88  *
  89  */
  90
  91 int UtcDaliSignalEmptyP(void)
  92 {
  93   TestApplication app; // Create core for debug logging
  94
  95   // Test that Empty() is true, when no slots connected to the signal
  96
  97   {
  98     TestSignals::VoidRetNoParamSignal signal;
  99     DALI_TEST_CHECK( signal.Empty() );
 100   }
 101
 102   // Test that Empty() is true, when a slot has connected and disconnected
 103   {
 104     TestSignals::VoidRetNoParamSignal signal;
 105     TestSlotHandler handler;
 106     signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
 107     signal.Disconnect( &handler, &TestSlotHandler::VoidSlotVoid );
 108     DALI_TEST_CHECK( signal.Empty() );
 109   }
 110
 111   END_TEST;
 112 }
 113
 114 int UtcDaliSignalEmptyN(void)
 115 {
 116   TestApplication app; // Create core for debug logging
 117
 118   // Test that Empty() is false after signal connection
 119   TestSignals::VoidRetNoParamSignal signal;
 120   TestSlotHandler handler;
 121   signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
 122   DALI_TEST_CHECK( ! signal.Empty() );
 123
 124   END_TEST;
 125 }
 126
 127 int UtcDaliSignalGetConnectionCountP(void)
 128 {
 129   TestApplication app; // Create core for debug logging
 130
 131   TestSignals::VoidRetNoParamSignal signal;
 132   TestSlotHandler handler;
 133   signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
 134   DALI_TEST_CHECK( signal.GetConnectionCount() == 1 );
 135
 136   TestSlotHandler handler2;
 137   signal.Connect( &handler2, &TestSlotHandler::VoidSlotVoid );
 138   DALI_TEST_CHECK( signal.GetConnectionCount() == 2 );
 139
 140   END_TEST;
 141 }
 142
 143 int UtcDaliSignalGetConnectionCountN(void)
 144 {
 145   TestApplication app; // Create core for debug logging
 146   TestSignals::VoidRetNoParamSignal signal;
 147   DALI_TEST_CHECK( signal.GetConnectionCount() == 0 );
 148   END_TEST;
 149 }
 150
 151 /**
 152  * there are 5 different connection functions
 153  * we go through them here in order of definition in dali-signal.h
 154  */
 155 int UtcDaliSignalConnectP01(void)
 156 {
 157   TestApplication app; // Create core for debug logging
 158
 159   // test static function: void Connect( void (*func)() )
 160   TestSignals::VoidRetNoParamSignal signal;
 161   signal.Connect( StaticVoidCallbackVoid );
 162   DALI_TEST_CHECK( ! signal.Empty() );
 163
 164
 165   END_TEST;
 166 }
 167
 168 int UtcDaliSignalConnectN01(void)
 169 {
 170   // difficult to perform a negative test on Connect as no checks are performed
 171   // when creating a callback for a null function ( during Connect).
 172   // so we test an assert on Emit
 173   TestApplication app; // Create core for debug logging
 174
 175   TestSignals::VoidRetNoParamSignal signal;
 176   signal.Connect( NULL );
 177   try
 178   {
 179     signal.Emit();
 180   }
 181   catch (Dali::DaliException& e)
 182   {
 183     // Tests that a negative test of an assertion succeeds
 184     DALI_TEST_PRINT_ASSERT( e );
 185     tet_result(TET_PASS);
 186   }
 187   END_TEST;
 188 }
 189
 190
 191 int UtcDaliSignalConnectP02(void)
 192 {
 193   TestApplication app; // Create core for debug logging
 194
 195   // test member function: Connect( X* obj, void (X::*func)() ))
 196   TestSignals::VoidRetNoParamSignal signal;
 197   TestSlotHandler handler;
 198   signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
 199   DALI_TEST_CHECK( ! signal.Empty() );
 200   signal.Emit();
 201   DALI_TEST_CHECK( handler.mHandled == true );
 202   END_TEST;
 203 }
 204
 205 int UtcDaliSignalConnectN02(void)
 206 {
 207   TestApplication app; // Create core for debug logging
 208
 209   TestSignals::VoidRetNoParamSignal signal;
 210   try
 211   {
 212     // test member function: Connect( X* obj, void (X::*func)() )) with NULL object
 213     signal.Connect( static_cast<TestSlotHandler*>(NULL), &TestSlotHandler::VoidSlotVoid );
 214   }
 215   catch (Dali::DaliException& e)
 216   {
 217     // Tests that a negative test of an assertion succeeds
 218     DALI_TEST_PRINT_ASSERT( e );
 219     tet_result(TET_PASS);
 220   }
 221   END_TEST;
 222 }
 223
 224
 225 int UtcDaliSignalConnectP03(void)
 226 {
 227   TestApplication app; // Create core for debug logging
 228
 229   // test slot delegate: Connect( SlotDelegate<X>& delegate, void (X::*func)() )
 230   TestSignals::VoidRetNoParamSignal signal;
 231   TestSlotDelegateHandler handler;
 232   signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
 233   DALI_TEST_CHECK( ! signal.Empty() );
 234   signal.Emit();
 235   DALI_TEST_CHECK( handler.mHandled == true );
 236
 237   END_TEST;
 238 }
 239
 240 int UtcDaliSignalConnectN03(void)
 241 {
 242   TestApplication app; // Create core for debug logging
 243   // the delegate is passed by reference, so you can't pass null.
 244   tet_result( TET_PASS );
 245   END_TEST;
 246 }
 247
 248 int UtcDaliSignalConnectP04(void)
 249 {
 250   TestApplication app; // Create core for debug logging
 251
 252   //  test function object: Connect( ConnectionTrackerInterface* connectionTracker, const X& func )
 253   TestSlotHandler handler;
 254   TestSignals::VoidRetNoParamSignal signal;
 255   bool functorCalled(false);
 256   TestFunctor functor( functorCalled );
 257   signal.Connect( &handler, functor );
 258   DALI_TEST_CHECK( ! signal.Empty() );
 259   signal.Emit();
 260   DALI_TEST_CHECK( functorCalled == true );
 261
 262   END_TEST;
 263 }
 264
 265 int UtcDaliSignalConnectN04(void)
 266 {
 267   // for negative test we try to connect a null connection tracker to the signal
 268   TestSignals::VoidRetNoParamSignal signal;
 269   TestSlotHandler *nullHandler( NULL );
 270   try
 271   {
 272     signal.Connect( nullHandler , &TestSlotHandler::VoidSlotVoid  );
 273   }
 274   catch (Dali::DaliException& e)
 275   {
 276     // Tests that a negative test of an assertion succeeds
 277     DALI_TEST_PRINT_ASSERT( e );
 278     tet_result( TET_PASS );
 279   }
 280
 281   END_TEST;
 282
 283 }
 284
 285 int UtcDaliSignalConnectP05(void)
 286 {
 287   TestApplication app; // Create core for debug logging
 288
 289   // test function object using FunctorDelegate.
 290   // :Connect( ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate )
 291   TestSlotHandler handler;
 292   TestSignals::VoidRetNoParamSignal signal;
 293   bool functorDelegateCalled(false);
 294   signal.Connect( &handler, FunctorDelegate::New( VoidFunctorVoid(functorDelegateCalled) ));
 295   DALI_TEST_CHECK( ! signal.Empty() );
 296   signal.Emit();
 297   DALI_TEST_CHECK( functorDelegateCalled == true );
 298
 299   END_TEST;
 300 }
 301
 302 int UtcDaliSignalConnectN05(void)
 303 {
 304   TestApplication app; // Create core for debug logging
 305
 306   // for negative test we try to connect a null connection tracker to the signal
 307   // :Connect( ConnectionTrackerInterface == NULL, FunctorDelegate* delegate )
 308   TestSlotHandler *nullHandler( NULL );
 309   TestSignals::VoidRetNoParamSignal signal;
 310   bool functorDelegateCalled(false);
 311   try
 312   {
 313     signal.Connect( nullHandler, FunctorDelegate::New( VoidFunctorVoid(functorDelegateCalled) ));
 314   }
 315   catch (Dali::DaliException& e)
 316   {
 317     DALI_TEST_PRINT_ASSERT( e );
 318     tet_result( TET_PASS );
 319   }
 320   END_TEST;
 321 }
 322
 323
 324 /**
 325  * there 3 different disconnect functions
 326  *  we go through them here in order of definition in dali-signal.h
 327  */
 328 int UtcDaliSignalDisconnectP01(void)
 329 {
 330   TestApplication app; // Create core for debug logging
 331
 332   // test static function:  Disconnect( void (*func)( Arg0 arg0 ) )
 333
 334   TestSignals::VoidRetNoParamSignal signal;
 335   signal.Connect( StaticVoidCallbackVoid );
 336   DALI_TEST_CHECK( ! signal.Empty() );
 337   signal.Disconnect( StaticVoidCallbackVoid );
 338   DALI_TEST_CHECK( signal.Empty() );
 339
 340   END_TEST;
 341
 342  }
 343 int UtcDaliSignalDisconnectN01(void)
 344 {
 345   TestApplication app; // Create core for debug logging
 346
 347   // 1. Disconnect using the function
 348   TestSignals::VoidRetNoParamSignal signal;
 349   signal.Connect( StaticVoidCallbackVoid );
 350   DALI_TEST_CHECK( ! signal.Empty() );
 351
 352   signal.Disconnect( AlternativeVoidCallbackVoid );
 353
 354   DALI_TEST_CHECK( ! signal.Empty() );
 355
 356   END_TEST;
 357 }
 358
 359 int UtcDaliSignalDisconnectP02(void)
 360 {
 361   TestApplication app; // Create core for debug logging
 362
 363   // test member function: Disconnect( X* obj, void (X::*func)( Arg0 arg0 ) )
 364   TestSignals::VoidRetNoParamSignal signal;
 365   TestSlotHandler handler;
 366   signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
 367   DALI_TEST_CHECK( ! signal.Empty() );
 368   signal.Disconnect( &handler, &TestSlotHandler::VoidSlotVoid  );
 369   DALI_TEST_CHECK( signal.Empty() );
 370
 371   END_TEST;
 372
 373 }
 374 int UtcDaliSignalDisconnectN02(void)
 375 {
 376   TestApplication app; // Create core for debug logging
 377
 378   // 1. Disconnect using a null connection tracker
 379   TestSignals::VoidRetNoParamSignal signal;
 380   TestSlotHandler handler;
 381
 382   signal.Connect( &handler , &TestSlotHandler::VoidSlotVoid  );
 383   DALI_TEST_CHECK( !signal.Empty() );
 384
 385   try
 386   {
 387     TestSlotHandler* nullHandler( NULL );
 388     signal.Disconnect( nullHandler , &TestSlotHandler::VoidSlotVoid  );
 389   }
 390   catch(Dali::DaliException& e)
 391   {
 392     // Tests that a negative test of an assertion succeeds
 393     DALI_TEST_PRINT_ASSERT( e );
 394     DALI_TEST_CHECK( !signal.Empty() );
 395   }
 396   END_TEST;
 397 }
 398
 399 int UtcDaliSignalDisconnectP03(void)
 400 {
 401   TestApplication app; // Create core for debug logging
 402
 403   // test slot delegate: Disconnect( SlotDelegate<X>& delegate, void (X::*func)( Arg0 arg0 ) )
 404   TestSignals::VoidRetNoParamSignal signal;
 405   TestSlotDelegateHandler handler;
 406   signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
 407   DALI_TEST_CHECK( ! signal.Empty() );
 408   signal.Disconnect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
 409   DALI_TEST_CHECK( signal.Empty() );
 410
 411   END_TEST;
 412 }
 413
 414 int UtcDaliSignalDisconnectN03(void)
 415 {
 416   TestApplication app; // Create core for debug logging
 417
 418    // try to disconnect from the wrong signal
 419   TestSignals::VoidRetNoParamSignal signal;
 420   TestSlotDelegateHandler handler;
 421   signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
 422
 423   // use different signal
 424   signal.Disconnect( handler.mSlotDelegate , &TestSlotDelegateHandler::AlternativeVoidSlotVoid  );
 425
 426   DALI_TEST_CHECK( !signal.Empty() );
 427
 428   END_TEST;
 429
 430 }
 431
 432 /*******************************************
 433  *
 434  * End of Utc test cases for the individual API's of Signals
 435  * The following testing Signals functionality as a whole
 436  *
 437  *
 438  */
 439
 440 int UtcDaliSignalEmptyCheckSlotDestruction(void)
 441 {
 442   // Test that signal disconnect works when slot is destroyed (goes out of scope)
 443   {
 444     TestSignals::VoidRetNoParamSignal signal;
 445     {
 446       DALI_TEST_CHECK( signal.Empty() );
 447       TestSlotHandler handler;
 448       signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
 449       DALI_TEST_CHECK( ! signal.Empty() );
 450     }
 451     // End of slot lifetime
 452     DALI_TEST_CHECK( signal.Empty() );
 453
 454     // Signal emission should be a NOOP
 455     signal.Emit();
 456   }
 457
 458   {
 459     TestSignals::VoidRet1ValueParamSignal signal;
 460     {
 461       DALI_TEST_CHECK( signal.Empty() );
 462       TestSlotHandler handler;
 463       signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValue );
 464       DALI_TEST_CHECK( ! signal.Empty() );
 465     }
 466     // End of slot lifetime
 467     DALI_TEST_CHECK( signal.Empty() );
 468
 469     // Signal emission should be a NOOP
 470     signal.Emit( 10 );
 471   }
 472
 473   {
 474     TestSignals::VoidRet1RefParamSignal signal;
 475     {
 476       DALI_TEST_CHECK( signal.Empty() );
 477       TestSlotHandler handler;
 478       signal.Connect( &handler, &TestSlotHandler::VoidSlotIntRef );
 479       DALI_TEST_CHECK( ! signal.Empty() );
 480     }
 481     // End of slot lifetime
 482     DALI_TEST_CHECK( signal.Empty() );
 483
 484     // Signal emission should be a NOOP
 485     int temp( 5 );
 486     signal.Emit( temp );
 487   }
 488
 489   {
 490     TestSignals::VoidRet2ValueParamSignal signal;
 491     {
 492       DALI_TEST_CHECK( signal.Empty() );
 493       TestSlotHandler handler;
 494       signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValueIntValue );
 495       DALI_TEST_CHECK( ! signal.Empty() );
 496     }
 497     // End of slot lifetime
 498     DALI_TEST_CHECK( signal.Empty() );
 499
 500     // Signal emission should be a NOOP
 501     signal.Emit( 1, 2 );
 502   }
 503
 504   {
 505     TestSignals::BoolRet1ValueParamSignal signal;
 506     {
 507       DALI_TEST_CHECK( signal.Empty() );
 508       TestSlotHandler handler;
 509       signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValue );
 510       DALI_TEST_CHECK( ! signal.Empty() );
 511     }
 512     // End of slot lifetime
 513     DALI_TEST_CHECK( signal.Empty() );
 514
 515     // Signal emission should be a NOOP
 516     bool blah = signal.Emit( 1.0f );
 517     DALI_TEST_CHECK( ! blah );
 518   }
 519
 520   {
 521     TestSignals::BoolRet2ValueParamSignal signal;
 522     {
 523       DALI_TEST_CHECK( signal.Empty() );
 524       TestSlotHandler handler;
 525       signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValueIntValue );
 526       DALI_TEST_CHECK( ! signal.Empty() );
 527     }
 528     // End of slot lifetime
 529     DALI_TEST_CHECK( signal.Empty() );
 530
 531     // Signal emission should be a NOOP
 532     bool blah = signal.Emit( 1.0f, 2 );
 533     DALI_TEST_CHECK( ! blah );
 534   }
 535
 536   {
 537     TestSignals::IntRet2ValueParamSignal signal;
 538     {
 539       DALI_TEST_CHECK( signal.Empty() );
 540       TestSlotHandler handler;
 541       signal.Connect( &handler, &TestSlotHandler::IntSlotFloatValueIntValue );
 542       DALI_TEST_CHECK( ! signal.Empty() );
 543     }
 544     // End of slot lifetime
 545     DALI_TEST_CHECK( signal.Empty() );
 546
 547     // Signal emission should be a NOOP
 548     int blah = signal.Emit( 10.0f, 100 );
 549     DALI_TEST_CHECK( 0 == blah );
 550   }
 551
 552   {
 553     TestSignals::FloatRet0ParamSignal signal;
 554     {
 555       DALI_TEST_CHECK( signal.Empty() );
 556       TestSlotHandler handler;
 557       signal.Connect( &handler, &TestSlotHandler::FloatSlotVoid );
 558       DALI_TEST_CHECK( ! signal.Empty() );
 559     }
 560     // End of slot lifetime
 561     DALI_TEST_CHECK( signal.Empty() );
 562
 563     // Signal emission should be a NOOP
 564     float blah = signal.Emit();
 565     DALI_TEST_CHECK( 0.0f == blah );
 566   }
 567
 568   {
 569     TestSignals::FloatRet2ValueParamSignal signal;
 570     {
 571       DALI_TEST_CHECK( signal.Empty() );
 572       TestSlotHandler handler;
 573       signal.Connect(&handler, &TestSlotHandler::FloatSlotFloatValueFloatValue);
 574       DALI_TEST_CHECK( ! signal.Empty() );
 575     }
 576     // End of slot lifetime
 577     DALI_TEST_CHECK( signal.Empty() );
 578
 579     // Signal emission should be a NOOP
 580     float blah = signal.Emit( 3.0f, 4.0f );
 581     DALI_TEST_CHECK( 0.0f == blah );
 582   }
 583   END_TEST;
 584 }
 585
 586 // Positive test case for a method
 587 int UtcDaliSignalConnectAndEmit(void)
 588 {
 589   // Test basic signal emission for each slot type
 590
 591   TestSignals signals;
 592
 593   {
 594     TestSlotHandler handlers;
 595     signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
 596     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 597     signals.EmitVoidSignalVoid();
 598     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
 599
 600     // Test double emission
 601     handlers.mHandled = false;
 602     signals.EmitVoidSignalVoid();
 603     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
 604   }
 605   signals.CheckNoConnections();
 606
 607   {
 608     TestSlotHandler handlers;
 609     signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
 610     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 611     int x = 7;
 612     signals.EmitVoidSignalIntRef(x);
 613     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
 614     DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
 615   }
 616   signals.CheckNoConnections();
 617
 618   {
 619     TestSlotHandler handlers;
 620     signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
 621     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 622     signals.EmitVoidSignalIntValue(5);
 623     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
 624     DALI_TEST_EQUALS( handlers.mIntParam1, 5, TEST_LOCATION );
 625   }
 626   signals.CheckNoConnections();
 627
 628   {
 629     TestSlotHandler handlers;
 630     signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
 631     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 632     signals.EmitVoidSignalIntValueIntValue(6, 7);
 633     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
 634     DALI_TEST_EQUALS( handlers.mIntParam1, 6, TEST_LOCATION );
 635     DALI_TEST_EQUALS( handlers.mIntParam2, 7, TEST_LOCATION );
 636   }
 637   signals.CheckNoConnections();
 638
 639   {
 640     TestSlotHandler handlers;
 641     signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
 642     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 643
 644     handlers.mBoolReturn = true;
 645     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION );
 646     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
 647     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
 648
 649     // repeat with opposite return value
 650     handlers.mBoolReturn = false;
 651     handlers.mHandled = false;
 652     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION );
 653     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
 654     DALI_TEST_EQUALS( handlers.mFloatParam1, 6.0f, TEST_LOCATION );
 655   }
 656   signals.CheckNoConnections();
 657
 658   {
 659     TestSlotHandler handlers;
 660     signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
 661     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 662     handlers.mBoolReturn = true;
 663     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION );
 664     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
 665     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
 666     DALI_TEST_EQUALS( handlers.mIntParam2, 10, TEST_LOCATION );
 667   }
 668   signals.CheckNoConnections();
 669
 670   {
 671     TestSlotHandler handlers;
 672     signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
 673     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 674     handlers.mIntReturn = 27;
 675     int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
 676     DALI_TEST_EQUALS( x, 27, TEST_LOCATION );
 677     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
 678     DALI_TEST_EQUALS( handlers.mFloatParam1, 33.5f, TEST_LOCATION );
 679     DALI_TEST_EQUALS( handlers.mIntParam2, 5, TEST_LOCATION );
 680   }
 681   signals.CheckNoConnections();
 682
 683   {
 684     TestSlotHandler handlers;
 685     signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
 686     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 687     handlers.mFloatReturn = 27.0f;
 688     float f = signals.EmitFloat0Signal();
 689     DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
 690     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
 691     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
 692     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
 693   }
 694   signals.CheckNoConnections();
 695
 696   {
 697     TestSlotHandler handlers;
 698     signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
 699     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 700     handlers.mFloatReturn = 27.0f;
 701     float f = signals.EmitFloat2VSignal(5, 33.0f);
 702     DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
 703     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
 704     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
 705     DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
 706   }
 707   signals.CheckNoConnections();
 708
 709   {
 710     TestSlotHandler handlers;
 711     signals.VoidSignalFloatValue3().Connect(&handlers, &TestSlotHandler::VoidSlotFloatValue3);
 712     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 713     signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
 714     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
 715     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
 716     DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
 717     DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
 718   }
 719   signals.CheckNoConnections();
 720
 721   {
 722     TestSlotHandler handlers;
 723     signals.FloatSignalFloatValue3().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValue3);
 724     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 725     handlers.mFloatReturn = 27.0f;
 726     float returnValue = signals.EmitFloatSignalFloatValue3(5, 33.0f, 100.0f);
 727     DALI_TEST_EQUALS( returnValue, 27.0f, TEST_LOCATION );
 728     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
 729     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
 730     DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
 731     DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
 732   }
 733   signals.CheckNoConnections();
 734   END_TEST;
 735 }
 736
 737 int UtcDaliSignalDisconnect(void)
 738 {
 739   // Test that callbacks don't occur if a signal is disconnected before emission
 740
 741   TestSignals signals;
 742
 743   {
 744     TestSlotHandler handlers;
 745     signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
 746     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 747     signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
 748     signals.EmitVoidSignalVoid();
 749     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 750   }
 751
 752   {
 753     TestSlotHandler handlers;
 754     signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
 755     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 756     int r = 7;
 757     handlers.mIntReturn = 5;
 758     signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
 759     signals.EmitVoidSignalIntRef(r);
 760     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 761     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
 762     DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
 763   }
 764
 765   {
 766     TestSlotHandler handlers;
 767     signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
 768     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 769     signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
 770     signals.EmitVoidSignalIntValue(5);
 771     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 772     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
 773   }
 774
 775   {
 776     TestSlotHandler handlers;
 777     signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
 778     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 779     signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
 780     signals.EmitVoidSignalIntValueIntValue(5, 10);
 781     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 782     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
 783     DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
 784   }
 785
 786   {
 787     TestSlotHandler handlers;
 788     signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
 789     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 790     handlers.mBoolReturn = true;
 791     signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
 792     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
 793     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 794     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
 795   }
 796
 797   {
 798     TestSlotHandler handlers;
 799     signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
 800     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 801     handlers.mBoolReturn = true;
 802     signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
 803     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
 804     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 805     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
 806     DALI_TEST_EQUALS( handlers.mIntParam2,   0, TEST_LOCATION );
 807   }
 808
 809   {
 810     TestSlotHandler handlers;
 811     signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
 812     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 813     handlers.mIntReturn = 27;
 814     signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
 815     signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
 816     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 817     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
 818     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
 819   }
 820
 821   {
 822     TestSlotHandler handlers;
 823     signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
 824     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 825     handlers.mFloatReturn = 27.0f;
 826     signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
 827     signals.EmitFloat0Signal();
 828     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 829     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
 830     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
 831   }
 832
 833   {
 834     TestSlotHandler handlers;
 835     signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
 836     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 837     handlers.mFloatReturn = 27.0f;
 838     signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
 839     signals.EmitFloat2VSignal(5, 33.0f);
 840     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 841     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
 842     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
 843   }
 844   END_TEST;
 845 }
 846
 847 int UtcDaliSignalDisconnect2(void)
 848 {
 849   // Test that nothing happens when attempting to disconnect an unconnected slot
 850
 851   TestSignals signals;
 852   {
 853     TestSlotHandler handlers;
 854     signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
 855     signals.EmitVoidSignalVoid();
 856     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 857   }
 858
 859   {
 860     TestSlotHandler handlers;
 861     int r = 7;
 862     signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
 863     signals.EmitVoidSignalIntRef(r);
 864     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 865     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
 866     DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
 867   }
 868
 869   {
 870     TestSlotHandler handlers;
 871     signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
 872     signals.EmitVoidSignalIntValue(5);
 873     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 874     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
 875   }
 876
 877   {
 878     TestSlotHandler handlers;
 879     signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
 880     signals.EmitVoidSignalIntValueIntValue(5, 10);
 881     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 882     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
 883     DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
 884   }
 885
 886   {
 887     TestSlotHandler handlers;
 888     handlers.mBoolReturn = true;
 889     signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
 890     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
 891     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 892     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
 893   }
 894
 895   {
 896     TestSlotHandler handlers;
 897     handlers.mBoolReturn = true;
 898     signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
 899     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
 900     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 901     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
 902     DALI_TEST_EQUALS( handlers.mIntParam2,   0, TEST_LOCATION );
 903   }
 904
 905   {
 906     TestSlotHandler handlers;
 907     handlers.mIntReturn = 27;
 908     signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
 909     signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
 910     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 911     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
 912     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
 913   }
 914
 915   {
 916     TestSlotHandler handlers;
 917     handlers.mFloatReturn = 27.0f;
 918     signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
 919     signals.EmitFloat2VSignal(5, 33.0f);
 920     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 921     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
 922     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
 923   }
 924
 925   {
 926     TestSlotHandler handlers;
 927     handlers.mFloatReturn = 27.0f;
 928     signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
 929     signals.EmitFloat0Signal();
 930     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 931     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
 932     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
 933   }
 934   END_TEST;
 935 }
 936
 937 int UtcDaliSignalDisconnect3(void)
 938 {
 939   // Test that callbacks stop after a signal is disconnected
 940
 941   TestSignals signals;
 942
 943   {
 944     TestSlotHandler handlers;
 945     signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
 946     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 947
 948     // Emit first
 949     signals.EmitVoidSignalVoid();
 950     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
 951
 952     // Disconnect and emit again
 953     handlers.mHandled = false;
 954     signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
 955     signals.EmitVoidSignalVoid();
 956     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 957   }
 958
 959   {
 960     TestSlotHandler handlers;
 961     signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
 962     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 963     int r = 7;
 964
 965     // Emit first
 966     signals.EmitVoidSignalIntRef(r);
 967     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
 968     DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
 969
 970     // Disconnect and emit again
 971     handlers.mHandled = false;
 972     handlers.mIntParam1 = 0;
 973     signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
 974     signals.EmitVoidSignalIntRef(r);
 975     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
 976     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
 977     DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
 978   }
 979   END_TEST;
 980 }
 981
 982 int UtcDaliSignalCustomConnectionTracker(void)
 983 {
 984   // Test slot destruction
 985   {
 986     TestSignals::VoidRetNoParamSignal signal;
 987     {
 988       DALI_TEST_CHECK( signal.Empty() );
 989       TestBasicConnectionTrackerInterface customTracker;
 990       signal.Connect( &customTracker, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
 991       DALI_TEST_CHECK( ! signal.Empty() );
 992     }
 993     // End of slot lifetime
 994     DALI_TEST_CHECK( signal.Empty() );
 995
 996     // Signal emission should be a NOOP
 997     signal.Emit();
 998   }
 999
1000   TestBasicConnectionTrackerInterface customTracker2;
1001
1002   // Test signal emission & destruction
1003   {
1004     TestSignals::VoidRetNoParamSignal signal;
1005     DALI_TEST_CHECK( signal.Empty() );
1006     DALI_TEST_EQUALS( 0u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1007
1008     signal.Connect( &customTracker2, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
1009     DALI_TEST_CHECK( ! signal.Empty() );
1010     DALI_TEST_EQUALS( 1u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1011
1012     DALI_TEST_EQUALS( customTracker2.mCallbackHandled, false, TEST_LOCATION );
1013     signal.Emit();
1014     DALI_TEST_EQUALS( customTracker2.mCallbackHandled, true, TEST_LOCATION );
1015   }
1016   DALI_TEST_EQUALS( 0u, customTracker2.GetConnectionCount(), TEST_LOCATION );
1017   END_TEST;
1018 }
1019
1020 int UtcDaliSignalMultipleConnections(void)
1021 {
1022   // Test that multiple callbacks can be connected to the same signal
1023
1024   TestSignals signals;
1025
1026   {
1027     TestSlotHandler handler1;
1028     signals.SignalVoidNone().Connect( &handler1, &TestSlotHandler::VoidSlotVoid );
1029     DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1030
1031     TestSlotHandler handler2;
1032     signals.SignalVoidNone().Connect( &handler2, &TestSlotHandler::VoidSlotVoid );
1033     DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1034
1035     signals.EmitVoidSignalVoid();
1036     DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1037     DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1038
1039     // Remove first connection and repeat
1040     handler1.Reset();
1041     handler2.Reset();
1042     signals.SignalVoidNone().Disconnect( &handler1, &TestSlotHandler::VoidSlotVoid );
1043
1044     signals.EmitVoidSignalVoid();
1045     DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1046     DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1047   }
1048
1049   {
1050     TestSlotHandler handler1;
1051     signals.SignalVoid1Ref().Connect( &handler1, &TestSlotHandler::VoidSlotIntRef );
1052     DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1053
1054     TestSlotHandler handler2;
1055     signals.SignalVoid1Ref().Connect( &handler2, &TestSlotHandler::VoidSlotIntRef );
1056     DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1057
1058     int x = 7;
1059     signals.EmitVoidSignalIntRef(x);
1060     DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1061     DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1062     DALI_TEST_EQUALS( handler1.mIntParam1, 7, TEST_LOCATION );
1063     DALI_TEST_EQUALS( handler2.mIntParam1, 7, TEST_LOCATION );
1064
1065     // Remove second connection and repeat
1066     handler1.Reset();
1067     handler2.Reset();
1068     x = 8;
1069     signals.SignalVoid1Ref().Disconnect( &handler2, &TestSlotHandler::VoidSlotIntRef );
1070
1071     signals.EmitVoidSignalIntRef(x);
1072     DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1073     DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1074     DALI_TEST_EQUALS( handler1.mIntParam1, 8, TEST_LOCATION );
1075     DALI_TEST_EQUALS( handler2.mIntParam1, 0, TEST_LOCATION );
1076   }
1077
1078   {
1079     TestSlotHandler handler1;
1080     signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1081     DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1082
1083     TestSlotHandler handler2;
1084     signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1085     DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1086
1087     TestSlotHandler handler3;
1088     signals.SignalVoid1Value().Connect( &handler3, &TestSlotHandler::VoidSlotIntValue );
1089     DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
1090
1091     signals.EmitVoidSignalIntValue( 5 );
1092     DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1093     DALI_TEST_EQUALS( handler1.mIntParam1, 5, TEST_LOCATION );
1094     DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1095     DALI_TEST_EQUALS( handler2.mIntParam1, 5, TEST_LOCATION );
1096     DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1097     DALI_TEST_EQUALS( handler3.mIntParam1, 5, TEST_LOCATION );
1098
1099     // Remove middle connection and repeat
1100     handler1.Reset();
1101     handler2.Reset();
1102     handler3.Reset();
1103     signals.SignalVoid1Value().Disconnect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1104
1105     signals.EmitVoidSignalIntValue( 6 );
1106     DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1107     DALI_TEST_EQUALS( handler1.mIntParam1, 6, TEST_LOCATION );
1108     DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1109     DALI_TEST_EQUALS( handler2.mIntParam1, 0, TEST_LOCATION );
1110     DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1111     DALI_TEST_EQUALS( handler3.mIntParam1, 6, TEST_LOCATION );
1112   }
1113
1114   // Test that multiple callbacks are disconnected when a signal is destroyed
1115
1116   TestSlotHandler handler4;
1117   TestSlotHandler handler5;
1118   TestSlotHandler handler6;
1119
1120   {
1121     TestSignals::VoidRet1ValueParamSignal tempSignal;
1122
1123     DALI_TEST_EQUALS( handler4.GetConnectionCount(), 0u, TEST_LOCATION );
1124     DALI_TEST_EQUALS( handler5.GetConnectionCount(), 0u, TEST_LOCATION );
1125     DALI_TEST_EQUALS( handler6.GetConnectionCount(), 0u, TEST_LOCATION );
1126
1127     tempSignal.Connect( &handler4, &TestSlotHandler::VoidSlotIntValue );
1128     tempSignal.Connect( &handler5, &TestSlotHandler::VoidSlotIntValue );
1129     tempSignal.Connect( &handler6, &TestSlotHandler::VoidSlotIntValue );
1130
1131     DALI_TEST_EQUALS( handler4.GetConnectionCount(), 1u, TEST_LOCATION );
1132     DALI_TEST_EQUALS( handler5.GetConnectionCount(), 1u, TEST_LOCATION );
1133     DALI_TEST_EQUALS( handler6.GetConnectionCount(), 1u, TEST_LOCATION );
1134   }
1135   // End of tempSignal lifetime
1136
1137   DALI_TEST_EQUALS( handler4.GetConnectionCount(), 0u, TEST_LOCATION );
1138   DALI_TEST_EQUALS( handler5.GetConnectionCount(), 0u, TEST_LOCATION );
1139   DALI_TEST_EQUALS( handler6.GetConnectionCount(), 0u, TEST_LOCATION );
1140   END_TEST;
1141 }
1142
1143 int UtcDaliSignalMultipleConnections2(void)
1144 {
1145   TestSignals signals;
1146
1147   // Test that connecting the same callback twice is a NOOP
1148   {
1149     TestSlotHandler handler1;
1150
1151     // Note the double connection is intentional
1152     signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1153     signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1154     DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1155
1156     signals.EmitVoidSignalIntValue( 6 );
1157     DALI_TEST_EQUALS( handler1.mHandledCount, 1, TEST_LOCATION );
1158     DALI_TEST_EQUALS( handler1.mIntParam1, 6, TEST_LOCATION );
1159
1160     // Calling Disconnect once should be enough
1161     signals.SignalVoid1Value().Disconnect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1162     DALI_TEST_CHECK( signals.SignalVoid1Value().Empty() );
1163     handler1.mIntParam1 = 0;
1164
1165     signals.EmitVoidSignalIntValue( 7 );
1166     DALI_TEST_EQUALS( handler1.mHandledCount, 1/*not incremented since last check*/, TEST_LOCATION );
1167     DALI_TEST_EQUALS( handler1.mIntParam1, 0, TEST_LOCATION );
1168   }
1169
1170   // Test automatic disconnect after multiple Connect() calls
1171   {
1172     TestSlotHandler handler2;
1173     signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1174     signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
1175
1176     TestSlotHandler handler3;
1177     signals.SignalBool1Value().Connect( &handler3, &TestSlotHandler::BoolSlotFloatValue );
1178     signals.SignalBool1Value().Connect( &handler3, &TestSlotHandler::BoolSlotFloatValue );
1179
1180     DALI_TEST_EQUALS( handler2.mHandledCount, 0, TEST_LOCATION );
1181     DALI_TEST_EQUALS( handler3.mHandledCount, 0, TEST_LOCATION );
1182     DALI_TEST_CHECK( ! signals.SignalVoid1Value().Empty() );
1183     DALI_TEST_CHECK( ! signals.SignalBool1Value().Empty() );
1184   }
1185   DALI_TEST_CHECK( signals.SignalVoid1Value().Empty() );
1186   DALI_TEST_CHECK( signals.SignalBool1Value().Empty() );
1187
1188   // Should be NOOP
1189   signals.EmitVoidSignalIntValue( 1 );
1190   signals.EmitBoolSignalFloatValue( 1.0f );
1191
1192   // Test that connecting the same callback 10 times is a NOOP
1193   TestSlotHandler handler4;
1194   DALI_TEST_EQUALS( handler4.mHandledCount, 0, TEST_LOCATION );
1195   DALI_TEST_EQUALS( handler4.mFloatParam1, 0.0f, TEST_LOCATION );
1196
1197   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1198   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1199   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1200   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1201   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1202   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1203   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1204   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1205   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1206   signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1207
1208   signals.EmitBoolSignalFloatValue( 2.0f );
1209   DALI_TEST_EQUALS( handler4.mHandledCount, 1, TEST_LOCATION );
1210   DALI_TEST_EQUALS( handler4.mFloatParam1, 2.0f, TEST_LOCATION );
1211
1212   // Calling Disconnect once should be enough
1213   signals.SignalBool1Value().Disconnect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
1214   DALI_TEST_CHECK( signals.SignalBool1Value().Empty() );
1215
1216   signals.EmitBoolSignalFloatValue( 3.0f );
1217   DALI_TEST_EQUALS( handler4.mHandledCount, 1/*not incremented since last check*/, TEST_LOCATION );
1218   DALI_TEST_EQUALS( handler4.mFloatParam1, 2.0f, TEST_LOCATION );
1219   END_TEST;
1220 }
1221
1222 int UtcDaliSignalMultipleConnections3(void)
1223 {
1224   TestSignals signals;
1225
1226   // Test connecting two difference callbacks for the same ConnectionTracker
1227
1228   TestSlotHandler handler1;
1229
1230   {
1231     TestSignals::VoidRet1ValueParamSignal tempSignal;
1232
1233     DALI_TEST_EQUALS( handler1.GetConnectionCount(), 0u, TEST_LOCATION );
1234     DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1235     DALI_TEST_EQUALS( handler1.mIntParam1, 0, TEST_LOCATION );
1236
1237     // Note that the duplicate connection is deliberate
1238     tempSignal.Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
1239     tempSignal.Connect( &handler1, &TestSlotHandler::VoidDuplicateSlotIntValue );
1240
1241     DALI_TEST_EQUALS( handler1.GetConnectionCount(), 2u, TEST_LOCATION );
1242     DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
1243
1244     tempSignal.Emit( 10 );
1245
1246     DALI_TEST_EQUALS( handler1.mHandledCount, 2, TEST_LOCATION );
1247     DALI_TEST_EQUALS( handler1.mIntParam1, 10, TEST_LOCATION );
1248     DALI_TEST_EQUALS( handler1.mIntParam2, 10, TEST_LOCATION );
1249   }
1250   // End of tempSignal lifetime
1251
1252   DALI_TEST_EQUALS( handler1.GetConnectionCount(), 0u, TEST_LOCATION );
1253   END_TEST;
1254 }
1255
1256
1257 int UtcDaliSignalDisconnectStatic(void)
1258 {
1259   // void Func()
1260
1261   {
1262     TestSignals::VoidRetNoParamSignal signal;
1263     DALI_TEST_CHECK( signal.Empty() );
1264
1265     signal.Connect( StaticVoidCallbackVoid );
1266     DALI_TEST_CHECK( ! signal.Empty() );
1267
1268     wasStaticVoidCallbackVoidCalled = false;
1269     signal.Emit();
1270     DALI_TEST_EQUALS( wasStaticVoidCallbackVoidCalled, true, TEST_LOCATION );
1271
1272     signal.Disconnect( StaticVoidCallbackVoid );
1273     DALI_TEST_CHECK( signal.Empty() );
1274
1275     wasStaticVoidCallbackVoidCalled = false;
1276     signal.Emit();
1277     DALI_TEST_EQUALS( wasStaticVoidCallbackVoidCalled, false, TEST_LOCATION );
1278   }
1279
1280   // float Func()
1281
1282   {
1283     TestSignals::FloatRet0ParamSignal signal;
1284     DALI_TEST_CHECK( signal.Empty() );
1285
1286     signal.Connect( StaticFloatCallbackVoid );
1287     DALI_TEST_CHECK( ! signal.Empty() );
1288
1289     wasStaticFloatCallbackVoidCalled = false;
1290     float result = signal.Emit();
1291     DALI_TEST_EQUALS( wasStaticFloatCallbackVoidCalled, true, TEST_LOCATION );
1292     DALI_TEST_EQUALS( result, 7.0f, TEST_LOCATION );
1293
1294     signal.Disconnect( StaticFloatCallbackVoid );
1295     DALI_TEST_CHECK( signal.Empty() );
1296
1297     wasStaticFloatCallbackVoidCalled = false;
1298     result = signal.Emit();
1299     DALI_TEST_EQUALS( wasStaticFloatCallbackVoidCalled, false, TEST_LOCATION );
1300     DALI_TEST_EQUALS( result, 0.0f, TEST_LOCATION );
1301   }
1302
1303   // void Func( int )
1304
1305   {
1306     TestSignals::VoidRet1ValueParamSignal signal;
1307     DALI_TEST_CHECK( signal.Empty() );
1308
1309     signal.Connect( StaticVoidCallbackIntValue );
1310     DALI_TEST_CHECK( ! signal.Empty() );
1311
1312     wasStaticVoidCallbackIntValueCalled = false;
1313     staticIntValue = 0;
1314     signal.Emit( 10 );
1315     DALI_TEST_EQUALS( wasStaticVoidCallbackIntValueCalled, true, TEST_LOCATION );
1316     DALI_TEST_EQUALS( staticIntValue, 10, TEST_LOCATION );
1317
1318     signal.Disconnect( StaticVoidCallbackIntValue );
1319     DALI_TEST_CHECK( signal.Empty() );
1320
1321     wasStaticVoidCallbackIntValueCalled = false;
1322     staticIntValue = 0;
1323     signal.Emit( 11 );
1324     DALI_TEST_EQUALS( wasStaticVoidCallbackIntValueCalled, false, TEST_LOCATION );
1325     DALI_TEST_EQUALS( staticIntValue, 0, TEST_LOCATION );
1326   }
1327
1328   // float Func( float, float )
1329
1330   {
1331     TestSignals::FloatRet2ValueParamSignal signal;
1332     DALI_TEST_CHECK( signal.Empty() );
1333
1334     signal.Connect( StaticFloatCallbackFloatValueFloatValue );
1335     DALI_TEST_CHECK( ! signal.Empty() );
1336
1337     wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1338     staticFloatValue1 = 0.0f;
1339     staticFloatValue2 = 0.0f;
1340     float result = signal.Emit( 5.0f, 6.0f );
1341     DALI_TEST_EQUALS( wasStaticFloatCallbackFloatValueFloatValueCalled, true, TEST_LOCATION );
1342     DALI_TEST_EQUALS( staticFloatValue1, 5.0f, TEST_LOCATION );
1343     DALI_TEST_EQUALS( staticFloatValue2, 6.0f, TEST_LOCATION );
1344     DALI_TEST_EQUALS( result, 5.0f+6.0f, TEST_LOCATION );
1345
1346     signal.Disconnect( StaticFloatCallbackFloatValueFloatValue );
1347     DALI_TEST_CHECK( signal.Empty() );
1348
1349     wasStaticFloatCallbackFloatValueFloatValueCalled = false;
1350     staticFloatValue1 = 0.0f;
1351     staticFloatValue2 = 0.0f;
1352     result = signal.Emit( 7.0f, 8.0f );
1353     DALI_TEST_EQUALS( wasStaticFloatCallbackFloatValueFloatValueCalled, false, TEST_LOCATION );
1354     DALI_TEST_EQUALS( staticFloatValue1, 0.0f, TEST_LOCATION );
1355     DALI_TEST_EQUALS( staticFloatValue2, 0.0f, TEST_LOCATION );
1356     DALI_TEST_EQUALS( result, 0.0f, TEST_LOCATION );
1357   }
1358   END_TEST;
1359 }
1360
1361 int UtcDaliSignalDisconnectDuringCallback(void)
1362 {
1363   // Test disconnection during each callback
1364
1365   TestSignals::VoidRetNoParamSignal signal;
1366   DALI_TEST_CHECK( signal.Empty() );
1367
1368   TestSlotDisconnector handler1;
1369   handler1.VoidConnectVoid( signal );
1370   DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1371   DALI_TEST_CHECK( ! signal.Empty() );
1372
1373   signal.Emit();
1374   DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1375   DALI_TEST_CHECK( signal.Empty() );
1376
1377   // Repeat with 2 callbacks
1378
1379   handler1.mHandled = false;
1380
1381   TestSlotDisconnector handler2;
1382   handler1.VoidConnectVoid( signal );
1383   handler2.VoidConnectVoid( signal );
1384   DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1385   DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1386   DALI_TEST_CHECK( ! signal.Empty() );
1387
1388   signal.Emit();
1389   DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1390   DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1391   DALI_TEST_CHECK( signal.Empty() );
1392
1393   // Repeat with no callbacks
1394
1395   handler1.mHandled = false;
1396   handler2.mHandled = false;
1397
1398   signal.Emit();
1399   DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1400   DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1401
1402   // Repeat with 3 callbacks
1403
1404   TestSlotDisconnector handler3;
1405   handler1.VoidConnectVoid( signal );
1406   handler2.VoidConnectVoid( signal );
1407   handler3.VoidConnectVoid( signal );
1408   DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1409   DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1410   DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
1411   DALI_TEST_CHECK( ! signal.Empty() );
1412
1413   signal.Emit();
1414   DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
1415   DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
1416   DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
1417   DALI_TEST_CHECK( signal.Empty() );
1418
1419   // Repeat with no callbacks
1420
1421   handler1.mHandled = false;
1422   handler2.mHandled = false;
1423   handler3.mHandled = false;
1424
1425   signal.Emit();
1426   DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
1427   DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
1428   DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
1429   END_TEST;
1430 }
1431
1432 int UtcDaliSignalDisconnectDuringCallback2(void)
1433 {
1434   // Test disconnection of some (but not all) callbacks during sigmal emission
1435
1436   TestSignals::VoidRetNoParamSignal signal;
1437   DALI_TEST_CHECK( signal.Empty() );
1438
1439   TestSlotMultiDisconnector handler;
1440   handler.ConnectAll( signal );
1441   DALI_TEST_EQUALS( handler.mSlotHandled[0], false, TEST_LOCATION );
1442   DALI_TEST_EQUALS( handler.mSlotHandled[1], false, TEST_LOCATION );
1443   DALI_TEST_EQUALS( handler.mSlotHandled[2], false, TEST_LOCATION );
1444   DALI_TEST_EQUALS( handler.mSlotHandled[3], false, TEST_LOCATION );
1445   DALI_TEST_EQUALS( handler.mSlotHandled[4], false, TEST_LOCATION );
1446   DALI_TEST_EQUALS( handler.mSlotHandled[5], false, TEST_LOCATION );
1447   DALI_TEST_EQUALS( handler.mSlotHandled[6], false, TEST_LOCATION );
1448   DALI_TEST_EQUALS( handler.mSlotHandled[7], false, TEST_LOCATION );
1449   DALI_TEST_EQUALS( handler.mSlotHandled[8], false, TEST_LOCATION );
1450   DALI_TEST_EQUALS( handler.mSlotHandled[9], false, TEST_LOCATION );
1451   DALI_TEST_CHECK( ! signal.Empty() );
1452
1453   signal.Emit();
1454
1455   // Slots 5, 7, & 9 should be disconnected before being called
1456   DALI_TEST_EQUALS( handler.mSlotHandled[0], true, TEST_LOCATION );
1457   DALI_TEST_EQUALS( handler.mSlotHandled[1], true, TEST_LOCATION );
1458   DALI_TEST_EQUALS( handler.mSlotHandled[2], true, TEST_LOCATION );
1459   DALI_TEST_EQUALS( handler.mSlotHandled[3], true, TEST_LOCATION );
1460   DALI_TEST_EQUALS( handler.mSlotHandled[4], true, TEST_LOCATION );
1461   DALI_TEST_EQUALS( handler.mSlotHandled[5], false, TEST_LOCATION );
1462   DALI_TEST_EQUALS( handler.mSlotHandled[6], true, TEST_LOCATION );
1463   DALI_TEST_EQUALS( handler.mSlotHandled[7], false, TEST_LOCATION );
1464   DALI_TEST_EQUALS( handler.mSlotHandled[8], true, TEST_LOCATION );
1465   DALI_TEST_EQUALS( handler.mSlotHandled[9], false, TEST_LOCATION );
1466   DALI_TEST_CHECK( ! signal.Empty() );
1467
1468   // Odd slots are disconnected
1469   DALI_TEST_EQUALS( handler.GetConnectionCount(), 5u, TEST_LOCATION );
1470   END_TEST;
1471 }
1472
1473 int UtcDaliSignalEmitDuringCallback(void)
1474 {
1475   TestApplication app; // Create core for debug logging
1476
1477   TestSignals::VoidRetNoParamSignal signal;
1478   DALI_TEST_CHECK( signal.Empty() );
1479
1480   TestEmitDuringCallback handler1;
1481   handler1.VoidConnectVoid( signal );
1482
1483   // Test that this does not result in an infinite loop!
1484   signal.Emit();
1485   END_TEST;
1486 }
1487
1488 int UtcDaliSignalTestApp01(void)
1489 {
1490   // Test 1 signal connected to 1 Slot.
1491   // Signal dies first.
1492
1493   TestButton* button = new TestButton(1);
1494   TestApp app;
1495   button->DownSignal().Connect(&app,&TestApp::OnButtonPress);
1496
1497   // check we have both the button, and the app have 1 connection
1498   DALI_TEST_EQUALS( app.GetConnectionCount(), 1u, TEST_LOCATION );
1499   DALI_TEST_EQUALS( button->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
1500
1501   delete button;  // should automatically destroy the connection
1502
1503   // check we have a 0 connections
1504   DALI_TEST_EQUALS( app.GetConnectionCount(), 0u, TEST_LOCATION );
1505
1506   END_TEST;
1507 }
1508
1509 int UtcDaliSignalTestApp02(void)
1510 {
1511   // Test 1 signal connected to 1 Slot.
1512   // Slot owning object dies first.
1513
1514   TestButton button(1);
1515   TestApp *app = new TestApp;
1516   button.DownSignal().Connect( app, &TestApp::OnButtonPress);
1517
1518   // check we have a 1 connection
1519   DALI_TEST_EQUALS( app->GetConnectionCount(), 1u, TEST_LOCATION );
1520   DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
1521
1522   delete app;  // should automatically destroy the connection
1523
1524   // check we have a 0 connections
1525   DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION );
1526   END_TEST;
1527 }
1528
1529 int UtcDaliSignalTestApp03(void)
1530 {
1531   // Test 1 Signal connect to 2 slots
1532   // 1 of the slot owners dies. Then the second slot owner dies
1533
1534   TestButton button(1);
1535   TestApp *app1 = new TestApp;
1536   TestApp *app2 = new TestApp;
1537
1538   button.DownSignal().Connect( app1, &TestApp::OnButtonPress);
1539   button.DownSignal().Connect( app2, &TestApp::OnButtonPress);
1540
1541     // check we have a 2 connections to the signal
1542   DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 2u, TEST_LOCATION );
1543
1544   // kill the first slot
1545   delete app1;  // should automatically destroy the connection
1546
1547   // check we have 1 connection left
1548   DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
1549
1550   button.Press();   // emit the signal (to ensure it doesn't seg fault)
1551
1552   // kill the second slot
1553   delete app2;  // should automatically destroy the connection
1554
1555   // check we have 1 connection left
1556   DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION );
1557
1558   END_TEST;
1559 }
1560
1561 int UtcDaliSignalTestApp04(void)
1562 {
1563   // Test 1 Signal connected to 2 slots (with different owners)
1564   // The Signal dies, check the 2 slots disconnect automatically
1565
1566   TestButton* button = new TestButton(1);
1567   TestApp app1;
1568   TestApp app2;
1569
1570   button->DownSignal().Connect(&app1,&TestApp::OnButtonPress);
1571   button->DownSignal().Connect(&app2,&TestApp::OnButtonPress);
1572
1573   // check the connection counts
1574   DALI_TEST_EQUALS( app1.GetConnectionCount(), 1u, TEST_LOCATION );
1575   DALI_TEST_EQUALS( app2.GetConnectionCount(), 1u, TEST_LOCATION );
1576   DALI_TEST_EQUALS( button->DownSignal().GetConnectionCount(), 2u, TEST_LOCATION );
1577
1578   delete button;  // should automatically destroy the connection
1579
1580   // check both slot owners have zero connections
1581   DALI_TEST_EQUALS( app1.GetConnectionCount(), 0u, TEST_LOCATION );
1582   DALI_TEST_EQUALS( app2.GetConnectionCount(), 0u, TEST_LOCATION );
1583   END_TEST;
1584 }
1585
1586 int UtcDaliSignalTestApp05(void)
1587 {
1588   // Test 2 Signals (with different owners)  connected to 1 slots
1589   // 1 Signal dies, check that the remaining connection is valid
1590
1591   TestButton* button1 = new TestButton(1); // use for signal 1
1592   TestButton* button2 = new TestButton(2); // use for signal 2
1593
1594   TestApp app;
1595
1596   button1->DownSignal().Connect(&app,&TestApp::OnButtonPress);
1597   button2->DownSignal().Connect(&app,&TestApp::OnButtonPress);
1598
1599   // check the connection counts
1600   DALI_TEST_EQUALS( app.GetConnectionCount(), 2u, TEST_LOCATION );
1601   DALI_TEST_EQUALS( button1->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
1602   DALI_TEST_EQUALS( button2->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
1603
1604   // make sure both signals emit ok
1605   button2->Press();
1606   DALI_TEST_EQUALS( app.GetButtonPressedId() , 2 , TEST_LOCATION );
1607
1608   button1->Press();
1609   DALI_TEST_EQUALS( app.GetButtonPressedId() , 1 , TEST_LOCATION );
1610
1611   delete button1;  // should automatically destroy 1 connection
1612
1613   // check both slot owners have zero connections
1614   DALI_TEST_EQUALS( app.GetConnectionCount(), 1u, TEST_LOCATION );
1615
1616   // check remaining connection still works
1617   button2->Press();
1618   DALI_TEST_EQUALS( app.GetButtonPressedId() , 2 , TEST_LOCATION );
1619
1620   // kill the last signal
1621   delete button2;
1622   DALI_TEST_EQUALS( app.GetConnectionCount(), 0u, TEST_LOCATION );
1623   END_TEST;
1624 }
1625
1626 int UtcDaliSignalTestApp06(void)
1627 {
1628   Signal< bool () > boolSignal;
1629   TestApp app;
1630   bool result(false);
1631
1632   // connect a slot which will return false
1633   boolSignal.Connect( &app, &TestApp::BoolReturnTestFalse);
1634   result = boolSignal.Emit();
1635   DALI_TEST_EQUALS( result, false, TEST_LOCATION );
1636
1637   // disconnect last slot, and connect a slot which returns true
1638   boolSignal.Disconnect( &app, &TestApp::BoolReturnTestFalse);
1639   boolSignal.Connect( &app, &TestApp::BoolReturnTestTrue);
1640   result = boolSignal.Emit();
1641   DALI_TEST_EQUALS( result, true, TEST_LOCATION );
1642   END_TEST;
1643 }
1644
1645 int UtcDaliSlotDelegateConnection(void)
1646 {
1647   TestSignals signals;
1648
1649   {
1650     TestSlotDelegateHandler handlers;
1651     signals.SignalVoidNone().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
1652     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1653     signals.EmitVoidSignalVoid();
1654     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1655
1656     // Test double emission
1657     handlers.mHandled = false;
1658     signals.EmitVoidSignalVoid();
1659     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1660   }
1661   signals.CheckNoConnections();
1662
1663   {
1664     TestSlotDelegateHandler handlers;
1665     signals.SignalVoid1Ref().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef );
1666     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1667     int x = 7;
1668     signals.EmitVoidSignalIntRef(x);
1669     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1670     DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
1671   }
1672   signals.CheckNoConnections();
1673
1674   {
1675     TestSlotDelegateHandler handlers;
1676     signals.SignalVoid1Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue );
1677     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1678     signals.EmitVoidSignalIntValue(5);
1679     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1680     DALI_TEST_EQUALS( handlers.mIntParam1, 5, TEST_LOCATION );
1681   }
1682   signals.CheckNoConnections();
1683
1684   {
1685     TestSlotDelegateHandler handlers;
1686     signals.SignalVoid2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue );
1687     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1688     signals.EmitVoidSignalIntValueIntValue(6, 7);
1689     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1690     DALI_TEST_EQUALS( handlers.mIntParam1, 6, TEST_LOCATION );
1691     DALI_TEST_EQUALS( handlers.mIntParam2, 7, TEST_LOCATION );
1692   }
1693   signals.CheckNoConnections();
1694
1695   {
1696     TestSlotDelegateHandler handlers;
1697     signals.SignalBool1Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue );
1698     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1699
1700     handlers.mBoolReturn = true;
1701     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION );
1702     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1703     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1704
1705     // repeat with opposite return value
1706     handlers.mBoolReturn = false;
1707     handlers.mHandled = false;
1708     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION );
1709     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1710     DALI_TEST_EQUALS( handlers.mFloatParam1, 6.0f, TEST_LOCATION );
1711   }
1712   signals.CheckNoConnections();
1713
1714   {
1715     TestSlotDelegateHandler handlers;
1716     signals.SignalBool2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue );
1717     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1718     handlers.mBoolReturn = true;
1719     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION );
1720     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1721     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1722     DALI_TEST_EQUALS( handlers.mIntParam2, 10, TEST_LOCATION );
1723   }
1724   signals.CheckNoConnections();
1725
1726   {
1727     TestSlotDelegateHandler handlers;
1728     signals.SignalInt2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue );
1729     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1730     handlers.mIntReturn = 27;
1731     int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
1732     DALI_TEST_EQUALS( x, 27, TEST_LOCATION );
1733     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1734     DALI_TEST_EQUALS( handlers.mFloatParam1, 33.5f, TEST_LOCATION );
1735     DALI_TEST_EQUALS( handlers.mIntParam2, 5, TEST_LOCATION );
1736   }
1737   signals.CheckNoConnections();
1738
1739   {
1740     TestSlotDelegateHandler handlers;
1741     signals.SignalFloat0().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid );
1742     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1743     handlers.mFloatReturn = 27.0f;
1744     float f = signals.EmitFloat0Signal();
1745     DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
1746     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1747     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1748     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
1749   }
1750   signals.CheckNoConnections();
1751
1752   {
1753     TestSlotDelegateHandler handlers;
1754     signals.SignalFloat2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue );
1755     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1756     handlers.mFloatReturn = 27.0f;
1757     float f = signals.EmitFloat2VSignal(5, 33.0f);
1758     DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
1759     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1760     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1761     DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1762   }
1763   signals.CheckNoConnections();
1764
1765   {
1766     TestSlotDelegateHandler handlers;
1767     signals.VoidSignalFloatValue3().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotFloatValue3 );
1768     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1769     signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
1770     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1771     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1772     DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1773     DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
1774   }
1775   signals.CheckNoConnections();
1776
1777   {
1778     TestSlotDelegateHandler handlers;
1779     signals.FloatSignalFloatValue3().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValue3 );
1780     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1781     handlers.mFloatReturn = 27.0f;
1782     float returnValue = signals.EmitFloatSignalFloatValue3(5, 33.0f, 100.0f);
1783     DALI_TEST_EQUALS( returnValue, 27.0f, TEST_LOCATION );
1784     DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
1785     DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
1786     DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
1787     DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
1788   }
1789   signals.CheckNoConnections();
1790   END_TEST;
1791 }
1792
1793 int UtcDaliSignalSlotDelegateDestruction(void)
1794 {
1795   // Test that signal disconnect works when slot-delegate is destroyed (goes out of scope)
1796
1797   {
1798     TestSignals::VoidRetNoParamSignal signal;
1799     {
1800       DALI_TEST_CHECK( signal.Empty() );
1801       TestSlotDelegateHandler handler;
1802       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
1803       DALI_TEST_CHECK( ! signal.Empty() );
1804     }
1805     // End of slot lifetime
1806     DALI_TEST_CHECK( signal.Empty() );
1807
1808     // Signal emission should be a NOOP
1809     signal.Emit();
1810   }
1811
1812   {
1813     TestSignals::VoidRet1ValueParamSignal signal;
1814     {
1815       DALI_TEST_CHECK( signal.Empty() );
1816       TestSlotDelegateHandler handler;
1817       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue );
1818       DALI_TEST_CHECK( ! signal.Empty() );
1819     }
1820     // End of slot lifetime
1821     DALI_TEST_CHECK( signal.Empty() );
1822
1823     // Signal emission should be a NOOP
1824     signal.Emit( 10 );
1825   }
1826
1827   {
1828     TestSignals::VoidRet1RefParamSignal signal;
1829     {
1830       DALI_TEST_CHECK( signal.Empty() );
1831       TestSlotDelegateHandler handler;
1832       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef );
1833       DALI_TEST_CHECK( ! signal.Empty() );
1834     }
1835     // End of slot lifetime
1836     DALI_TEST_CHECK( signal.Empty() );
1837
1838     // Signal emission should be a NOOP
1839     int temp( 5 );
1840     signal.Emit( temp );
1841   }
1842
1843   {
1844     TestSignals::VoidRet2ValueParamSignal signal;
1845     {
1846       DALI_TEST_CHECK( signal.Empty() );
1847       TestSlotDelegateHandler handler;
1848       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue );
1849       DALI_TEST_CHECK( ! signal.Empty() );
1850     }
1851     // End of slot lifetime
1852     DALI_TEST_CHECK( signal.Empty() );
1853
1854     // Signal emission should be a NOOP
1855     signal.Emit( 1, 2 );
1856   }
1857
1858   {
1859     TestSignals::BoolRet1ValueParamSignal signal;
1860     {
1861       DALI_TEST_CHECK( signal.Empty() );
1862       TestSlotDelegateHandler handler;
1863       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue );
1864       DALI_TEST_CHECK( ! signal.Empty() );
1865     }
1866     // End of slot lifetime
1867     DALI_TEST_CHECK( signal.Empty() );
1868
1869     // Signal emission should be a NOOP
1870     bool blah = signal.Emit( 1.0f );
1871     DALI_TEST_CHECK( ! blah );
1872   }
1873
1874   {
1875     TestSignals::BoolRet2ValueParamSignal signal;
1876     {
1877       DALI_TEST_CHECK( signal.Empty() );
1878       TestSlotDelegateHandler handler;
1879       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue );
1880       DALI_TEST_CHECK( ! signal.Empty() );
1881     }
1882     // End of slot lifetime
1883     DALI_TEST_CHECK( signal.Empty() );
1884
1885     // Signal emission should be a NOOP
1886     bool blah = signal.Emit( 1.0f, 2 );
1887     DALI_TEST_CHECK( ! blah );
1888   }
1889
1890   {
1891     TestSignals::IntRet2ValueParamSignal signal;
1892     {
1893       DALI_TEST_CHECK( signal.Empty() );
1894       TestSlotDelegateHandler handler;
1895       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue );
1896       DALI_TEST_CHECK( ! signal.Empty() );
1897     }
1898     // End of slot lifetime
1899     DALI_TEST_CHECK( signal.Empty() );
1900
1901     // Signal emission should be a NOOP
1902     int blah = signal.Emit( 10.0f, 100 );
1903     DALI_TEST_CHECK( 0 == blah );
1904   }
1905
1906   {
1907     TestSignals::FloatRet0ParamSignal signal;
1908     {
1909       DALI_TEST_CHECK( signal.Empty() );
1910       TestSlotDelegateHandler handler;
1911       signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid );
1912       DALI_TEST_CHECK( ! signal.Empty() );
1913     }
1914     // End of slot lifetime
1915     DALI_TEST_CHECK( signal.Empty() );
1916
1917     // Signal emission should be a NOOP
1918     float blah = signal.Emit();
1919     DALI_TEST_CHECK( 0.0f == blah );
1920   }
1921
1922   {
1923     TestSignals::FloatRet2ValueParamSignal signal;
1924     {
1925       DALI_TEST_CHECK( signal.Empty() );
1926       TestSlotDelegateHandler handler;
1927       signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
1928       DALI_TEST_CHECK( ! signal.Empty() );
1929     }
1930     // End of slot lifetime
1931     DALI_TEST_CHECK( signal.Empty() );
1932
1933     // Signal emission should be a NOOP
1934     float blah = signal.Emit( 3.0f, 4.0f );
1935     DALI_TEST_CHECK( 0.0f == blah );
1936   }
1937   END_TEST;
1938 }
1939
1940 int UtcDaliSlotHandlerDisconnect(void)
1941 {
1942   // Test that callbacks don't occur if a signal is disconnected before emission
1943
1944   TestSignals signals;
1945
1946   {
1947     TestSlotDelegateHandler handlers;
1948     signals.SignalVoidNone().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
1949     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1950     signals.SignalVoidNone().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
1951     signals.EmitVoidSignalVoid();
1952     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1953   }
1954
1955   {
1956     TestSlotDelegateHandler handlers;
1957     signals.SignalVoid1Ref().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
1958     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1959     int r = 7;
1960     handlers.mIntReturn = 5;
1961     signals.SignalVoid1Ref().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
1962     signals.EmitVoidSignalIntRef(r);
1963     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1964     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1965     DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
1966   }
1967
1968   {
1969     TestSlotDelegateHandler handlers;
1970     signals.SignalVoid1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
1971     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1972     signals.SignalVoid1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
1973     signals.EmitVoidSignalIntValue(5);
1974     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1975     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1976   }
1977
1978   {
1979     TestSlotDelegateHandler handlers;
1980     signals.SignalVoid2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
1981     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1982     signals.SignalVoid2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
1983     signals.EmitVoidSignalIntValueIntValue(5, 10);
1984     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1985     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
1986     DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
1987   }
1988
1989   {
1990     TestSlotDelegateHandler handlers;
1991     signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
1992     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1993     handlers.mBoolReturn = true;
1994     signals.SignalBool1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
1995     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
1996     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
1997     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
1998   }
1999
2000   {
2001     TestSlotDelegateHandler handlers;
2002     signals.SignalBool2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2003     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2004     handlers.mBoolReturn = true;
2005     signals.SignalBool2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
2006     DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
2007     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2008     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
2009     DALI_TEST_EQUALS( handlers.mIntParam2,   0, TEST_LOCATION );
2010   }
2011
2012   {
2013     TestSlotDelegateHandler handlers;
2014     signals.SignalInt2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2015     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2016     handlers.mIntReturn = 27;
2017     signals.SignalInt2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
2018     signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
2019     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2020     DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
2021     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2022   }
2023
2024   {
2025     TestSlotDelegateHandler handlers;
2026     signals.SignalFloat0().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2027     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2028     handlers.mFloatReturn = 27.0f;
2029     signals.SignalFloat0().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
2030     signals.EmitFloat0Signal();
2031     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2032     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
2033     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2034   }
2035
2036   {
2037     TestSlotDelegateHandler handlers;
2038     signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2039     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2040     handlers.mFloatReturn = 27.0f;
2041     signals.SignalFloat2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
2042     signals.EmitFloat2VSignal(5, 33.0f);
2043     DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
2044     DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
2045     DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
2046   }
2047   END_TEST;
2048 }