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