automated-tests/src/dali-toolkit/utc-Dali-PageTurnView.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 #include <stdlib.h>
  20 #include <string.h>
  21 #include <sstream>
  22 #include <dali-toolkit-test-suite-utils.h>
  23 #include <dali-toolkit/dali-toolkit.h>
  24 #include <dali/integration-api/events/pan-gesture-event.h>
  25 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
  26 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
  27 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
  28 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
  29
  30
  31
  32 using namespace Dali;
  33 using namespace Dali::Toolkit;
  34
  35 namespace
  36 {
  37 const int RENDER_FRAME_INTERVAL = 16;                           ///< Duration of each frame in ms. (at approx 60FPS)
  38 const unsigned int TOTAL_PAGE_NUMBER = 20;
  39 const Vector2 PAGE_SIZE( 300.f,400.f );
  40 const unsigned int IMAGE_WIDTH = 30;
  41 const unsigned int IMAGE_HEIGHT = 30;
  42 const Vector2 IMAGE_SIZE( static_cast<float>( IMAGE_WIDTH ), static_cast<float>(IMAGE_HEIGHT) );
  43 const Vector2 SPINE_SHADOW_PARAMETER( 60.0f, 30.0f );
  44
  45 static bool gObjectCreatedCallBackCalled;
  46 static void TestCallback(BaseHandle handle)
  47 {
  48   gObjectCreatedCallBackCalled = true;
  49 }
  50
  51 /*
  52  * Simulate time passed by.
  53  *
  54  * @note this will always process at least 1 frame (1/60 sec)
  55  *
  56  * @param application Test application instance
  57  * @param duration Time to pass in milliseconds.
  58  */
  59 void Wait(ToolkitTestApplication& application, int duration = 0)
  60 {
  61   for(int i = 0; i <= ( duration / RENDER_FRAME_INTERVAL); i++)
  62   {
  63     application.SendNotification();
  64     application.Render(RENDER_FRAME_INTERVAL);
  65   }
  66 }
  67
  68 // Generate a PanGestureEvent to send to Core
  69 Integration::PanGestureEvent GeneratePan(
  70     Gesture::State state,
  71     const Vector2& previousPosition,
  72     const Vector2& currentPosition,
  73     unsigned long timeDelta,
  74     unsigned int numberOfTouches = 1)
  75 {
  76   Integration::PanGestureEvent pan(state);
  77
  78   pan.previousPosition = previousPosition;
  79   pan.currentPosition = currentPosition;
  80   pan.timeDelta = timeDelta;
  81   pan.numberOfTouches = numberOfTouches;
  82
  83   return pan;
  84 }
  85
  86 /**
  87  * Helper to generate PanGestureEvent
  88  *
  89  * @param[in] application Application instance
  90  * @param[in] state The Gesture State
  91  * @param[in] pos The current position of touch.
  92  */
  93 static void SendPan(ToolkitTestApplication& application, Gesture::State state, const Vector2& pos)
  94 {
  95   static Vector2 last;
  96
  97   if( (state == Gesture::Started) ||
  98       (state == Gesture::Possible) )
  99   {
 100     last.x = pos.x;
 101     last.y = pos.y;
 102   }
 103
 104   application.ProcessEvent(GeneratePan(state, last, pos, RENDER_FRAME_INTERVAL));
 105
 106   last.x = pos.x;
 107   last.y = pos.y;
 108 }
 109
 110 static Vector2 PerformGestureDiagonalSwipe(ToolkitTestApplication& application, Vector2 start, Vector2 direction, int frames, bool toStart = true, bool toFinish = true)
 111 {
 112   // Now do a pan starting from (start) and heading (direction)
 113   Vector2 pos(start);
 114
 115   if( toStart )
 116   {
 117     SendPan(application, Gesture::Possible, pos);
 118     Wait(application);
 119     SendPan(application, Gesture::Started, pos);
 120     Wait(application);
 121   }
 122
 123   for(int i = 0;i<frames;i++)
 124   {
 125     pos += direction; // Move in this direction
 126     SendPan(application, Gesture::Continuing, pos);
 127     Wait(application);
 128   }
 129
 130   if(toFinish)
 131   {
 132     pos += direction; // Move in this direction
 133     SendPan(application, Gesture::Finished, pos);
 134     Wait(application);
 135   }
 136
 137   return pos;
 138 }
 139
 140
 141 //Functor to test whether PageTurnSignal / PagePanSignal is emitted
 142 class PageSignalCallback : public Dali::ConnectionTracker
 143 {
 144 public:
 145
 146   PageSignalCallback( bool& signalReceived, PageTurnView& view, unsigned int& pageIndex, bool& isForwards )
 147   : mSignalVerified( signalReceived ),
 148     mView( view ),
 149     mPageIndex( pageIndex ),
 150     mIsTurningForwards( isForwards )
 151   {
 152   }
 153
 154   // callback to be connected to PageTurnSignal
 155   void PageTurnSignalCallback( PageTurnView view, unsigned int pageIndex, bool isTurningForward )
 156   {
 157     tet_infoline( "Verifying PageTurnedSignal" );
 158
 159     if( mView == view && mPageIndex == pageIndex && mIsTurningForwards == isTurningForward )
 160     {
 161       mSignalVerified = true;
 162     }
 163   }
 164
 165   // callback to be connected to PagePanSignal
 166   void PagePanSignalCallback( PageTurnView view )
 167   {
 168     tet_infoline( "Verifying PagePannedSignal" );
 169
 170     if( mView == view )
 171     {
 172       mSignalVerified = true;
 173     }
 174   }
 175
 176   void Reset()
 177   {
 178     mSignalVerified = false;
 179   }
 180
 181   bool&         mSignalVerified;
 182   PageTurnView& mView;
 183   unsigned int& mPageIndex;
 184   bool&         mIsTurningForwards;
 185
 186 };
 187
 188
 189 //Implementation of PageFactory for providing page actors to PageTurnView
 190 class TestPageFactory : public PageFactory
 191 {
 192 public:
 193
 194   TestPageFactory(ToolkitTestApplication& application)
 195   : mApplication( application )
 196   {
 197     mSourceActors.resize(TOTAL_PAGE_NUMBER);
 198     mTotalPageNumber = TOTAL_PAGE_NUMBER;
 199   }
 200
 201   /**
 202    * Query the number of pages available from the factory.
 203    * The maximum available page has an ID of GetNumberOfPages()-1.
 204    */
 205   virtual unsigned int GetNumberOfPages()
 206   {
 207     return mTotalPageNumber;
 208   }
 209
 210   /**
 211    * Create an image actor to represent a page.
 212    * @param[in] pageId The ID of the page to create.
 213    * @return An image actor, or an uninitialized pointer if the ID is out of range.
 214    */
 215   virtual Actor NewPage( unsigned int pageId )
 216   {
 217     if(!mSourceActors[pageId])
 218     {
 219       Actor actor = CreateSolidColorImageActor(mApplication, Color::BLUE,IMAGE_WIDTH,IMAGE_HEIGHT);
 220       actor.SetName( static_cast<std::ostringstream*>( &(std::ostringstream() << pageId) )->str()  );
 221
 222       actor.SetParentOrigin( ParentOrigin::CENTER );
 223       actor.SetAnchorPoint( AnchorPoint::CENTER );
 224
 225       SetActorHittability( actor, true );
 226
 227       mSourceActors[pageId] = actor;
 228     }
 229
 230     return mSourceActors[pageId];
 231   }
 232
 233   void DeletePage( unsigned int pageId )
 234   {
 235     mSourceActors.erase( mSourceActors.begin() + pageId );
 236     mTotalPageNumber--;
 237   }
 238
 239 private:
 240   ToolkitTestApplication& mApplication;
 241   std::vector<Actor>      mSourceActors;
 242   unsigned int            mTotalPageNumber;
 243 };
 244
 245 }// namespace
 246
 247 void dali_page_turn_view_startup(void)
 248 {
 249   test_return_value = TET_UNDEF;
 250 }
 251
 252 void dali_page_turn_view_cleanup(void)
 253 {
 254   test_return_value = TET_PASS;
 255 }
 256
 257 int UtcDaliPageTurnPortraitViewNew(void)
 258 {
 259   ToolkitTestApplication application;
 260
 261   tet_infoline(" UtcDaliPageTurnViewNew ");
 262
 263   // Test default constructor
 264   PageTurnView portraitView;
 265   DALI_TEST_CHECK( !portraitView );
 266
 267   // Test object creation
 268   TestPageFactory factory(application);
 269   portraitView = PageTurnPortraitView::New( factory, PAGE_SIZE );
 270   DALI_TEST_CHECK( portraitView );
 271
 272   //Additional check to ensure object is created by checking if it's registered
 273   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 274   DALI_TEST_CHECK( registry );
 275
 276   gObjectCreatedCallBackCalled = false;
 277   registry.ObjectCreatedSignal().Connect( &TestCallback );
 278   {
 279     TestPageFactory factory(application);
 280     PageTurnView PortraitView = PageTurnPortraitView::New( factory, PAGE_SIZE );
 281   }
 282   DALI_TEST_CHECK( gObjectCreatedCallBackCalled );
 283
 284   // Test copy constructor
 285   PageTurnView viewCopy( portraitView );
 286   DALI_TEST_CHECK( viewCopy );
 287
 288   // Test down cast
 289   Handle handleView;
 290   handleView = portraitView;
 291   PageTurnView downCastView = PageTurnView::DownCast( handleView );
 292   DALI_TEST_CHECK( downCastView );
 293   END_TEST;
 294 }
 295
 296 int UtcDaliPageTurnLandscapeViewNew(void)
 297 {
 298   ToolkitTestApplication application;
 299
 300   tet_infoline(" UtcDaliPageTurnViewNew ");
 301
 302   //Test default constructor
 303   PageTurnView landscapeView;
 304   DALI_TEST_CHECK( !landscapeView );
 305
 306   // Test object creation
 307   TestPageFactory factory(application);
 308   landscapeView = PageTurnLandscapeView::New( factory, PAGE_SIZE );
 309   DALI_TEST_CHECK( landscapeView );
 310
 311   //Additional check to ensure object is created by checking if it's registered
 312   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 313   DALI_TEST_CHECK( registry );
 314
 315   gObjectCreatedCallBackCalled = false;
 316   registry.ObjectCreatedSignal().Connect( &TestCallback );
 317   {
 318     TestPageFactory factory(application);
 319     PageTurnView landscapeView = PageTurnLandscapeView::New( factory, PAGE_SIZE );
 320   }
 321   DALI_TEST_CHECK( gObjectCreatedCallBackCalled );
 322
 323   // Test copy constructor
 324   PageTurnView viewCopy( landscapeView );
 325   DALI_TEST_CHECK( viewCopy );
 326
 327   // Test down cast
 328   Handle handleView;
 329   handleView = landscapeView;
 330   PageTurnView downCastView = PageTurnView::DownCast( handleView );
 331   DALI_TEST_CHECK( downCastView );
 332
 333   END_TEST;
 334 }
 335
 336 int UtcDaliPageTurnViewSetAndGetSpineShadowParameter(void)
 337 {
 338   ToolkitTestApplication application;
 339
 340   tet_infoline(" UtcDaliPageTurnViewSetAndGetSpineShadowParameter ");
 341
 342   TestPageFactory factory(application);
 343   PageTurnView landscapeView = PageTurnLandscapeView::New( factory, PAGE_SIZE );
 344   DALI_TEST_CHECK( landscapeView.GetSpineShadowParameter() !=  SPINE_SHADOW_PARAMETER);
 345   landscapeView.SetSpineShadowParameter(SPINE_SHADOW_PARAMETER);
 346   DALI_TEST_CHECK( landscapeView.GetSpineShadowParameter() ==  SPINE_SHADOW_PARAMETER);
 347   END_TEST;
 348 }
 349
 350 int UtcDaliPageTurnViewGoToPageAndGetCurrentPage(void)
 351 {
 352   ToolkitTestApplication application;
 353
 354   tet_infoline(" UtcDaliPageTurnViewGoToPageAndGetCurrentPage ");
 355
 356   TestPageFactory factory(application);
 357   PageTurnView portraitView = PageTurnPortraitView::New( factory, PAGE_SIZE );
 358   DALI_TEST_CHECK( portraitView.GetCurrentPage() == 0 );
 359
 360   portraitView.GoToPage( 10 );
 361   DALI_TEST_CHECK( portraitView.GetCurrentPage() == 10 );
 362
 363   portraitView.GoToPage( 5 );
 364   DALI_TEST_CHECK( portraitView.GetCurrentPage() == 5 );
 365   END_TEST;
 366 }
 367
 368 int UtcDaliPageTurnViewEnterLeaveEditMode(void)
 369 {
 370   ToolkitTestApplication application;
 371
 372   tet_infoline( " UtcDaliPageTurnViewEnterLeaveEditMode " );
 373
 374   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
 375
 376   TestPageFactory factory(application);
 377   factory.EnableOffscreenRendering( );
 378
 379   PageTurnView pageTurnView = PageTurnLandscapeView::New( factory, PAGE_SIZE );
 380   pageTurnView.SetPositionInheritanceMode( USE_PARENT_POSITION );
 381   Stage::GetCurrent().Add( pageTurnView );
 382
 383   Vector2 size = Stage::GetCurrent().GetSize();
 384
 385   pageTurnView.GoToPage(5);
 386
 387   // Render and notify
 388   application.SendNotification();
 389   application.Render(RENDER_FRAME_INTERVAL);
 390
 391   Actor actor = pageTurnView.EnterEditMode();
 392   // Test that when entering edit mode, current page source actor is returned.
 393   unsigned int pageId;
 394   std::istringstream( actor.GetName() ) >> pageId;
 395   DALI_TEST_CHECK( pageId == 5 );
 396
 397   bool signalVerified;
 398   PageTurnView currentView;
 399   unsigned int pageIndex;
 400   bool isTurningForwards;
 401   PageSignalCallback callbackPanStarted( signalVerified, currentView, pageIndex, isTurningForwards );
 402   pageTurnView.PagePanStartedSignal().Connect( &callbackPanStarted, &PageSignalCallback::PagePanSignalCallback );
 403
 404   currentView = pageTurnView;
 405   pageIndex = 5;
 406   DALI_TEST_CHECK( !callbackPanStarted.mSignalVerified );
 407
 408   // Test that the control does not receive pan gesture in edit-mode
 409   PerformGestureDiagonalSwipe( application, Vector2(size*0.75f), Vector2(size*0.01f), 10, true, true);
 410   DALI_TEST_CHECK( !callbackPanStarted.mSignalVerified );
 411
 412   pageTurnView.LeaveEditMode();
 413   // Test that the control receives pan gesture after leaving edit-mode
 414   PerformGestureDiagonalSwipe( application, Vector2(size*0.75f), Vector2(size*0.01f), 10, true, true);
 415   DALI_TEST_CHECK( callbackPanStarted.mSignalVerified );
 416   END_TEST;
 417 }
 418
 419 int UtcDaliPageTurnViewGetHitActor(void)
 420 {
 421   ToolkitTestApplication application;
 422
 423   tet_infoline(" UtcDaliPageTurnViewGetHitActor ");
 424
 425   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
 426
 427   TestPageFactory factory(application);
 428   factory.EnableOffscreenRendering( );
 429
 430   PageTurnView pageTurnView = PageTurnPortraitView::New( factory, PAGE_SIZE );
 431   pageTurnView.SetParentOrigin( ParentOrigin::TOP_LEFT );
 432   pageTurnView.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 433   Stage::GetCurrent().Add( pageTurnView );
 434
 435   // Render and notify
 436   application.SendNotification();
 437   application.Render(RENDER_FRAME_INTERVAL);
 438
 439   pageTurnView.GoToPage(3);
 440
 441   Vector2 localCoordinate = Vector2();
 442   Vector2 screenCoordinate = PAGE_SIZE*0.5f+Vector2(7.f,8.f);
 443   Actor hitActor = pageTurnView.GetHitActor( screenCoordinate, localCoordinate );
 444   DALI_TEST_CHECK( hitActor );
 445   unsigned int pageId;
 446   std::istringstream( hitActor.GetName() ) >> pageId;
 447   DALI_TEST_CHECK( pageId == 3 );
 448   DALI_TEST_EQUALS(  localCoordinate, IMAGE_SIZE*0.5f+Vector2(7.f,8.f), 0.1f, TEST_LOCATION  );
 449
 450   screenCoordinate = PAGE_SIZE*0.5f+IMAGE_SIZE;
 451   hitActor = pageTurnView.GetHitActor( screenCoordinate, localCoordinate );
 452   DALI_TEST_CHECK( !hitActor );
 453   END_TEST;
 454 }
 455
 456 int UtcDaliPageTurnViewRefresh(void)
 457 {
 458   ToolkitTestApplication application;
 459
 460   tet_infoline(" UtcDaliPageTurnViewRefresh ");
 461
 462   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
 463
 464   TestPageFactory factory(application);
 465   factory.EnableOffscreenRendering( );
 466   PageTurnView pageTurnView = PageTurnPortraitView::New( factory, PAGE_SIZE );
 467   pageTurnView.SetParentOrigin( ParentOrigin::TOP_LEFT );
 468   pageTurnView.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 469   Stage::GetCurrent().Add( pageTurnView );
 470
 471   // Render and notify
 472   application.SendNotification();
 473   application.Render(RENDER_FRAME_INTERVAL);
 474   application.Render(RENDER_FRAME_INTERVAL);
 475   application.SendNotification();
 476
 477   factory.DeletePage( 0 );
 478
 479   pageTurnView.RefreshCurrentPage();
 480   // simply calls the certain off screen render task to refresh
 481   Vector2 localCoordinate = Vector2();
 482   Vector2 screenCoordinate = PAGE_SIZE*0.5f;
 483   Actor hitActor = pageTurnView.GetHitActor( screenCoordinate, localCoordinate );
 484   unsigned int pageId;
 485   std::istringstream( hitActor.GetName() ) >> pageId;
 486   DALI_TEST_CHECK( pageId == 0 );
 487
 488   pageTurnView.RefreshAll();
 489   // re-parent all the source actors and refresh
 490   hitActor = pageTurnView.GetHitActor( screenCoordinate, localCoordinate );
 491   std::istringstream( hitActor.GetName() ) >> pageId;
 492   DALI_TEST_CHECK( pageId == 1 );
 493   END_TEST;
 494 }
 495
 496 int UtcDaliPageTurnViewSignals(void)
 497 {
 498   ToolkitTestApplication application;
 499
 500   tet_infoline(" UtcDaliPageTurnViewSignals ");
 501
 502   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
 503
 504   TestPageFactory factory(application);
 505   Vector2 size = Stage::GetCurrent().GetSize();
 506   PageTurnView portraitView = PageTurnPortraitView::New( factory, size );
 507   portraitView.SetPositionInheritanceMode( USE_PARENT_POSITION );
 508   Stage::GetCurrent().Add( portraitView );
 509
 510   // Render and notify
 511   application.SendNotification();
 512   application.Render(RENDER_FRAME_INTERVAL);
 513
 514   // [0]: testing PageTurnStartedSignal;  [1]: testing PageTurnFinishedSignal
 515   // [2]: testing PagePanStartedSignal;   [3]: testing PagePanFinishedSignal
 516   bool signalVerified[4] = {false, false, false, false};
 517   PageTurnView currentView;
 518   unsigned int pageIndex;
 519   bool isTurningForwards;
 520
 521   PageSignalCallback callbackTurnStarted( signalVerified[0], currentView, pageIndex, isTurningForwards );
 522   portraitView.PageTurnStartedSignal().Connect( &callbackTurnStarted, &PageSignalCallback::PageTurnSignalCallback );
 523
 524   PageSignalCallback callbackTurnFinished( signalVerified[1], currentView, pageIndex, isTurningForwards );
 525   portraitView.PageTurnFinishedSignal().Connect( &callbackTurnFinished, &PageSignalCallback::PageTurnSignalCallback );
 526
 527   PageSignalCallback callbackPanStarted( signalVerified[2], currentView, pageIndex, isTurningForwards );
 528   portraitView.PagePanStartedSignal().Connect( &callbackPanStarted, &PageSignalCallback::PagePanSignalCallback );
 529
 530   PageSignalCallback callbackPanFinished( signalVerified[3], currentView, pageIndex, isTurningForwards );
 531   portraitView.PagePanFinishedSignal().Connect( &callbackPanFinished, &PageSignalCallback::PagePanSignalCallback );
 532
 533   DALI_TEST_CHECK( !callbackTurnStarted.mSignalVerified );
 534   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 535   DALI_TEST_CHECK( !callbackPanStarted.mSignalVerified );
 536   DALI_TEST_CHECK( !callbackPanFinished.mSignalVerified );
 537
 538   currentView = portraitView;
 539
 540   //-----Test 1: pan 10 frames from position(size * 0.75f) to position(size * 0.25f), page 0 will be turned forward----
 541   pageIndex = 0;
 542   isTurningForwards = true;
 543   // Do a pan moving up diagonally.
 544   Vector2 start = size * 0.75f;
 545   Vector2 direction = -size*0.05f; //-size*0.5f/10.f;
 546
 547   DALI_TEST_CHECK( portraitView.GetCurrentPage() == 0);
 548   PerformGestureDiagonalSwipe( application, start, direction, 5, true, false);
 549   DALI_TEST_CHECK( callbackTurnStarted.mSignalVerified );
 550   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 551   DALI_TEST_CHECK( callbackPanStarted.mSignalVerified );
 552   DALI_TEST_CHECK( !callbackPanFinished.mSignalVerified );
 553
 554   PerformGestureDiagonalSwipe( application, start+direction*5.f, direction, 5, false, true);
 555   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 556   DALI_TEST_CHECK( callbackPanFinished.mSignalVerified );
 557
 558   Wait(application, 1000);
 559   DALI_TEST_CHECK( callbackTurnFinished.mSignalVerified );
 560   DALI_TEST_CHECK( portraitView.GetCurrentPage() == pageIndex+1); // the page is turn over
 561
 562   //---Test 2: pan from position( size*0.5f ) to position( size.width, size.height*0.5f ) to position( size * 0.75f ), page 1 will bent then slid back---
 563   callbackTurnStarted.Reset();
 564   callbackTurnFinished.Reset();
 565   callbackPanStarted.Reset();
 566   callbackPanFinished.Reset();
 567   portraitView.GoToPage(5);
 568   pageIndex = 5;
 569   isTurningForwards = true;
 570
 571   //pan 10 frames from position( size.width, size.height*0.5f ) to position( size * 0.75f )
 572   start = Vector2( size.width, size.height*0.5f );
 573   direction = Vector2(-size.width*0.025f, size.height*0.025f);
 574   PerformGestureDiagonalSwipe( application, start, direction, 5, true, false);
 575   DALI_TEST_CHECK( callbackPanStarted.mSignalVerified );
 576   DALI_TEST_CHECK( callbackTurnStarted.mSignalVerified );
 577   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 578   DALI_TEST_CHECK( !callbackPanFinished.mSignalVerified );
 579
 580   signalVerified[0] = false;
 581   isTurningForwards = false;
 582   PerformGestureDiagonalSwipe( application, start + direction*2 , direction, 5, false, true);
 583   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 584   DALI_TEST_CHECK( callbackPanFinished.mSignalVerified );
 585   DALI_TEST_CHECK( callbackTurnStarted.mSignalVerified ); // start the sliding back
 586
 587   Wait(application, 1000);
 588   DALI_TEST_CHECK( callbackTurnFinished.mSignalVerified );
 589   DALI_TEST_CHECK( portraitView.GetCurrentPage() == pageIndex); // the page is not turned over
 590
 591   // ----Test 3: pan 10 frames from position( size*0.25f ) to position( size.width*0.75f, size.height*0.25f ), the previous page will be turned backwards---
 592   callbackTurnStarted.Reset();
 593   callbackTurnFinished.Reset();
 594   callbackPanStarted.Reset();
 595   callbackPanFinished.Reset();
 596   portraitView.GoToPage(10);
 597   pageIndex = 9; // will turn the previous page back
 598   isTurningForwards = false;
 599   start = size*0.25f;
 600   direction = Vector2(size.x*0.05f, 0.f);
 601   PerformGestureDiagonalSwipe( application, start, direction, 5, true, false);
 602   DALI_TEST_CHECK( callbackPanStarted.mSignalVerified );
 603   DALI_TEST_CHECK( !callbackTurnStarted.mSignalVerified );
 604   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 605   DALI_TEST_CHECK( !callbackPanFinished.mSignalVerified );
 606
 607   PerformGestureDiagonalSwipe( application, start+direction*5.f, direction, 5, false, true);
 608   DALI_TEST_CHECK( callbackTurnStarted.mSignalVerified );
 609   DALI_TEST_CHECK( callbackPanFinished.mSignalVerified );
 610   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 611
 612   Wait( application, 1000 );
 613
 614   DALI_TEST_CHECK( callbackTurnFinished.mSignalVerified );
 615   DALI_TEST_CHECK( portraitView.GetCurrentPage() == 9);
 616   END_TEST;
 617 }