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

   1 /*
   2  * Copyright (c) 2022 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 <dali-toolkit-test-suite-utils.h>
  19 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
  20 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
  21 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
  22 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
  23 #include <dali/integration-api/events/touch-event-integ.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <iostream>
  27 #include <sstream>
  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      VIEW_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 int Wait(ToolkitTestApplication& application, int duration = 0)
  54 {
  55   int time = 0;
  56
  57   for(int i = 0; i <= (duration / RENDER_FRAME_INTERVAL); i++)
  58   {
  59     application.SendNotification();
  60     application.Render(RENDER_FRAME_INTERVAL);
  61     time += RENDER_FRAME_INTERVAL;
  62   }
  63
  64   return time;
  65 }
  66
  67 static Vector2 PerformGestureDiagonalSwipe(ToolkitTestApplication& application, Vector2 start, Vector2 direction, int frames, uint32_t& time, bool toStart = true, bool toFinish = true)
  68 {
  69   Vector2 pos(start);
  70
  71   if(toStart)
  72   {
  73     // Now do a pan starting from (start + 20) and heading (direction)
  74     Vector2 pos_start_jump(start + Vector2(15.0f, 0.0f));
  75     TestStartPan(application, start, pos_start_jump, time);
  76     pos += direction;
  77   }
  78
  79   time += Wait(application);
  80
  81   for(int i = 0; i < frames; i++)
  82   {
  83     pos += direction;
  84     TestMovePan(application, pos, time);
  85     time += Wait(application);
  86   }
  87
  88   if(toFinish)
  89   {
  90     pos += direction;
  91     TestEndPan(application, pos, time);
  92     time += Wait(application);
  93   }
  94
  95   return pos;
  96 }
  97
  98 //Functor to test whether PageTurnSignal / PagePanSignal is emitted
  99 class PageSignalCallback : public Dali::ConnectionTracker
 100 {
 101 public:
 102   PageSignalCallback(bool& signalReceived, PageTurnView& view, unsigned int& pageIndex, bool& isForwards)
 103   : mSignalVerified(signalReceived),
 104     mView(view),
 105     mPageIndex(pageIndex),
 106     mIsTurningForwards(isForwards)
 107   {
 108   }
 109
 110   // callback to be connected to PageTurnSignal
 111   void PageTurnSignalCallback(PageTurnView view, unsigned int pageIndex, bool isTurningForward)
 112   {
 113     tet_infoline("Verifying PageTurnedSignal");
 114
 115     if(mView == view && mPageIndex == pageIndex && mIsTurningForwards == isTurningForward)
 116     {
 117       mSignalVerified = true;
 118     }
 119   }
 120
 121   // callback to be connected to PagePanSignal
 122   void PagePanSignalCallback(PageTurnView view)
 123   {
 124     tet_infoline("Verifying PagePannedSignal");
 125
 126     if(mView == view)
 127     {
 128       mSignalVerified = true;
 129     }
 130   }
 131
 132   void Reset()
 133   {
 134     mSignalVerified = false;
 135   }
 136
 137   bool&         mSignalVerified;
 138   PageTurnView& mView;
 139   unsigned int& mPageIndex;
 140   bool&         mIsTurningForwards;
 141 };
 142
 143 //Implementation of PageFactory for providing page actors to PageTurnView
 144 class TestPageFactory : public PageFactory
 145 {
 146 public:
 147   TestPageFactory(bool returnValidTexture = true)
 148   : mValidTexture(returnValidTexture)
 149   {
 150     mTotalPageNumber = TOTAL_PAGE_NUMBER;
 151   }
 152
 153   /**
 154    * Query the number of pages available from the factory.
 155    * The maximum available page has an ID of GetNumberOfPages()-1.
 156    */
 157   virtual unsigned int GetNumberOfPages()
 158   {
 159     return mTotalPageNumber;
 160   }
 161
 162   /**
 163    * Create an texture to represent a page content.
 164    * @param[in] pageId The ID of the page to create.
 165    * @return An image, or an empty handle if the ID is out of range.
 166    */
 167   virtual Texture NewPage(unsigned int pageId)
 168   {
 169     if(mValidTexture)
 170     {
 171       return Texture::New(Dali::TextureType::TEXTURE_2D, Pixel::RGB888, 100, 100);
 172     }
 173     return Texture(); // empty handle
 174   }
 175
 176 private:
 177   unsigned int mTotalPageNumber;
 178   bool         mValidTexture;
 179 };
 180
 181 } // namespace
 182
 183 void dali_page_turn_view_startup(void)
 184 {
 185   test_return_value = TET_UNDEF;
 186 }
 187
 188 void dali_page_turn_view_cleanup(void)
 189 {
 190   test_return_value = TET_PASS;
 191 }
 192
 193 int UtcDaliPageTurnPortraitViewNew(void)
 194 {
 195   ToolkitTestApplication application;
 196
 197   tet_infoline(" UtcDaliPageTurnViewNew ");
 198
 199   // Test default constructor
 200   PageTurnView portraitView;
 201   DALI_TEST_CHECK(!portraitView);
 202
 203   // Test object creation
 204   TestPageFactory factory;
 205   portraitView = PageTurnPortraitView::New(factory, VIEW_PAGE_SIZE);
 206   DALI_TEST_CHECK(portraitView);
 207
 208   //Additional check to ensure object is created by checking if it's registered
 209   ObjectRegistry registry = application.GetCore().GetObjectRegistry();
 210   DALI_TEST_CHECK(registry);
 211
 212   gObjectCreatedCallBackCalled = false;
 213   registry.ObjectCreatedSignal().Connect(&TestCallback);
 214   {
 215     TestPageFactory factory;
 216     PageTurnView    portraitView = PageTurnPortraitView::New(factory, VIEW_PAGE_SIZE);
 217   }
 218   DALI_TEST_CHECK(gObjectCreatedCallBackCalled);
 219
 220   // Test copy constructor
 221   PageTurnView viewCopy(portraitView);
 222   DALI_TEST_CHECK(viewCopy);
 223
 224   // Test down cast
 225   Handle handleView;
 226   handleView                = portraitView;
 227   PageTurnView downCastView = PageTurnView::DownCast(handleView);
 228   DALI_TEST_CHECK(downCastView);
 229
 230   END_TEST;
 231 }
 232
 233 int UtcDaliPageTurnLandscapeViewNew(void)
 234 {
 235   ToolkitTestApplication application;
 236
 237   tet_infoline(" UtcDaliPageTurnViewNew ");
 238
 239   //Test default constructor
 240   PageTurnView landscapeView;
 241   DALI_TEST_CHECK(!landscapeView);
 242
 243   // Test object creation
 244   TestPageFactory factory;
 245   landscapeView = PageTurnLandscapeView::New(factory, VIEW_PAGE_SIZE);
 246   DALI_TEST_CHECK(landscapeView);
 247
 248   //Additional check to ensure object is created by checking if it's registered
 249   ObjectRegistry registry = application.GetCore().GetObjectRegistry();
 250   DALI_TEST_CHECK(registry);
 251
 252   gObjectCreatedCallBackCalled = false;
 253   registry.ObjectCreatedSignal().Connect(&TestCallback);
 254   {
 255     TestPageFactory factory;
 256     PageTurnView    landscapeView = PageTurnLandscapeView::New(factory, VIEW_PAGE_SIZE);
 257   }
 258   DALI_TEST_CHECK(gObjectCreatedCallBackCalled);
 259
 260   // Test copy constructor
 261   PageTurnView viewCopy(landscapeView);
 262   DALI_TEST_CHECK(viewCopy);
 263
 264   // Test down cast
 265   Handle handleView;
 266   handleView                = landscapeView;
 267   PageTurnView downCastView = PageTurnView::DownCast(handleView);
 268   DALI_TEST_CHECK(downCastView);
 269
 270   END_TEST;
 271 }
 272
 273 int UtcDaliPageTurnPortraitViewCopyConstructorAndAssignment(void)
 274 {
 275   ToolkitTestApplication application;
 276
 277   tet_infoline(" UtcDaliPageTurnPortraitViewCopyConstructorAndAssignment ");
 278
 279   // Test default constructor
 280   PageTurnPortraitView portraitView;
 281   DALI_TEST_CHECK(!portraitView);
 282
 283   // Test object creation
 284   TestPageFactory factory;
 285   portraitView = PageTurnPortraitView::New(factory, VIEW_PAGE_SIZE);
 286   DALI_TEST_CHECK(portraitView);
 287
 288   // Test copy constructor
 289   PageTurnPortraitView viewCopy(portraitView);
 290   DALI_TEST_CHECK(viewCopy);
 291
 292   // Test assignment
 293   PageTurnPortraitView portraitView2;
 294   portraitView2 = portraitView;
 295   DALI_TEST_CHECK(portraitView2);
 296   DALI_TEST_CHECK(portraitView == portraitView2);
 297
 298   // Test down cast
 299   Handle handleView;
 300   handleView                        = portraitView;
 301   PageTurnPortraitView downCastView = PageTurnPortraitView::DownCast(handleView);
 302   DALI_TEST_CHECK(downCastView);
 303
 304   END_TEST;
 305 }
 306
 307 int UtcDaliPageTurnLandscapeViewCopyConstructorAndAssignment(void)
 308 {
 309   ToolkitTestApplication application;
 310
 311   tet_infoline(" UtcDaliPageTurnLandscapeViewCopyConstructorAndAssignment ");
 312
 313   // Test default constructor
 314   PageTurnLandscapeView landscapeView;
 315   DALI_TEST_CHECK(!landscapeView);
 316
 317   // Test object creation
 318   TestPageFactory factory;
 319   landscapeView = PageTurnLandscapeView::New(factory, VIEW_PAGE_SIZE);
 320   DALI_TEST_CHECK(landscapeView);
 321
 322   // Test copy constructor
 323   PageTurnLandscapeView viewCopy(landscapeView);
 324   DALI_TEST_CHECK(viewCopy);
 325
 326   // Test assignment
 327   PageTurnLandscapeView landscapeView2;
 328   landscapeView2 = landscapeView;
 329   DALI_TEST_CHECK(landscapeView2);
 330   DALI_TEST_CHECK(landscapeView == landscapeView2);
 331
 332   // Test down cast
 333   Handle handleView;
 334   handleView                         = landscapeView;
 335   PageTurnLandscapeView downCastView = PageTurnLandscapeView::DownCast(handleView);
 336   DALI_TEST_CHECK(downCastView);
 337
 338   END_TEST;
 339 }
 340
 341 int UtcDaliPageTurnViewSetGetProperty(void)
 342 {
 343   ToolkitTestApplication application;
 344
 345   tet_infoline(" UtcDaliPageTurnViewSetGetProperty ");
 346
 347   TestPageFactory factory;
 348   PageTurnView    landscapeView = PageTurnLandscapeView::New(factory, VIEW_PAGE_SIZE);
 349   DALI_TEST_CHECK(landscapeView);
 350
 351   application.GetScene().Add(landscapeView);
 352
 353   // Test "viewPageSize" property
 354   DALI_TEST_CHECK(landscapeView.GetPropertyIndex("viewPageSize") == PageTurnView::Property::VIEW_PAGE_SIZE);
 355   DALI_TEST_EQUALS(landscapeView.GetProperty(PageTurnView::Property::VIEW_PAGE_SIZE).Get<Vector2>(), VIEW_PAGE_SIZE, TEST_LOCATION);
 356
 357   Vector2 newSize(VIEW_PAGE_SIZE.x * 0.75, VIEW_PAGE_SIZE.y * 0.5f);
 358   landscapeView.SetProperty(PageTurnView::Property::VIEW_PAGE_SIZE, newSize);
 359   DALI_TEST_EQUALS(landscapeView.GetProperty(PageTurnView::Property::VIEW_PAGE_SIZE).Get<Vector2>(), newSize, TEST_LOCATION);
 360   Wait(application);
 361   DALI_TEST_EQUALS(Vector2(landscapeView.GetTargetSize()), Vector2(newSize.x * 2.f, newSize.y), TEST_LOCATION);
 362
 363   landscapeView.SetProperty(PageTurnView::Property::VIEW_PAGE_SIZE, newSize * 1.5f);
 364   DALI_TEST_EQUALS(landscapeView.GetProperty(PageTurnView::Property::VIEW_PAGE_SIZE).Get<Vector2>(), newSize * 1.5f, TEST_LOCATION);
 365   Wait(application);
 366   DALI_TEST_EQUALS(Vector2(landscapeView.GetTargetSize()), Vector2(newSize.x * 3.f, newSize.y * 1.5f), TEST_LOCATION);
 367
 368   // Test "currentPageId" property
 369   DALI_TEST_CHECK(landscapeView.GetPropertyIndex("currentPageId") == PageTurnView::Property::CURRENT_PAGE_ID);
 370   DALI_TEST_EQUALS(landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), 0, TEST_LOCATION);
 371
 372   int pageId = static_cast<int>(TOTAL_PAGE_NUMBER) / 3;
 373   landscapeView.SetProperty(PageTurnView::Property::CURRENT_PAGE_ID, pageId);
 374   DALI_TEST_EQUALS(landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), pageId, TEST_LOCATION);
 375
 376   landscapeView.SetProperty(PageTurnView::Property::CURRENT_PAGE_ID, pageId * 2);
 377   DALI_TEST_EQUALS(landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), pageId * 2, TEST_LOCATION);
 378
 379   // Test "spinShadow" property
 380   DALI_TEST_CHECK(landscapeView.GetPropertyIndex("spineShadow") == PageTurnView::Property::SPINE_SHADOW);
 381   landscapeView.SetProperty(PageTurnView::Property::SPINE_SHADOW, SPINE_SHADOW_PARAMETER);
 382   DALI_TEST_EQUALS(landscapeView.GetProperty(PageTurnView::Property::SPINE_SHADOW).Get<Vector2>(), SPINE_SHADOW_PARAMETER, TEST_LOCATION);
 383
 384   landscapeView.SetProperty(PageTurnView::Property::SPINE_SHADOW, SPINE_SHADOW_PARAMETER * 0.75f);
 385   DALI_TEST_EQUALS(landscapeView.GetProperty(PageTurnView::Property::SPINE_SHADOW).Get<Vector2>(), SPINE_SHADOW_PARAMETER * 0.75f, TEST_LOCATION);
 386
 387   END_TEST;
 388 }
 389
 390 int UtcDaliPageTurnPortraitViewSignals(void)
 391 {
 392   ToolkitTestApplication application;
 393
 394   tet_infoline(" UtcDaliPageTurnPortraitViewSignals ");
 395
 396   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
 397
 398   TestPageFactory factory;
 399   Vector2         size         = application.GetScene().GetSize();
 400   PageTurnView    portraitView = PageTurnPortraitView::New(factory, size);
 401   portraitView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
 402   application.GetScene().Add(portraitView);
 403
 404   // Render and notify
 405   application.SendNotification();
 406   application.Render(RENDER_FRAME_INTERVAL);
 407
 408   // [0]: testing PageTurnStartedSignal;  [1]: testing PageTurnFinishedSignal
 409   // [2]: testing PagePanStartedSignal;   [3]: testing PagePanFinishedSignal
 410   bool         signalVerified[4] = {false, false, false, false};
 411   PageTurnView currentView;
 412   unsigned int pageIndex;
 413   bool         isTurningForwards;
 414
 415   PageSignalCallback callbackTurnStarted(signalVerified[0], currentView, pageIndex, isTurningForwards);
 416   portraitView.PageTurnStartedSignal().Connect(&callbackTurnStarted, &PageSignalCallback::PageTurnSignalCallback);
 417
 418   PageSignalCallback callbackTurnFinished(signalVerified[1], currentView, pageIndex, isTurningForwards);
 419   portraitView.PageTurnFinishedSignal().Connect(&callbackTurnFinished, &PageSignalCallback::PageTurnSignalCallback);
 420
 421   PageSignalCallback callbackPanStarted(signalVerified[2], currentView, pageIndex, isTurningForwards);
 422   portraitView.PagePanStartedSignal().Connect(&callbackPanStarted, &PageSignalCallback::PagePanSignalCallback);
 423
 424   PageSignalCallback callbackPanFinished(signalVerified[3], currentView, pageIndex, isTurningForwards);
 425   portraitView.PagePanFinishedSignal().Connect(&callbackPanFinished, &PageSignalCallback::PagePanSignalCallback);
 426
 427   DALI_TEST_CHECK(!callbackTurnStarted.mSignalVerified);
 428   DALI_TEST_CHECK(!callbackTurnFinished.mSignalVerified);
 429   DALI_TEST_CHECK(!callbackPanStarted.mSignalVerified);
 430   DALI_TEST_CHECK(!callbackPanFinished.mSignalVerified);
 431
 432   currentView = portraitView;
 433
 434   //-----Test 1: pan 10 frames from position(size * 0.75f) to position(size * 0.25f), page 0 will be turned forward----
 435   pageIndex         = 0;
 436   isTurningForwards = true;
 437   // Do a pan moving up diagonally
 438   uint32_t time      = 0;
 439   Vector2  start     = size * 0.75f;
 440   Vector2  direction = -size * 0.05f; //-size*0.5f/10.f;
 441
 442   DALI_TEST_EQUALS(portraitView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), 0, TEST_LOCATION);
 443   PerformGestureDiagonalSwipe(application, start, direction, 5, time, true, false);
 444   DALI_TEST_CHECK(callbackTurnStarted.mSignalVerified);
 445   DALI_TEST_CHECK(!callbackTurnFinished.mSignalVerified);
 446   DALI_TEST_CHECK(callbackPanStarted.mSignalVerified);
 447   DALI_TEST_CHECK(!callbackPanFinished.mSignalVerified);
 448
 449   PerformGestureDiagonalSwipe(application, start + direction * 5.f, direction, 5, time, false, true);
 450   DALI_TEST_CHECK(!callbackTurnFinished.mSignalVerified);
 451   DALI_TEST_CHECK(callbackPanFinished.mSignalVerified);
 452
 453   time += Wait(application, 1000);
 454   DALI_TEST_CHECK(callbackTurnFinished.mSignalVerified);
 455   // the page is turned over
 456   DALI_TEST_EQUALS(portraitView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), (int)(pageIndex + 1), TEST_LOCATION);
 457
 458   //---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---
 459   callbackTurnStarted.Reset();
 460   callbackTurnFinished.Reset();
 461   callbackPanStarted.Reset();
 462   callbackPanFinished.Reset();
 463   portraitView.SetProperty(PageTurnView::Property::CURRENT_PAGE_ID, 5);
 464   pageIndex         = 5;
 465   isTurningForwards = true;
 466
 467   //pan 10 frames from position( size.width, size.height*0.5f ) to position( size * 0.75f )
 468   start     = Vector2(size.width, size.height * 0.5f);
 469   direction = Vector2(-size.width * 0.025f, size.height * 0.025f);
 470   PerformGestureDiagonalSwipe(application, start, direction, 5, time, true, false);
 471   DALI_TEST_CHECK(callbackPanStarted.mSignalVerified);
 472   DALI_TEST_CHECK(callbackTurnStarted.mSignalVerified);
 473   DALI_TEST_CHECK(!callbackTurnFinished.mSignalVerified);
 474   DALI_TEST_CHECK(!callbackPanFinished.mSignalVerified);
 475
 476   signalVerified[0] = false;
 477   isTurningForwards = false;
 478   PerformGestureDiagonalSwipe(application, start + direction * 2, direction, 5, time, false, true);
 479   DALI_TEST_CHECK(!callbackTurnFinished.mSignalVerified);
 480   DALI_TEST_CHECK(callbackPanFinished.mSignalVerified);
 481   DALI_TEST_CHECK(callbackTurnStarted.mSignalVerified); // start the sliding back
 482
 483   time += Wait(application, 1000);
 484   DALI_TEST_CHECK(callbackTurnFinished.mSignalVerified);
 485   DALI_TEST_EQUALS(portraitView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), (int)pageIndex, TEST_LOCATION); // the page is not turned over
 486
 487   // ----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---
 488   callbackTurnStarted.Reset();
 489   callbackTurnFinished.Reset();
 490   callbackPanStarted.Reset();
 491   callbackPanFinished.Reset();
 492   portraitView.SetProperty(PageTurnView::Property::CURRENT_PAGE_ID, 10);
 493   pageIndex         = 9; // will turn the previous page back
 494   isTurningForwards = false;
 495   start             = size * 0.25f;
 496   direction         = Vector2(size.x * 0.05f, 0.f);
 497   PerformGestureDiagonalSwipe(application, start, direction, 4, time, true, false);
 498   DALI_TEST_CHECK(callbackPanStarted.mSignalVerified);
 499   DALI_TEST_CHECK(!callbackTurnStarted.mSignalVerified);
 500   DALI_TEST_CHECK(!callbackTurnFinished.mSignalVerified);
 501   DALI_TEST_CHECK(!callbackPanFinished.mSignalVerified);
 502
 503   PerformGestureDiagonalSwipe(application, start + direction * 5.f, direction, 5, time, false, true);
 504   DALI_TEST_CHECK(callbackTurnStarted.mSignalVerified);
 505   DALI_TEST_CHECK(callbackPanFinished.mSignalVerified);
 506   DALI_TEST_CHECK(!callbackTurnFinished.mSignalVerified);
 507
 508   Wait(application, 1000);
 509
 510   DALI_TEST_CHECK(callbackTurnFinished.mSignalVerified);
 511   DALI_TEST_EQUALS(portraitView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), 9, TEST_LOCATION);
 512   END_TEST;
 513 }
 514
 515 int UtcDaliPageTurnLanscapeViewSignals(void)
 516 {
 517   ToolkitTestApplication application;
 518
 519   tet_infoline(" UtcDaliPageTurnLanscapeViewSignals ");
 520
 521   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
 522   /***
 523    * -----------------
 524    * |               |
 525    * |---------------|
 526    * |bookboo|bookboo|
 527    * |kbookbo|kbookbo|
 528    * |okbookb|okbookb|
 529    * |ookbook|ookbook|
 530    * |bookboo|bookboo|
 531    * |---------------|
 532    * |               |
 533    * ----------------
 534    */
 535
 536   TestPageFactory factory;
 537   Vector2         stageSize     = application.GetScene().GetSize();
 538   PageTurnView    landscapeView = PageTurnLandscapeView::New(factory, Vector2(stageSize.x * 0.5f, stageSize.x * 0.8f));
 539   landscapeView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
 540   application.GetScene().Add(landscapeView);
 541
 542   // Render and notify
 543   application.SendNotification();
 544   application.Render(RENDER_FRAME_INTERVAL);
 545
 546   // [0]: testing PageTurnStartedSignal;  [1]: testing PageTurnFinishedSignal
 547   // [2]: testing PagePanStartedSignal;   [3]: testing PagePanFinishedSignal
 548   bool         signalVerified[4] = {false, false, false, false};
 549   PageTurnView currentView;
 550   unsigned int pageIndex;
 551   bool         isTurningForwards;
 552
 553   PageSignalCallback callbackTurnStarted(signalVerified[0], currentView, pageIndex, isTurningForwards);
 554   landscapeView.PageTurnStartedSignal().Connect(&callbackTurnStarted, &PageSignalCallback::PageTurnSignalCallback);
 555
 556   PageSignalCallback callbackTurnFinished(signalVerified[1], currentView, pageIndex, isTurningForwards);
 557   landscapeView.PageTurnFinishedSignal().Connect(&callbackTurnFinished, &PageSignalCallback::PageTurnSignalCallback);
 558
 559   PageSignalCallback callbackPanStarted(signalVerified[2], currentView, pageIndex, isTurningForwards);
 560   landscapeView.PagePanStartedSignal().Connect(&callbackPanStarted, &PageSignalCallback::PagePanSignalCallback);
 561
 562   PageSignalCallback callbackPanFinished(signalVerified[3], currentView, pageIndex, isTurningForwards);
 563   landscapeView.PagePanFinishedSignal().Connect(&callbackPanFinished, &PageSignalCallback::PagePanSignalCallback);
 564
 565   DALI_TEST_CHECK(!callbackTurnStarted.mSignalVerified);
 566   DALI_TEST_CHECK(!callbackTurnFinished.mSignalVerified);
 567   DALI_TEST_CHECK(!callbackPanStarted.mSignalVerified);
 568   DALI_TEST_CHECK(!callbackPanFinished.mSignalVerified);
 569
 570   currentView = landscapeView;
 571
 572   //-----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----
 573   pageIndex         = 0;
 574   isTurningForwards = true;
 575   // Do a pan to the left.
 576   uint32_t time      = 0;
 577   Vector2  start     = Vector2(stageSize.x * 0.85f, stageSize.y * 0.5);
 578   Vector2  direction = Vector2(-stageSize.x * 0.04f, -stageSize.x * 0.03f);
 579
 580   DALI_TEST_EQUALS(landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), 0, TEST_LOCATION);
 581   PerformGestureDiagonalSwipe(application, start, direction, 5, time, true, false);
 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   PerformGestureDiagonalSwipe(application, start + direction * 5.f, direction, 5, time, false, true);
 588   DALI_TEST_CHECK(!callbackTurnFinished.mSignalVerified);
 589   DALI_TEST_CHECK(callbackPanFinished.mSignalVerified);
 590
 591   time += Wait(application, 1000);
 592   DALI_TEST_CHECK(callbackTurnFinished.mSignalVerified);
 593   // the page is turned over
 594   DALI_TEST_EQUALS(landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), (int)(pageIndex + 1), TEST_LOCATION);
 595
 596   //---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---
 597   callbackTurnStarted.Reset();
 598   callbackTurnFinished.Reset();
 599   callbackPanStarted.Reset();
 600   callbackPanFinished.Reset();
 601   isTurningForwards = false;
 602
 603   //pan 10 frames from position( size.width, size.height*0.5f ) to position( size * 0.75f )
 604   start     = Vector2(stageSize.x * 0.15f, stageSize.y * 0.5f);
 605   direction = Vector2(stageSize.x * 0.03f, 0.f);
 606   PerformGestureDiagonalSwipe(application, start, direction, 5, time, true, false);
 607   DALI_TEST_CHECK(callbackPanStarted.mSignalVerified);
 608   DALI_TEST_CHECK(callbackTurnStarted.mSignalVerified);
 609   DALI_TEST_CHECK(!callbackTurnFinished.mSignalVerified);
 610   DALI_TEST_CHECK(!callbackPanFinished.mSignalVerified);
 611
 612   PerformGestureDiagonalSwipe(application, start + direction * 5.f, direction, 5, time, false, true);
 613   DALI_TEST_CHECK(!callbackTurnFinished.mSignalVerified);
 614   DALI_TEST_CHECK(callbackPanFinished.mSignalVerified);
 615
 616   time += Wait(application, 1000);
 617   DALI_TEST_CHECK(callbackTurnFinished.mSignalVerified);
 618   DALI_TEST_EQUALS(landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), 0, TEST_LOCATION); // the first page is turned back
 619
 620   // ----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---
 621   callbackTurnStarted.Reset();
 622   callbackTurnFinished.Reset();
 623   callbackPanStarted.Reset();
 624   callbackPanFinished.Reset();
 625   isTurningForwards = false;
 626   start             = stageSize * 0.55f;
 627   direction         = Vector2(stageSize.x * 0.025f, 0.f);
 628   PerformGestureDiagonalSwipe(application, start, direction, 5, time, true, false);
 629   DALI_TEST_CHECK(callbackPanStarted.mSignalVerified);
 630   DALI_TEST_CHECK(!callbackTurnStarted.mSignalVerified);
 631   DALI_TEST_CHECK(!callbackTurnFinished.mSignalVerified);
 632   DALI_TEST_CHECK(!callbackPanFinished.mSignalVerified);
 633
 634   PerformGestureDiagonalSwipe(application, start + direction * 5.f, direction, 5, time, false, true);
 635   DALI_TEST_CHECK(!callbackTurnStarted.mSignalVerified);
 636   DALI_TEST_CHECK(callbackPanFinished.mSignalVerified);
 637   DALI_TEST_CHECK(!callbackTurnFinished.mSignalVerified);
 638
 639   Wait(application, 1000);
 640
 641   DALI_TEST_CHECK(!callbackTurnFinished.mSignalVerified);
 642   DALI_TEST_EQUALS(landscapeView.GetProperty(PageTurnView::Property::CURRENT_PAGE_ID).Get<int>(), 0, TEST_LOCATION);
 643   END_TEST;
 644 }
 645
 646 int UtcDaliPageImageFactoryGetExtention(void)
 647 {
 648   ToolkitTestApplication application;
 649   TestPageFactory        factory;
 650   DALI_TEST_CHECK(factory.GetExtension() == NULL);
 651   END_TEST;
 652 }
 653
 654 int UtcDaliPageTurnEmptyTextureHandle(void)
 655 {
 656   ToolkitTestApplication application;
 657
 658   tet_infoline(" UtcDaliPageTurnEmptyTextureHandle ");
 659
 660   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
 661
 662   TestPageFactory factory(false /* returns empty handles */);
 663   Vector2         size = application.GetScene().GetSize();
 664   try
 665   {
 666     PageTurnView portraitView = PageTurnPortraitView::New(factory, size);
 667     portraitView.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
 668     application.GetScene().Add(portraitView);
 669
 670     tet_result(TET_FAIL);
 671   }
 672   catch(DaliException& e)
 673   {
 674     DALI_TEST_ASSERT(e, "must pass in valid texture", TEST_LOCATION);
 675   }
 676   catch(...)
 677   {
 678     tet_result(TET_FAIL);
 679   }
 680
 681   END_TEST;
 682 }