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

   1 /*
   2  * Copyright (c) 2019 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/integration-api/events/pan-gesture-event.h>
  24 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
  25 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
  26 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
  27 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
  28
  29 using namespace Dali;
  30 using namespace Dali::Toolkit;
  31
  32 namespace
  33 {
  34 const int RENDER_FRAME_INTERVAL = 16;                           ///< Duration of each frame in ms. (at approx 60FPS)
  35 const unsigned int TOTAL_PAGE_NUMBER = 20;
  36 const Vector2 PAGE_SIZE( 300.f,400.f );
  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( bool returnValidTexture = true )
 189   : mValidTexture( returnValidTexture )
 190   {
 191     mTotalPageNumber = TOTAL_PAGE_NUMBER;
 192   }
 193
 194   /**
 195    * Query the number of pages available from the factory.
 196    * The maximum available page has an ID of GetNumberOfPages()-1.
 197    */
 198   virtual unsigned int GetNumberOfPages()
 199   {
 200     return mTotalPageNumber;
 201   }
 202
 203   /**
 204    * Create an texture to represent a page content.
 205    * @param[in] pageId The ID of the page to create.
 206    * @return An image, or an empty handle if the ID is out of range.
 207    */
 208   virtual Texture NewPage( unsigned int pageId )
 209   {
 210     if( mValidTexture )
 211     {
 212       return Texture::New( Dali::TextureType::TEXTURE_2D, Pixel::RGB888, 100, 100 );
 213     }
 214     return Texture(); // empty handle
 215   }
 216
 217 private:
 218   unsigned int            mTotalPageNumber;
 219   bool                    mValidTexture;
 220 };
 221
 222 }// namespace
 223
 224 void dali_page_turn_view_startup(void)
 225 {
 226   test_return_value = TET_UNDEF;
 227 }
 228
 229 void dali_page_turn_view_cleanup(void)
 230 {
 231   test_return_value = TET_PASS;
 232 }
 233
 234 int UtcDaliPageTurnPortraitViewNew(void)
 235 {
 236   ToolkitTestApplication application;
 237
 238   tet_infoline(" UtcDaliPageTurnViewNew ");
 239
 240   // Test default constructor
 241   PageTurnView portraitView;
 242   DALI_TEST_CHECK( !portraitView );
 243
 244   // Test object creation
 245   TestPageFactory factory;
 246   portraitView = PageTurnPortraitView::New( factory, PAGE_SIZE );
 247   DALI_TEST_CHECK( portraitView );
 248
 249   //Additional check to ensure object is created by checking if it's registered
 250   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 251   DALI_TEST_CHECK( registry );
 252
 253   gObjectCreatedCallBackCalled = false;
 254   registry.ObjectCreatedSignal().Connect( &TestCallback );
 255   {
 256     TestPageFactory factory;
 257     PageTurnView portraitView = PageTurnPortraitView::New( factory, PAGE_SIZE );
 258   }
 259   DALI_TEST_CHECK( gObjectCreatedCallBackCalled );
 260
 261   // Test copy constructor
 262   PageTurnView viewCopy( portraitView );
 263   DALI_TEST_CHECK( viewCopy );
 264
 265   // Test down cast
 266   Handle handleView;
 267   handleView = portraitView;
 268   PageTurnView downCastView = PageTurnView::DownCast( handleView );
 269   DALI_TEST_CHECK( downCastView );
 270
 271   END_TEST;
 272 }
 273
 274 int UtcDaliPageTurnLandscapeViewNew(void)
 275 {
 276   ToolkitTestApplication application;
 277
 278   tet_infoline(" UtcDaliPageTurnViewNew ");
 279
 280   //Test default constructor
 281   PageTurnView landscapeView;
 282   DALI_TEST_CHECK( !landscapeView );
 283
 284   // Test object creation
 285   TestPageFactory factory;
 286   landscapeView = PageTurnLandscapeView::New( factory, PAGE_SIZE );
 287   DALI_TEST_CHECK( landscapeView );
 288
 289   //Additional check to ensure object is created by checking if it's registered
 290   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 291   DALI_TEST_CHECK( registry );
 292
 293   gObjectCreatedCallBackCalled = false;
 294   registry.ObjectCreatedSignal().Connect( &TestCallback );
 295   {
 296     TestPageFactory factory;
 297     PageTurnView landscapeView = PageTurnLandscapeView::New( factory, PAGE_SIZE );
 298   }
 299   DALI_TEST_CHECK( gObjectCreatedCallBackCalled );
 300
 301   // Test copy constructor
 302   PageTurnView viewCopy( landscapeView );
 303   DALI_TEST_CHECK( viewCopy );
 304
 305   // Test down cast
 306   Handle handleView;
 307   handleView = landscapeView;
 308   PageTurnView downCastView = PageTurnView::DownCast( handleView );
 309   DALI_TEST_CHECK( downCastView );
 310
 311   END_TEST;
 312 }
 313
 314 int UtcDaliPageTurnPortraitViewCopyConstructorAndAssignment(void)
 315 {
 316   ToolkitTestApplication application;
 317
 318   tet_infoline(" UtcDaliPageTurnPortraitViewCopyConstructorAndAssignment ");
 319
 320   // Test default constructor
 321   PageTurnPortraitView portraitView;
 322   DALI_TEST_CHECK( !portraitView );
 323
 324   // Test object creation
 325   TestPageFactory factory;
 326   portraitView = PageTurnPortraitView::New( factory, PAGE_SIZE );
 327   DALI_TEST_CHECK( portraitView );
 328
 329   // Test copy constructor
 330   PageTurnPortraitView viewCopy( portraitView );
 331   DALI_TEST_CHECK( viewCopy );
 332
 333   // Test assignment
 334   PageTurnPortraitView portraitView2;
 335   portraitView2 = portraitView;
 336   DALI_TEST_CHECK( portraitView2 );
 337   DALI_TEST_CHECK( portraitView == portraitView2);
 338
 339   // Test down cast
 340   Handle handleView;
 341   handleView = portraitView;
 342   PageTurnPortraitView downCastView = PageTurnPortraitView::DownCast( handleView );
 343   DALI_TEST_CHECK( downCastView );
 344
 345   END_TEST;
 346 }
 347
 348 int UtcDaliPageTurnLandscapeViewCopyConstructorAndAssignment(void)
 349 {
 350   ToolkitTestApplication application;
 351
 352   tet_infoline(" UtcDaliPageTurnLandscapeViewCopyConstructorAndAssignment ");
 353
 354   // Test default constructor
 355   PageTurnLandscapeView landscapeView;
 356   DALI_TEST_CHECK( !landscapeView );
 357
 358   // Test object creation
 359   TestPageFactory factory;
 360   landscapeView = PageTurnLandscapeView::New( factory, PAGE_SIZE );
 361   DALI_TEST_CHECK( landscapeView );
 362
 363   // Test copy constructor
 364   PageTurnLandscapeView viewCopy( landscapeView );
 365   DALI_TEST_CHECK( viewCopy );
 366
 367   // Test assignment
 368   PageTurnLandscapeView landscapeView2;
 369   landscapeView2 = landscapeView;
 370   DALI_TEST_CHECK( landscapeView2 );
 371   DALI_TEST_CHECK( landscapeView == landscapeView2);
 372
 373   // Test down cast
 374   Handle handleView;
 375   handleView = landscapeView;
 376   PageTurnLandscapeView downCastView = PageTurnLandscapeView::DownCast( handleView );
 377   DALI_TEST_CHECK( downCastView );
 378
 379   END_TEST;
 380 }
 381
 382 int UtcDaliPageTurnViewSetGetProperty(void)
 383 {
 384   ToolkitTestApplication application;
 385
 386   tet_infoline(" UtcDaliPageTurnViewSetGetProperty ");
 387
 388   TestPageFactory factory;
 389   PageTurnView landscapeView = PageTurnLandscapeView::New( factory, PAGE_SIZE );
 390   DALI_TEST_CHECK( landscapeView );
 391
 392   Stage::GetCurrent().Add( landscapeView );
 393
 394   // Test "pageSize" property
 395   DALI_TEST_CHECK( landscapeView.GetPropertyIndex("pageSize") == PageTurnView::Property::PAGE_SIZE  );
 396   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::PAGE_SIZE).Get<Vector2>(), PAGE_SIZE, TEST_LOCATION );
 397
 398   Vector2 newSize( PAGE_SIZE.x*0.75, PAGE_SIZE.y*0.5f );
 399   landscapeView.SetProperty( PageTurnView::Property::PAGE_SIZE, newSize );
 400   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::PAGE_SIZE).Get<Vector2>(), newSize, TEST_LOCATION );
 401   Wait( application);
 402   DALI_TEST_EQUALS( Vector2(landscapeView.GetTargetSize()), Vector2(newSize.x*2.f, newSize.y), TEST_LOCATION);
 403
 404   landscapeView.SetProperty( PageTurnView::Property::PAGE_SIZE,newSize*1.5f);
 405   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::PAGE_SIZE).Get<Vector2>(), newSize*1.5f, TEST_LOCATION );
 406   Wait( application);
 407   DALI_TEST_EQUALS( Vector2(landscapeView.GetTargetSize()), Vector2(newSize.x*3.f, newSize.y*1.5f), TEST_LOCATION);
 408
 409   // Test "currentPageId" property
 410   DALI_TEST_CHECK( landscapeView.GetPropertyIndex("currentPageId") == PageTurnView::Property::CURRENT_PAGE_ID );
 411   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), 0, TEST_LOCATION );
 412
 413   int pageId = static_cast<int>(TOTAL_PAGE_NUMBER)/3;
 414   landscapeView.SetProperty( PageTurnView::Property::CURRENT_PAGE_ID, pageId );
 415   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), pageId, TEST_LOCATION );
 416
 417   landscapeView.SetProperty( PageTurnView::Property::CURRENT_PAGE_ID, pageId*2 );
 418   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), pageId*2, TEST_LOCATION );
 419
 420   // Test "spinShadow" property
 421   DALI_TEST_CHECK( landscapeView.GetPropertyIndex( "spineShadow" ) == PageTurnView::Property::SPINE_SHADOW );
 422   landscapeView.SetProperty( PageTurnView::Property::SPINE_SHADOW, SPINE_SHADOW_PARAMETER );
 423   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::SPINE_SHADOW).Get<Vector2>(), SPINE_SHADOW_PARAMETER, TEST_LOCATION );
 424
 425   landscapeView.SetProperty( PageTurnView::Property::SPINE_SHADOW,  SPINE_SHADOW_PARAMETER*0.75f );
 426   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::SPINE_SHADOW).Get<Vector2>(), SPINE_SHADOW_PARAMETER*0.75f, TEST_LOCATION );
 427
 428   END_TEST;
 429 }
 430
 431 int UtcDaliPageTurnPortraitViewSignals(void)
 432 {
 433   ToolkitTestApplication application;
 434
 435   tet_infoline(" UtcDaliPageTurnPortraitViewSignals ");
 436
 437   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
 438
 439   TestPageFactory factory;
 440   Vector2 size = Stage::GetCurrent().GetSize();
 441   PageTurnView portraitView = PageTurnPortraitView::New( factory, size );
 442   portraitView.SetParentOrigin( ParentOrigin::CENTER );
 443   Stage::GetCurrent().Add( portraitView );
 444
 445   // Render and notify
 446   application.SendNotification();
 447   application.Render(RENDER_FRAME_INTERVAL);
 448
 449   // [0]: testing PageTurnStartedSignal;  [1]: testing PageTurnFinishedSignal
 450   // [2]: testing PagePanStartedSignal;   [3]: testing PagePanFinishedSignal
 451   bool signalVerified[4] = {false, false, false, false};
 452   PageTurnView currentView;
 453   unsigned int pageIndex;
 454   bool isTurningForwards;
 455
 456   PageSignalCallback callbackTurnStarted( signalVerified[0], currentView, pageIndex, isTurningForwards );
 457   portraitView.PageTurnStartedSignal().Connect( &callbackTurnStarted, &PageSignalCallback::PageTurnSignalCallback );
 458
 459   PageSignalCallback callbackTurnFinished( signalVerified[1], currentView, pageIndex, isTurningForwards );
 460   portraitView.PageTurnFinishedSignal().Connect( &callbackTurnFinished, &PageSignalCallback::PageTurnSignalCallback );
 461
 462   PageSignalCallback callbackPanStarted( signalVerified[2], currentView, pageIndex, isTurningForwards );
 463   portraitView.PagePanStartedSignal().Connect( &callbackPanStarted, &PageSignalCallback::PagePanSignalCallback );
 464
 465   PageSignalCallback callbackPanFinished( signalVerified[3], currentView, pageIndex, isTurningForwards );
 466   portraitView.PagePanFinishedSignal().Connect( &callbackPanFinished, &PageSignalCallback::PagePanSignalCallback );
 467
 468   DALI_TEST_CHECK( !callbackTurnStarted.mSignalVerified );
 469   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 470   DALI_TEST_CHECK( !callbackPanStarted.mSignalVerified );
 471   DALI_TEST_CHECK( !callbackPanFinished.mSignalVerified );
 472
 473   currentView = portraitView;
 474
 475   //-----Test 1: pan 10 frames from position(size * 0.75f) to position(size * 0.25f), page 0 will be turned forward----
 476   pageIndex = 0;
 477   isTurningForwards = true;
 478   // Do a pan moving up diagonally.
 479   Vector2 start = size * 0.75f;
 480   Vector2 direction = -size*0.05f; //-size*0.5f/10.f;
 481
 482   DALI_TEST_EQUALS( portraitView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), 0, TEST_LOCATION );
 483   PerformGestureDiagonalSwipe( application, start, direction, 5, true, false);
 484   DALI_TEST_CHECK( callbackTurnStarted.mSignalVerified );
 485   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 486   DALI_TEST_CHECK( callbackPanStarted.mSignalVerified );
 487   DALI_TEST_CHECK( !callbackPanFinished.mSignalVerified );
 488
 489   PerformGestureDiagonalSwipe( application, start+direction*5.f, direction, 5, false, true);
 490   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 491   DALI_TEST_CHECK( callbackPanFinished.mSignalVerified );
 492
 493   Wait(application, 1000);
 494   DALI_TEST_CHECK( callbackTurnFinished.mSignalVerified );
 495   // the page is turned over
 496   DALI_TEST_EQUALS( portraitView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), (int)(pageIndex+1), TEST_LOCATION );
 497
 498   //---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---
 499   callbackTurnStarted.Reset();
 500   callbackTurnFinished.Reset();
 501   callbackPanStarted.Reset();
 502   callbackPanFinished.Reset();
 503   portraitView.SetProperty( PageTurnView::Property::CURRENT_PAGE_ID, 5 );
 504   pageIndex = 5;
 505   isTurningForwards = true;
 506
 507   //pan 10 frames from position( size.width, size.height*0.5f ) to position( size * 0.75f )
 508   start = Vector2( size.width, size.height*0.5f );
 509   direction = Vector2(-size.width*0.025f, size.height*0.025f);
 510   PerformGestureDiagonalSwipe( application, start, direction, 5, true, false);
 511   DALI_TEST_CHECK( callbackPanStarted.mSignalVerified );
 512   DALI_TEST_CHECK( callbackTurnStarted.mSignalVerified );
 513   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 514   DALI_TEST_CHECK( !callbackPanFinished.mSignalVerified );
 515
 516   signalVerified[0] = false;
 517   isTurningForwards = false;
 518   PerformGestureDiagonalSwipe( application, start + direction*2 , direction, 5, false, true);
 519   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 520   DALI_TEST_CHECK( callbackPanFinished.mSignalVerified );
 521   DALI_TEST_CHECK( callbackTurnStarted.mSignalVerified ); // start the sliding back
 522
 523   Wait(application, 1000);
 524   DALI_TEST_CHECK( callbackTurnFinished.mSignalVerified );
 525   DALI_TEST_EQUALS( portraitView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), (int)pageIndex, TEST_LOCATION ); // the page is not turned over
 526
 527   // ----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---
 528   callbackTurnStarted.Reset();
 529   callbackTurnFinished.Reset();
 530   callbackPanStarted.Reset();
 531   callbackPanFinished.Reset();
 532   portraitView.SetProperty( PageTurnView::Property::CURRENT_PAGE_ID, 10);
 533   pageIndex = 9; // will turn the previous page back
 534   isTurningForwards = false;
 535   start = size*0.25f;
 536   direction = Vector2(size.x*0.05f, 0.f);
 537   PerformGestureDiagonalSwipe( application, start, direction, 5, true, false);
 538   DALI_TEST_CHECK( callbackPanStarted.mSignalVerified );
 539   DALI_TEST_CHECK( !callbackTurnStarted.mSignalVerified );
 540   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 541   DALI_TEST_CHECK( !callbackPanFinished.mSignalVerified );
 542
 543   PerformGestureDiagonalSwipe( application, start+direction*5.f, direction, 5, false, true);
 544   DALI_TEST_CHECK( callbackTurnStarted.mSignalVerified );
 545   DALI_TEST_CHECK( callbackPanFinished.mSignalVerified );
 546   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 547
 548   Wait( application, 1000 );
 549
 550   DALI_TEST_CHECK( callbackTurnFinished.mSignalVerified );
 551   DALI_TEST_EQUALS( portraitView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), 9, TEST_LOCATION );
 552   END_TEST;
 553 }
 554
 555 int UtcDaliPageTurnLanscapeViewSignals(void)
 556 {
 557   ToolkitTestApplication application;
 558
 559   tet_infoline(" UtcDaliPageTurnLanscapeViewSignals ");
 560
 561   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
 562   /***
 563    * -----------------
 564    * |               |
 565    * |---------------|
 566    * |bookboo|bookboo|
 567    * |kbookbo|kbookbo|
 568    * |okbookb|okbookb|
 569    * |ookbook|ookbook|
 570    * |bookboo|bookboo|
 571    * |---------------|
 572    * |               |
 573    * ----------------
 574    */
 575
 576   TestPageFactory factory;
 577   Vector2 stageSize = Stage::GetCurrent().GetSize();
 578   PageTurnView landscapeView = PageTurnLandscapeView::New( factory, Vector2(stageSize.x*0.5f, stageSize.x*0.8f) );
 579   landscapeView.SetParentOrigin( ParentOrigin::CENTER );
 580   Stage::GetCurrent().Add( landscapeView );
 581
 582   // Render and notify
 583   application.SendNotification();
 584   application.Render(RENDER_FRAME_INTERVAL);
 585
 586   // [0]: testing PageTurnStartedSignal;  [1]: testing PageTurnFinishedSignal
 587   // [2]: testing PagePanStartedSignal;   [3]: testing PagePanFinishedSignal
 588   bool signalVerified[4] = {false, false, false, false};
 589   PageTurnView currentView;
 590   unsigned int pageIndex;
 591   bool isTurningForwards;
 592
 593   PageSignalCallback callbackTurnStarted( signalVerified[0], currentView, pageIndex, isTurningForwards );
 594   landscapeView.PageTurnStartedSignal().Connect( &callbackTurnStarted, &PageSignalCallback::PageTurnSignalCallback );
 595
 596   PageSignalCallback callbackTurnFinished( signalVerified[1], currentView, pageIndex, isTurningForwards );
 597   landscapeView.PageTurnFinishedSignal().Connect( &callbackTurnFinished, &PageSignalCallback::PageTurnSignalCallback );
 598
 599   PageSignalCallback callbackPanStarted( signalVerified[2], currentView, pageIndex, isTurningForwards );
 600   landscapeView.PagePanStartedSignal().Connect( &callbackPanStarted, &PageSignalCallback::PagePanSignalCallback );
 601
 602   PageSignalCallback callbackPanFinished( signalVerified[3], currentView, pageIndex, isTurningForwards );
 603   landscapeView.PagePanFinishedSignal().Connect( &callbackPanFinished, &PageSignalCallback::PagePanSignalCallback );
 604
 605   DALI_TEST_CHECK( !callbackTurnStarted.mSignalVerified );
 606   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 607   DALI_TEST_CHECK( !callbackPanStarted.mSignalVerified );
 608   DALI_TEST_CHECK( !callbackPanFinished.mSignalVerified );
 609
 610   currentView = landscapeView;
 611
 612   //-----Test 1: pan 10 frames from position(stageSize.x * 0.85f, stageSize.y*0.5) to position(stageSize.x * 0.45f, stageSize.y*0.5-stageSize.x * 0.3f), page 0 will be turned forward----
 613   pageIndex = 0;
 614   isTurningForwards = true;
 615   // Do a pan to the left.
 616   Vector2 start = Vector2(stageSize.x * 0.85f, stageSize.y*0.5);
 617   Vector2 direction = Vector2(-stageSize.x*0.04f, -stageSize.x*0.03f);
 618
 619   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), 0, TEST_LOCATION );
 620   PerformGestureDiagonalSwipe( application, start, direction, 5, true, false);
 621   DALI_TEST_CHECK( callbackTurnStarted.mSignalVerified );
 622   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 623   DALI_TEST_CHECK( callbackPanStarted.mSignalVerified );
 624   DALI_TEST_CHECK( !callbackPanFinished.mSignalVerified );
 625
 626   PerformGestureDiagonalSwipe( application, start+direction*5.f, direction, 5, false, true);
 627   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 628   DALI_TEST_CHECK( callbackPanFinished.mSignalVerified );
 629
 630   Wait(application, 1000);
 631   DALI_TEST_CHECK( callbackTurnFinished.mSignalVerified );
 632   // the page is turned over
 633   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), (int)(pageIndex+1), TEST_LOCATION );
 634
 635   //---Test 2: pan from position(stageSize.x * 0.15f, stageSize.y*0.5) to position(stageSize.x * 0.45f, stageSize.y*0.5) page 4 will be turned back---
 636   callbackTurnStarted.Reset();
 637   callbackTurnFinished.Reset();
 638   callbackPanStarted.Reset();
 639   callbackPanFinished.Reset();
 640   isTurningForwards = false;
 641
 642   //pan 10 frames from position( size.width, size.height*0.5f ) to position( size * 0.75f )
 643   start = Vector2( stageSize.x * 0.15f, stageSize.y*0.5f );
 644   direction = Vector2(stageSize.x * 0.03f, 0.f);
 645   PerformGestureDiagonalSwipe( application, start, direction, 5, true, false);
 646   DALI_TEST_CHECK( callbackPanStarted.mSignalVerified );
 647   DALI_TEST_CHECK( callbackTurnStarted.mSignalVerified );
 648   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 649   DALI_TEST_CHECK( !callbackPanFinished.mSignalVerified );
 650
 651   PerformGestureDiagonalSwipe( application, start + direction*5.f , direction, 5, false, true);
 652   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 653   DALI_TEST_CHECK( callbackPanFinished.mSignalVerified );
 654
 655   Wait(application, 1000);
 656   DALI_TEST_CHECK( callbackTurnFinished.mSignalVerified );
 657   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), 0, TEST_LOCATION ); // the first page is turned back
 658
 659   // ----Test 3: pan 10 frames from position( size*0.55f ) to position( size.width*0.8f, size.height*0.5f ), no page turn will be started---
 660   callbackTurnStarted.Reset();
 661   callbackTurnFinished.Reset();
 662   callbackPanStarted.Reset();
 663   callbackPanFinished.Reset();
 664   isTurningForwards = false;
 665   start = stageSize*0.55f;
 666   direction = Vector2(stageSize.x*0.025f, 0.f);
 667   PerformGestureDiagonalSwipe( application, start, direction, 5, true, false);
 668   DALI_TEST_CHECK( callbackPanStarted.mSignalVerified );
 669   DALI_TEST_CHECK( !callbackTurnStarted.mSignalVerified );
 670   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 671   DALI_TEST_CHECK( !callbackPanFinished.mSignalVerified );
 672
 673   PerformGestureDiagonalSwipe( application, start+direction*5.f, direction, 5, false, true);
 674   DALI_TEST_CHECK( !callbackTurnStarted.mSignalVerified );
 675   DALI_TEST_CHECK( callbackPanFinished.mSignalVerified );
 676   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 677
 678   Wait( application, 1000 );
 679
 680   DALI_TEST_CHECK( !callbackTurnFinished.mSignalVerified );
 681   DALI_TEST_EQUALS( landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), 0, TEST_LOCATION );
 682   END_TEST;
 683 }
 684
 685 int UtcDaliPageImageFactoryGetExtention(void)
 686 {
 687   ToolkitTestApplication application;
 688   TestPageFactory factory;
 689   DALI_TEST_CHECK( factory.GetExtension() == NULL );
 690   END_TEST;
 691 }
 692
 693 int UtcDaliPageTurnEmptyTextureHandle(void)
 694 {
 695   ToolkitTestApplication application;
 696
 697   tet_infoline(" UtcDaliPageTurnEmptyTextureHandle ");
 698
 699   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE );
 700
 701   TestPageFactory factory( false /* returns empty handles */ );
 702   Vector2 size = Stage::GetCurrent().GetSize();
 703   try
 704   {
 705     PageTurnView portraitView = PageTurnPortraitView::New( factory, size );
 706     portraitView.SetParentOrigin( ParentOrigin::CENTER );
 707     Stage::GetCurrent().Add( portraitView );
 708
 709     tet_result(TET_FAIL);
 710   }
 711   catch (DaliException& e)
 712   {
 713     DALI_TEST_ASSERT(e, "must pass in valid texture", TEST_LOCATION );
 714   }
 715   catch (...)
 716   {
 717     tet_result(TET_FAIL);
 718   }
 719
 720   END_TEST;
 721 }
 722