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 } // unnamed namespace
 159
 160
 161 int UtcDaliStageDefaultConstructor(void)
 162 {
 163   TestApplication application;
 164   Stage stage;
 165
 166   DALI_TEST_CHECK(!stage);
 167   END_TEST;
 168 }
 169
 170 int UtcDaliStageDestructor(void)
 171 {
 172   TestApplication application;
 173   Stage* stage = new Stage();
 174   delete stage;
 175   stage = NULL;
 176
 177   DALI_TEST_CHECK( true );
 178   END_TEST;
 179 }
 180
 181 int UtcDaliStageGetCurrent(void)
 182 {
 183   TestApplication application;
 184   Stage stage = Stage::GetCurrent();
 185
 186   DALI_TEST_CHECK(stage);
 187   END_TEST;
 188 }
 189
 190 int UtcDaliStageIsInstalled(void)
 191 {
 192   DALI_TEST_CHECK(!Stage::IsInstalled());
 193
 194   TestApplication application;
 195
 196   Stage::GetCurrent();
 197
 198   DALI_TEST_CHECK(Stage::IsInstalled());
 199   END_TEST;
 200 }
 201
 202 int UtcDaliStageAdd(void)
 203 {
 204   TestApplication application;
 205
 206   Stage stage = Stage::GetCurrent();
 207
 208   Actor actor = Actor::New();
 209   DALI_TEST_CHECK(!actor.OnStage());
 210
 211   stage.Add(actor);
 212   DALI_TEST_CHECK(actor.OnStage());
 213   END_TEST;
 214 }
 215
 216 int UtcDaliStageRemove(void)
 217 {
 218   TestApplication application;
 219
 220   Stage stage = Stage::GetCurrent();
 221
 222   Actor actor = Actor::New();
 223   DALI_TEST_CHECK(!actor.OnStage());
 224
 225   stage.Add(actor);
 226   DALI_TEST_CHECK(actor.OnStage());
 227
 228   stage.Remove(actor);
 229   DALI_TEST_CHECK(!actor.OnStage());
 230   END_TEST;
 231 }
 232
 233 int UtcDaliStageGetSize(void)
 234 {
 235   TestApplication application;
 236
 237   Stage stage = Stage::GetCurrent();
 238
 239   Vector2 size = stage.GetSize();
 240
 241   DALI_TEST_EQUALS(size.width,  static_cast<float>(TestApplication::DEFAULT_SURFACE_WIDTH),  TEST_LOCATION);
 242   DALI_TEST_EQUALS(size.height, static_cast<float>(TestApplication::DEFAULT_SURFACE_HEIGHT), TEST_LOCATION);
 243   END_TEST;
 244 }
 245
 246 int UtcDaliStageGetDpi01(void)
 247 {
 248   TestApplication application; // Initializes core DPI to default values
 249
 250   Stage stage = Stage::GetCurrent();
 251
 252   // Test the default DPI.
 253   Vector2 dpi = stage.GetDpi();
 254   DALI_TEST_EQUALS(dpi.x, static_cast<float>(TestApplication::DEFAULT_HORIZONTAL_DPI), TEST_LOCATION);
 255   DALI_TEST_EQUALS(dpi.y, static_cast<float>(TestApplication::DEFAULT_VERTICAL_DPI),   TEST_LOCATION);
 256   END_TEST;
 257 }
 258
 259 int UtcDaliStageGetDpi02(void)
 260 {
 261   TestApplication application; // Initializes core DPI to default values
 262
 263   // Test that setting core DPI explicitly also sets up the Stage's DPI.
 264   application.GetCore().SetDpi(200, 180);
 265
 266   Stage stage = Stage::GetCurrent();
 267   Vector2 dpi = stage.GetDpi();
 268   DALI_TEST_EQUALS(dpi.x, 200.0f, TEST_LOCATION);
 269   DALI_TEST_EQUALS(dpi.y, 180.0f, TEST_LOCATION);
 270   END_TEST;
 271 }
 272
 273
 274 int UtcDaliStageGetDpi03(void)
 275 {
 276   TestApplication application(480, 800, 72.0f, 120.0f); // Initializes core DPI with specific values
 277
 278   Stage stage = Stage::GetCurrent();
 279
 280   // Test that setting core DPI explicitly also sets up the Stage's DPI.
 281   Vector2 dpi = stage.GetDpi();
 282   DALI_TEST_EQUALS(dpi.x, 72.0f, TEST_LOCATION);
 283   DALI_TEST_EQUALS(dpi.y, 120.0f, TEST_LOCATION);
 284   END_TEST;
 285 }
 286
 287 int UtcDaliStageGetLayerCount(void)
 288 {
 289   TestApplication application;
 290
 291   Stage stage = Stage::GetCurrent();
 292
 293   // Initially we have a default layer
 294   DALI_TEST_EQUALS(stage.GetLayerCount(), 1u, TEST_LOCATION);
 295
 296   Layer layer = Layer::New();
 297   stage.Add(layer);
 298
 299   DALI_TEST_EQUALS(stage.GetLayerCount(), 2u, TEST_LOCATION);
 300   END_TEST;
 301 }
 302
 303 int UtcDaliStageGetLayer(void)
 304 {
 305   TestApplication application;
 306
 307   Stage stage = Stage::GetCurrent();
 308
 309   Layer rootLayer = stage.GetLayer(0);
 310   DALI_TEST_CHECK(rootLayer);
 311
 312   Layer layer = Layer::New();
 313   stage.Add(layer);
 314
 315   Layer sameLayer = stage.GetLayer(1);
 316   DALI_TEST_CHECK(layer == sameLayer);
 317   END_TEST;
 318 }
 319
 320
 321 int UtcDaliStageGetRootLayer(void)
 322 {
 323   TestApplication application;
 324
 325   Stage stage = Stage::GetCurrent();
 326
 327   Layer rootLayer = stage.GetLayer(0);
 328   DALI_TEST_CHECK( rootLayer );
 329
 330   Layer layer = Layer::New();
 331   stage.Add( layer );
 332   layer.LowerToBottom();
 333
 334   DALI_TEST_CHECK( stage.GetRootLayer() == rootLayer );
 335   END_TEST;
 336 }
 337
 338 int UtcDaliStageSetBackgroundColor(void)
 339 {
 340   TestApplication application;
 341
 342   Stage stage = Stage::GetCurrent();
 343
 344   Vector4 testColor(0.1f, 0.2f, 0.3f, 1.0f);
 345   stage.SetBackgroundColor(testColor);
 346
 347   DALI_TEST_EQUALS(testColor, stage.GetBackgroundColor(), TEST_LOCATION);
 348   END_TEST;
 349 }
 350
 351 int UtcDaliStageGetBackgroundColor(void)
 352 {
 353   TestApplication application;
 354
 355   Stage stage = Stage::GetCurrent();
 356
 357   DALI_TEST_EQUALS(Stage::DEFAULT_BACKGROUND_COLOR, stage.GetBackgroundColor(), TEST_LOCATION);
 358   END_TEST;
 359 }
 360
 361 int UtcDaliStageKeepRendering(void)
 362 {
 363   TestApplication application;
 364
 365   Stage stage = Stage::GetCurrent();
 366
 367   // Run core until it wants to sleep
 368   bool keepUpdating( true );
 369   while ( keepUpdating )
 370   {
 371     application.SendNotification();
 372     keepUpdating = application.Render(1000.0f /*1 second*/);
 373   }
 374
 375   // Force rendering for the next 5 seconds
 376   stage.KeepRendering( 5.0f );
 377
 378   application.SendNotification();
 379
 380   // Test that core wants to sleep after 10 seconds
 381   keepUpdating = application.Render(1000.0f /*1 second*/);
 382   DALI_TEST_CHECK( keepUpdating );
 383   keepUpdating = application.Render(1000.0f /*2 seconds*/);
 384   DALI_TEST_CHECK( keepUpdating );
 385   keepUpdating = application.Render(1000.0f /*3 seconds*/);
 386   DALI_TEST_CHECK( keepUpdating );
 387   keepUpdating = application.Render(1000.0f /*4 seconds*/);
 388   DALI_TEST_CHECK( keepUpdating );
 389   keepUpdating = application.Render(1000.0f /*5 seconds*/);
 390   DALI_TEST_CHECK( !keepUpdating );
 391   END_TEST;
 392 }
 393
 394 int UtcDaliStageEventProcessingFinished(void)
 395 {
 396   TestApplication application;
 397   Stage stage = Stage::GetCurrent();
 398
 399   bool eventProcessingFinished = false;
 400   EventProcessingFinishedFunctor functor( eventProcessingFinished );
 401   stage.EventProcessingFinishedSignal().Connect( &application, functor );
 402
 403   Actor actor( Actor::New() );
 404   stage.Add( actor );
 405
 406   application.SendNotification();
 407   application.Render();
 408
 409   DALI_TEST_CHECK( eventProcessingFinished );
 410
 411   END_TEST;
 412 }
 413
 414 int UtcDaliStageSignalKeyEvent(void)
 415 {
 416   TestApplication application;
 417   Stage stage = Stage::GetCurrent();
 418
 419   KeyEventSignalData data;
 420   KeyEventReceivedFunctor functor( data );
 421   stage.KeyEventSignal().Connect( &application, functor );
 422
 423   Integration::KeyEvent event( "i","i", 0, 0, 0, Integration::KeyEvent::Down );
 424   application.ProcessEvent( event );
 425
 426   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 427   DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.keyModifier );
 428   DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.keyPressedName );
 429   DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.keyPressed );
 430   DALI_TEST_CHECK( event.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.state) );
 431
 432   data.Reset();
 433
 434   Integration::KeyEvent event2( "i","i", 0, 0, 0, Integration::KeyEvent::Up );
 435   application.ProcessEvent( event2 );
 436
 437   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 438   DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.keyModifier );
 439   DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.keyPressedName );
 440   DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.keyPressed );
 441   DALI_TEST_CHECK( event2.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.state) );
 442
 443   data.Reset();
 444
 445   Integration::KeyEvent event3( "a","a", 0, 0, 0, Integration::KeyEvent::Down );
 446   application.ProcessEvent( event3 );
 447
 448   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 449   DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.keyModifier );
 450   DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.keyPressedName );
 451   DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.keyPressed );
 452   DALI_TEST_CHECK( event3.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.state) );
 453
 454   data.Reset();
 455
 456   Integration::KeyEvent event4( "a","a", 0, 0, 0, Integration::KeyEvent::Up );
 457   application.ProcessEvent( event4 );
 458
 459   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 460   DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.keyModifier );
 461   DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.keyPressedName );
 462   DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.keyPressed );
 463   DALI_TEST_CHECK( event4.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.state) );
 464   END_TEST;
 465 }
 466
 467 int UtcDaliStageTouchedSignal(void)
 468 {
 469   TestApplication application;
 470   Stage stage = Stage::GetCurrent();
 471
 472   TouchedSignalData data;
 473   TouchedFunctor functor( data );
 474   stage.TouchedSignal().Connect( &application, functor );
 475
 476   // Render and notify
 477   application.SendNotification();
 478   application.Render();
 479
 480   // NO ACTORS, SINGLE TOUCH, DOWN, MOTION THEN UP
 481   {
 482     Integration::TouchEvent touchEvent;
 483     touchEvent.points.push_back( TouchPoint( 0, TouchPoint::Down, 10.0f, 10.0f ) );
 484     application.ProcessEvent( touchEvent );
 485
 486     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 487     DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0 );
 488     DALI_TEST_CHECK( !data.receivedTouchEvent.points[0].hitActor );
 489     data.Reset();
 490
 491     touchEvent.points[0].state = TouchPoint::Motion;
 492     touchEvent.points[0].screen.x = 12.0f; // Some motion
 493     application.ProcessEvent( touchEvent );
 494
 495     DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 496     data.Reset();
 497
 498     touchEvent.points[0].state = TouchPoint::Up;
 499     application.ProcessEvent( touchEvent );
 500
 501     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 502     DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0 );
 503     DALI_TEST_CHECK( !data.receivedTouchEvent.points[0].hitActor );
 504     data.Reset();
 505   }
 506
 507   // Add an actor to the scene
 508
 509   Actor actor = Actor::New();
 510   actor.SetSize( 100.0f, 100.0f );
 511   actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 512   actor.SetParentOrigin( ParentOrigin::TOP_LEFT );
 513   actor.TouchedSignal().Connect( &DummyTouchCallback );
 514   stage.Add( actor );
 515
 516   // Render and notify
 517   application.SendNotification();
 518   application.Render();
 519
 520   // ACTOR ON SCENE, SINGLE TOUCH, DOWN IN ACTOR, MOTION THEN UP OUTSIDE ACTOR
 521   {
 522     Integration::TouchEvent touchEvent;
 523     touchEvent.points.push_back( TouchPoint( 0, TouchPoint::Down, 10.0f, 10.0f ) );
 524     application.ProcessEvent( touchEvent );
 525
 526     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 527     DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0 );
 528     DALI_TEST_CHECK( data.receivedTouchEvent.points[0].hitActor == actor );
 529     data.Reset();
 530
 531     touchEvent.points[0].state = TouchPoint::Motion;
 532     touchEvent.points[0].screen.x = 150.0f; // Some motion
 533     application.ProcessEvent( touchEvent );
 534
 535     DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 536     data.Reset();
 537
 538     touchEvent.points[0].state = TouchPoint::Up;
 539     application.ProcessEvent( touchEvent );
 540
 541     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 542     DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0 );
 543     DALI_TEST_CHECK( !data.receivedTouchEvent.points[0].hitActor );
 544     data.Reset();
 545   }
 546
 547   // INTERRUPTED BEFORE DOWN AND INTERRUPTED AFTER DOWN
 548   {
 549     Integration::TouchEvent touchEvent;
 550     touchEvent.points.push_back( TouchPoint( 0, TouchPoint::Interrupted, 10.0f, 10.0f ) );
 551     application.ProcessEvent( touchEvent );
 552
 553     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 554     DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0 );
 555     DALI_TEST_CHECK( !data.receivedTouchEvent.points[0].hitActor );
 556     DALI_TEST_CHECK( data.receivedTouchEvent.points[0].state == TouchPoint::Interrupted );
 557     data.Reset();
 558
 559     touchEvent.points[0].state = TouchPoint::Down;
 560     application.ProcessEvent( touchEvent );
 561
 562     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 563     DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0 );
 564     DALI_TEST_CHECK( data.receivedTouchEvent.points[0].hitActor == actor );
 565     DALI_TEST_CHECK( data.receivedTouchEvent.points[0].state == TouchPoint::Down );
 566     data.Reset();
 567
 568     touchEvent.points[0].state = TouchPoint::Interrupted;
 569     application.ProcessEvent( touchEvent );
 570
 571     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 572     DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0 );
 573     DALI_TEST_CHECK( !data.receivedTouchEvent.points[0].hitActor );
 574     DALI_TEST_CHECK( data.receivedTouchEvent.points[0].state == TouchPoint::Interrupted );
 575     data.Reset();
 576   }
 577
 578   // MULTIPLE TOUCH, SHOULD ONLY RECEIVE TOUCH ON FIRST DOWN AND LAST UP
 579   {
 580     Integration::TouchEvent touchEvent;
 581
 582     // 1st point
 583     touchEvent.points.push_back( TouchPoint( 0, TouchPoint::Down, 10.0f, 10.0f ) );
 584     application.ProcessEvent( touchEvent );
 585     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 586     data.Reset();
 587
 588     // 2nd point
 589     touchEvent.points[0].state = TouchPoint::Stationary;
 590     touchEvent.points.push_back( TouchPoint( 1, TouchPoint::Down, 50.0f, 50.0f ) );
 591     application.ProcessEvent( touchEvent );
 592     DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 593     data.Reset();
 594
 595     // Primary point is up
 596     touchEvent.points[0].state = TouchPoint::Up;
 597     touchEvent.points[1].state = TouchPoint::Stationary;
 598     application.ProcessEvent( touchEvent );
 599     DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 600     data.Reset();
 601
 602     // Remove 1st point now, 2nd point is now in motion
 603     touchEvent.points.erase( touchEvent.points.begin() );
 604     touchEvent.points[0].state = TouchPoint::Motion;
 605     touchEvent.points[0].screen.x = 150.0f;
 606     application.ProcessEvent( touchEvent );
 607     DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 608     data.Reset();
 609
 610     // Final point Up
 611     touchEvent.points[0].state = TouchPoint::Up;
 612     application.ProcessEvent( touchEvent );
 613     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 614     data.Reset();
 615   }
 616   END_TEST;
 617 }
 618
 619 int UtcDaliStageContextLostRegainedSignals(void)
 620 {
 621   TestApplication app;
 622   Stage stage = Stage::GetCurrent();
 623
 624   bool contextLost = false;
 625   bool contextRegained = false;
 626   ContextStatusFunctor contextLostFunctor( contextLost );
 627   ContextStatusFunctor contextRegainedFunctor( contextRegained );
 628   stage.ContextLostSignal().Connect(&app, contextLostFunctor );
 629   stage.ContextRegainedSignal().Connect(&app, contextRegainedFunctor );
 630
 631   Integration::Core& core = app.GetCore();
 632   Integration::ContextNotifierInterface* notifier = core.GetContextNotifier();
 633   notifier->NotifyContextLost();
 634   DALI_TEST_EQUALS( contextLost, true, TEST_LOCATION );
 635
 636   notifier->NotifyContextRegained();
 637   DALI_TEST_EQUALS( contextRegained, true, TEST_LOCATION );
 638
 639   END_TEST;
 640 }