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