automated-tests/src/dali-toolkit-unmanaged/utc-Dali-PageTurnView.cpp

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