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