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