automated-tests/src/dali/utc-Dali-Stage.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 #include <iostream>
  19
  20 #include <stdlib.h>
  21
  22 #include <dali/public-api/dali-core.h>
  23 #include <dali/integration-api/context-notifier.h>
  24 #include <dali/integration-api/events/key-event-integ.h>
  25 #include <dali/integration-api/events/touch-event-integ.h>
  26 #include <dali/devel-api/dynamics/dynamics.h>
  27
  28 #include <dali-test-suite-utils.h>
  29
  30 using namespace Dali;
  31
  32 void stage_test_startup(void)
  33 {
  34   test_return_value = TET_UNDEF;
  35 }
  36
  37 void stage_test_cleanup(void)
  38 {
  39   test_return_value = TET_PASS;
  40 }
  41
  42 namespace
  43 {
  44
  45 /**
  46  * Functor for EventProcessingFinished signal
  47  */
  48 struct EventProcessingFinishedFunctor
  49 {
  50   /**
  51    * @param[in] eventProcessingFinished reference to a boolean variable used to check if signal has been called.
  52    */
  53   EventProcessingFinishedFunctor( bool& eventProcessingFinished )
  54   : mEventProcessingFinished( eventProcessingFinished )
  55   {}
  56
  57   void operator()()
  58   {
  59     mEventProcessingFinished = true;
  60   }
  61
  62   bool& mEventProcessingFinished;
  63 };
  64
  65 // Stores data that is populated in the key-event callback and will be read by the TET cases
  66 struct KeyEventSignalData
  67 {
  68   KeyEventSignalData()
  69   : functorCalled(false)
  70   {}
  71
  72   void Reset()
  73   {
  74     functorCalled = false;
  75
  76     receivedKeyEvent.keyModifier = 0;
  77     receivedKeyEvent.keyPressedName.clear();
  78     receivedKeyEvent.keyPressed.clear();
  79   }
  80
  81   bool functorCalled;
  82   KeyEvent receivedKeyEvent;
  83 };
  84
  85 // Functor that sets the data when called
  86 struct KeyEventReceivedFunctor
  87 {
  88   KeyEventReceivedFunctor( KeyEventSignalData& data ) : signalData( data ) { }
  89
  90   bool operator()( const KeyEvent& keyEvent )
  91   {
  92     signalData.functorCalled = true;
  93     signalData.receivedKeyEvent = keyEvent;
  94
  95     return true;
  96   }
  97
  98   KeyEventSignalData& signalData;
  99 };
 100
 101 // Stores data that is populated in the touched signal callback and will be read by the TET cases
 102 struct TouchedSignalData
 103 {
 104   TouchedSignalData()
 105   : functorCalled(false)
 106   {}
 107
 108   void Reset()
 109   {
 110     functorCalled = false;
 111
 112     receivedTouchEvent.points.clear();
 113     receivedTouchEvent.time = 0;
 114   }
 115
 116   bool functorCalled;
 117   TouchEvent receivedTouchEvent;
 118 };
 119
 120 // Functor that sets the data when touched signal is received
 121 struct TouchedFunctor
 122 {
 123   TouchedFunctor( TouchedSignalData& data ) : signalData( data ) { }
 124
 125   void operator()( const TouchEvent& touch )
 126   {
 127     signalData.functorCalled = true;
 128     signalData.receivedTouchEvent = touch;
 129   }
 130
 131   TouchedSignalData& signalData;
 132 };
 133
 134 bool DummyTouchCallback( Actor actor, const TouchEvent& touch )
 135 {
 136   return true;
 137 }
 138
 139
 140 struct ContextStatusFunctor
 141 {
 142   ContextStatusFunctor(bool& calledFlag) : mCalledFlag( calledFlag )
 143   {
 144     mCalledFlag = false;
 145   }
 146
 147   void operator()()
 148   {
 149     mCalledFlag = true;
 150   }
 151   void Reset()
 152   {
 153     mCalledFlag = false;
 154   }
 155
 156   bool& mCalledFlag;
 157 };
 158
 159 struct SceneCreatedStatusFunctor
 160 {
 161   SceneCreatedStatusFunctor(bool& calledFlag) : mCalledFlag( calledFlag )
 162   {
 163     mCalledFlag = false;
 164   }
 165
 166   void operator()()
 167   {
 168     mCalledFlag = true;
 169   }
 170   void Reset()
 171   {
 172     mCalledFlag = false;
 173   }
 174
 175   bool& mCalledFlag;
 176 };
 177
 178 } // unnamed namespace
 179
 180
 181 int UtcDaliStageDefaultConstructor(void)
 182 {
 183   TestApplication application;
 184   Stage stage;
 185
 186   DALI_TEST_CHECK(!stage);
 187   END_TEST;
 188 }
 189
 190 int UtcDaliStageDestructor(void)
 191 {
 192   TestApplication application;
 193   Stage* stage = new Stage();
 194   delete stage;
 195   stage = NULL;
 196
 197   DALI_TEST_CHECK( true );
 198   END_TEST;
 199 }
 200
 201 int UtcDaliStageGetCurrent(void)
 202 {
 203   TestApplication application;
 204   Stage stage = Stage::GetCurrent();
 205
 206   DALI_TEST_CHECK(stage);
 207   END_TEST;
 208 }
 209
 210 int UtcDaliStageAssign(void)
 211 {
 212   TestApplication application;
 213   Stage stage = Stage::GetCurrent();
 214   Stage stage2;
 215   stage2 = stage;
 216
 217   DALI_TEST_CHECK(stage2);
 218   END_TEST;
 219 }
 220
 221 int UtcDaliStageIsInstalled(void)
 222 {
 223   DALI_TEST_CHECK(!Stage::IsInstalled());
 224
 225   TestApplication application;
 226
 227   Stage::GetCurrent();
 228
 229   DALI_TEST_CHECK(Stage::IsInstalled());
 230   END_TEST;
 231 }
 232
 233 int UtcDaliStageAdd(void)
 234 {
 235   TestApplication application;
 236
 237   Stage stage = Stage::GetCurrent();
 238
 239   Actor actor = Actor::New();
 240   DALI_TEST_CHECK(!actor.OnStage());
 241
 242   stage.Add(actor);
 243   DALI_TEST_CHECK(actor.OnStage());
 244   END_TEST;
 245 }
 246
 247 int UtcDaliStageRemove(void)
 248 {
 249   TestApplication application;
 250
 251   Stage stage = Stage::GetCurrent();
 252
 253   Actor actor = Actor::New();
 254   DALI_TEST_CHECK(!actor.OnStage());
 255
 256   stage.Add(actor);
 257   DALI_TEST_CHECK(actor.OnStage());
 258
 259   stage.Remove(actor);
 260   DALI_TEST_CHECK(!actor.OnStage());
 261   END_TEST;
 262 }
 263
 264 int UtcDaliStageGetSize(void)
 265 {
 266   TestApplication application;
 267
 268   Stage stage = Stage::GetCurrent();
 269
 270   Vector2 size = stage.GetSize();
 271
 272   DALI_TEST_EQUALS(size.width,  static_cast<float>(TestApplication::DEFAULT_SURFACE_WIDTH),  TEST_LOCATION);
 273   DALI_TEST_EQUALS(size.height, static_cast<float>(TestApplication::DEFAULT_SURFACE_HEIGHT), TEST_LOCATION);
 274   END_TEST;
 275 }
 276
 277 int UtcDaliStageGetDpi01(void)
 278 {
 279   TestApplication application; // Initializes core DPI to default values
 280
 281   Stage stage = Stage::GetCurrent();
 282
 283   // Test the default DPI.
 284   Vector2 dpi = stage.GetDpi();
 285   DALI_TEST_EQUALS(dpi.x, static_cast<float>(TestApplication::DEFAULT_HORIZONTAL_DPI), TEST_LOCATION);
 286   DALI_TEST_EQUALS(dpi.y, static_cast<float>(TestApplication::DEFAULT_VERTICAL_DPI),   TEST_LOCATION);
 287   END_TEST;
 288 }
 289
 290 int UtcDaliStageGetDpi02(void)
 291 {
 292   TestApplication application; // Initializes core DPI to default values
 293
 294   // Test that setting core DPI explicitly also sets up the Stage's DPI.
 295   application.GetCore().SetDpi(200, 180);
 296
 297   Stage stage = Stage::GetCurrent();
 298   Vector2 dpi = stage.GetDpi();
 299   DALI_TEST_EQUALS(dpi.x, 200.0f, TEST_LOCATION);
 300   DALI_TEST_EQUALS(dpi.y, 180.0f, TEST_LOCATION);
 301   END_TEST;
 302 }
 303
 304
 305 int UtcDaliStageGetDpi03(void)
 306 {
 307   TestApplication application(480, 800, 72.0f, 120.0f); // Initializes core DPI with specific values
 308
 309   Stage stage = Stage::GetCurrent();
 310
 311   // Test that setting core DPI explicitly also sets up the Stage's DPI.
 312   Vector2 dpi = stage.GetDpi();
 313   DALI_TEST_EQUALS(dpi.x, 72.0f, TEST_LOCATION);
 314   DALI_TEST_EQUALS(dpi.y, 120.0f, TEST_LOCATION);
 315   END_TEST;
 316 }
 317
 318 int UtcDaliStageInitializeDynamicsP(void)
 319 {
 320   TestApplication application;
 321   Stage stage = Stage::GetCurrent();
 322   DynamicsWorld world = stage.InitializeDynamics( DynamicsWorldConfig::New() );
 323
 324 #if !defined(DYNAMICS_SUPPORT)
 325   DALI_TEST_CHECK(true);
 326 #else
 327   DALI_TEST_CHECK( world );
 328 #endif
 329
 330   END_TEST;
 331 }
 332
 333 int UtcDaliStageGetLayerCount(void)
 334 {
 335   TestApplication application;
 336
 337   Stage stage = Stage::GetCurrent();
 338
 339   // Initially we have a default layer
 340   DALI_TEST_EQUALS(stage.GetLayerCount(), 1u, TEST_LOCATION);
 341
 342   Layer layer = Layer::New();
 343   stage.Add(layer);
 344
 345   DALI_TEST_EQUALS(stage.GetLayerCount(), 2u, TEST_LOCATION);
 346   END_TEST;
 347 }
 348
 349 int UtcDaliStageGetLayer(void)
 350 {
 351   TestApplication application;
 352
 353   Stage stage = Stage::GetCurrent();
 354
 355   Layer rootLayer = stage.GetLayer(0);
 356   DALI_TEST_CHECK(rootLayer);
 357
 358   Layer layer = Layer::New();
 359   stage.Add(layer);
 360
 361   Layer sameLayer = stage.GetLayer(1);
 362   DALI_TEST_CHECK(layer == sameLayer);
 363   END_TEST;
 364 }
 365
 366
 367 int UtcDaliStageGetRootLayer(void)
 368 {
 369   TestApplication application;
 370
 371   Stage stage = Stage::GetCurrent();
 372
 373   Layer rootLayer = stage.GetLayer(0);
 374   DALI_TEST_CHECK( rootLayer );
 375
 376   Layer layer = Layer::New();
 377   stage.Add( layer );
 378   layer.LowerToBottom();
 379
 380   DALI_TEST_CHECK( stage.GetRootLayer() == rootLayer );
 381   END_TEST;
 382 }
 383
 384 int UtcDaliStageSetBackgroundColor(void)
 385 {
 386   TestApplication application;
 387
 388   Stage stage = Stage::GetCurrent();
 389
 390   Vector4 testColor(0.1f, 0.2f, 0.3f, 1.0f);
 391   stage.SetBackgroundColor(testColor);
 392
 393   DALI_TEST_EQUALS(testColor, stage.GetBackgroundColor(), TEST_LOCATION);
 394   END_TEST;
 395 }
 396
 397 int UtcDaliStageGetBackgroundColor(void)
 398 {
 399   TestApplication application;
 400
 401   Stage stage = Stage::GetCurrent();
 402
 403   DALI_TEST_EQUALS(Stage::DEFAULT_BACKGROUND_COLOR, stage.GetBackgroundColor(), TEST_LOCATION);
 404   END_TEST;
 405 }
 406
 407 int UtcDaliStageKeepRendering(void)
 408 {
 409   TestApplication application;
 410
 411   Stage stage = Stage::GetCurrent();
 412
 413   // Run core until it wants to sleep
 414   bool keepUpdating( true );
 415   while ( keepUpdating )
 416   {
 417     application.SendNotification();
 418     keepUpdating = application.Render(1000.0f /*1 second*/);
 419   }
 420
 421   // Force rendering for the next 5 seconds
 422   stage.KeepRendering( 5.0f );
 423
 424   application.SendNotification();
 425
 426   // Test that core wants to sleep after 10 seconds
 427   keepUpdating = application.Render(1000.0f /*1 second*/);
 428   DALI_TEST_CHECK( keepUpdating );
 429   keepUpdating = application.Render(1000.0f /*2 seconds*/);
 430   DALI_TEST_CHECK( keepUpdating );
 431   keepUpdating = application.Render(1000.0f /*3 seconds*/);
 432   DALI_TEST_CHECK( keepUpdating );
 433   keepUpdating = application.Render(1000.0f /*4 seconds*/);
 434   DALI_TEST_CHECK( keepUpdating );
 435   keepUpdating = application.Render(1000.0f /*5 seconds*/);
 436   DALI_TEST_CHECK( !keepUpdating );
 437   END_TEST;
 438 }
 439
 440 int UtcDaliStageEventProcessingFinished(void)
 441 {
 442   TestApplication application;
 443   Stage stage = Stage::GetCurrent();
 444
 445   bool eventProcessingFinished = false;
 446   EventProcessingFinishedFunctor functor( eventProcessingFinished );
 447   stage.EventProcessingFinishedSignal().Connect( &application, functor );
 448
 449   Actor actor( Actor::New() );
 450   stage.Add( actor );
 451
 452   application.SendNotification();
 453   application.Render();
 454
 455   DALI_TEST_CHECK( eventProcessingFinished );
 456
 457   END_TEST;
 458 }
 459
 460 int UtcDaliStageSignalKeyEvent(void)
 461 {
 462   TestApplication application;
 463   Stage stage = Stage::GetCurrent();
 464
 465   KeyEventSignalData data;
 466   KeyEventReceivedFunctor functor( data );
 467   stage.KeyEventSignal().Connect( &application, functor );
 468
 469   Integration::KeyEvent event( "i","i", 0, 0, 0, Integration::KeyEvent::Down );
 470   application.ProcessEvent( event );
 471
 472   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 473   DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.keyModifier );
 474   DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.keyPressedName );
 475   DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.keyPressed );
 476   DALI_TEST_CHECK( event.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.state) );
 477
 478   data.Reset();
 479
 480   Integration::KeyEvent event2( "i","i", 0, 0, 0, Integration::KeyEvent::Up );
 481   application.ProcessEvent( event2 );
 482
 483   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 484   DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.keyModifier );
 485   DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.keyPressedName );
 486   DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.keyPressed );
 487   DALI_TEST_CHECK( event2.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.state) );
 488
 489   data.Reset();
 490
 491   Integration::KeyEvent event3( "a","a", 0, 0, 0, Integration::KeyEvent::Down );
 492   application.ProcessEvent( event3 );
 493
 494   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 495   DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.keyModifier );
 496   DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.keyPressedName );
 497   DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.keyPressed );
 498   DALI_TEST_CHECK( event3.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.state) );
 499
 500   data.Reset();
 501
 502   Integration::KeyEvent event4( "a","a", 0, 0, 0, Integration::KeyEvent::Up );
 503   application.ProcessEvent( event4 );
 504
 505   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 506   DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.keyModifier );
 507   DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.keyPressedName );
 508   DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.keyPressed );
 509   DALI_TEST_CHECK( event4.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.state) );
 510   END_TEST;
 511 }
 512
 513 int UtcDaliStageTouchedSignal(void)
 514 {
 515   TestApplication application;
 516   Stage stage = Stage::GetCurrent();
 517
 518   TouchedSignalData data;
 519   TouchedFunctor functor( data );
 520   stage.TouchedSignal().Connect( &application, functor );
 521
 522   // Render and notify
 523   application.SendNotification();
 524   application.Render();
 525
 526   // NO ACTORS, SINGLE TOUCH, DOWN, MOTION THEN UP
 527   {
 528     Integration::TouchEvent touchEvent;
 529     touchEvent.points.push_back( TouchPoint( 0, TouchPoint::Down, 10.0f, 10.0f ) );
 530     application.ProcessEvent( touchEvent );
 531
 532     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 533     DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0 );
 534     DALI_TEST_CHECK( !data.receivedTouchEvent.points[0].hitActor );
 535     data.Reset();
 536
 537     touchEvent.points[0].state = TouchPoint::Motion;
 538     touchEvent.points[0].screen.x = 12.0f; // Some motion
 539     application.ProcessEvent( touchEvent );
 540
 541     DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 542     data.Reset();
 543
 544     touchEvent.points[0].state = TouchPoint::Up;
 545     application.ProcessEvent( touchEvent );
 546
 547     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 548     DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0 );
 549     DALI_TEST_CHECK( !data.receivedTouchEvent.points[0].hitActor );
 550     data.Reset();
 551   }
 552
 553   // Add an actor to the scene
 554
 555   Actor actor = Actor::New();
 556   actor.SetSize( 100.0f, 100.0f );
 557   actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 558   actor.SetParentOrigin( ParentOrigin::TOP_LEFT );
 559   actor.TouchedSignal().Connect( &DummyTouchCallback );
 560   stage.Add( actor );
 561
 562   // Render and notify
 563   application.SendNotification();
 564   application.Render();
 565
 566   // ACTOR ON SCENE, SINGLE TOUCH, DOWN IN ACTOR, MOTION THEN UP OUTSIDE ACTOR
 567   {
 568     Integration::TouchEvent touchEvent;
 569     touchEvent.points.push_back( TouchPoint( 0, TouchPoint::Down, 10.0f, 10.0f ) );
 570     application.ProcessEvent( touchEvent );
 571
 572     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 573     DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0 );
 574     DALI_TEST_CHECK( data.receivedTouchEvent.points[0].hitActor == actor );
 575     data.Reset();
 576
 577     touchEvent.points[0].state = TouchPoint::Motion;
 578     touchEvent.points[0].screen.x = 150.0f; // Some motion
 579     application.ProcessEvent( touchEvent );
 580
 581     DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 582     data.Reset();
 583
 584     touchEvent.points[0].state = TouchPoint::Up;
 585     application.ProcessEvent( touchEvent );
 586
 587     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 588     DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0 );
 589     DALI_TEST_CHECK( !data.receivedTouchEvent.points[0].hitActor );
 590     data.Reset();
 591   }
 592
 593   // INTERRUPTED BEFORE DOWN AND INTERRUPTED AFTER DOWN
 594   {
 595     Integration::TouchEvent touchEvent;
 596     touchEvent.points.push_back( TouchPoint( 0, TouchPoint::Interrupted, 10.0f, 10.0f ) );
 597     application.ProcessEvent( touchEvent );
 598
 599     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 600     DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0 );
 601     DALI_TEST_CHECK( !data.receivedTouchEvent.points[0].hitActor );
 602     DALI_TEST_CHECK( data.receivedTouchEvent.points[0].state == TouchPoint::Interrupted );
 603     data.Reset();
 604
 605     touchEvent.points[0].state = TouchPoint::Down;
 606     application.ProcessEvent( touchEvent );
 607
 608     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 609     DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0 );
 610     DALI_TEST_CHECK( data.receivedTouchEvent.points[0].hitActor == actor );
 611     DALI_TEST_CHECK( data.receivedTouchEvent.points[0].state == TouchPoint::Down );
 612     data.Reset();
 613
 614     touchEvent.points[0].state = TouchPoint::Interrupted;
 615     application.ProcessEvent( touchEvent );
 616
 617     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 618     DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0 );
 619     DALI_TEST_CHECK( !data.receivedTouchEvent.points[0].hitActor );
 620     DALI_TEST_CHECK( data.receivedTouchEvent.points[0].state == TouchPoint::Interrupted );
 621     data.Reset();
 622   }
 623
 624   // MULTIPLE TOUCH, SHOULD ONLY RECEIVE TOUCH ON FIRST DOWN AND LAST UP
 625   {
 626     Integration::TouchEvent touchEvent;
 627
 628     // 1st point
 629     touchEvent.points.push_back( TouchPoint( 0, TouchPoint::Down, 10.0f, 10.0f ) );
 630     application.ProcessEvent( touchEvent );
 631     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 632     data.Reset();
 633
 634     // 2nd point
 635     touchEvent.points[0].state = TouchPoint::Stationary;
 636     touchEvent.points.push_back( TouchPoint( 1, TouchPoint::Down, 50.0f, 50.0f ) );
 637     application.ProcessEvent( touchEvent );
 638     DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 639     data.Reset();
 640
 641     // Primary point is up
 642     touchEvent.points[0].state = TouchPoint::Up;
 643     touchEvent.points[1].state = TouchPoint::Stationary;
 644     application.ProcessEvent( touchEvent );
 645     DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 646     data.Reset();
 647
 648     // Remove 1st point now, 2nd point is now in motion
 649     touchEvent.points.erase( touchEvent.points.begin() );
 650     touchEvent.points[0].state = TouchPoint::Motion;
 651     touchEvent.points[0].screen.x = 150.0f;
 652     application.ProcessEvent( touchEvent );
 653     DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 654     data.Reset();
 655
 656     // Final point Up
 657     touchEvent.points[0].state = TouchPoint::Up;
 658     application.ProcessEvent( touchEvent );
 659     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 660     data.Reset();
 661   }
 662   END_TEST;
 663 }
 664
 665 int UtcDaliStageContextLostRegainedSignals(void)
 666 {
 667   TestApplication app;
 668   Stage stage = Stage::GetCurrent();
 669
 670   bool contextLost = false;
 671   bool contextRegained = false;
 672   ContextStatusFunctor contextLostFunctor( contextLost );
 673   ContextStatusFunctor contextRegainedFunctor( contextRegained );
 674   stage.ContextLostSignal().Connect(&app, contextLostFunctor );
 675   stage.ContextRegainedSignal().Connect(&app, contextRegainedFunctor );
 676
 677   Integration::Core& core = app.GetCore();
 678   Integration::ContextNotifierInterface* notifier = core.GetContextNotifier();
 679   notifier->NotifyContextLost();
 680   DALI_TEST_EQUALS( contextLost, true, TEST_LOCATION );
 681
 682   notifier->NotifyContextRegained();
 683   DALI_TEST_EQUALS( contextRegained, true, TEST_LOCATION );
 684
 685   END_TEST;
 686 }
 687
 688 int UtcDaliStageSceneCreatedSignal(void)
 689 {
 690   TestApplication app;
 691   Stage stage = Stage::GetCurrent();
 692
 693   bool signalCalled = false;
 694   SceneCreatedStatusFunctor sceneCreatedFunctor( signalCalled );
 695   stage.SceneCreatedSignal().Connect(&app, sceneCreatedFunctor );
 696
 697   Integration::Core& core = app.GetCore();
 698   core.SceneCreated();
 699   DALI_TEST_EQUALS( signalCalled, true, TEST_LOCATION );
 700
 701   END_TEST;
 702 }