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

   1 /*
   2  * Copyright (c) 2020 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 <dali-toolkit-test-suite-utils.h>
  21 #include <dali-toolkit/dali-toolkit.h>
  22 #include <dali-toolkit/public-api/controls/video-view/video-view.h>
  23 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
  24 #include <dali/devel-api/adaptor-framework/video-sync-mode.h>
  25
  26 using namespace Dali;
  27 using namespace Dali::Toolkit;
  28
  29 namespace
  30 {
  31 const char* const TEST_FILE( "test.mp4" );
  32 const char* const VOLUME_LEFT( "volumeLeft" );
  33 const char* const VOLUME_RIGHT( "volumeRight" );
  34 const char* const RENDERING_TYPE( "renderingTarget" );
  35 const char* const DUMMY_STRING( "dummy string" );
  36
  37 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
  38   attribute mediump vec2 aPosition;\n
  39   varying mediump vec2 vTexCoord;\n
  40   uniform mediump mat4 uMvpMatrix;\n
  41   uniform mediump vec3 uSize;\n
  42   \n
  43   void main()\n
  44   {\n
  45     mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
  46     vertexPosition.xyz *= uSize;\n
  47     vertexPosition = uMvpMatrix * vertexPosition;\n
  48     \n
  49     vTexCoord = aPosition + vec2(0.5);\n
  50     gl_Position = vertexPosition;\n
  51   }\n
  52 );
  53
  54 const char* fragmentShaderPrefix( "#extension GL_OES_EGL_image_external:require\n" );
  55 const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
  56   varying mediump vec2 vTexCoord;\n
  57   uniform samplerExternalOES sTexture;\n
  58   uniform lowp vec4 uColor;\n
  59   \n
  60   void main()\n
  61   {\n
  62     gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
  63   }\n
  64 );
  65
  66 }
  67
  68 void video_view_startup(void)
  69 {
  70   test_return_value = TET_UNDEF;
  71 }
  72
  73 void video_view_cleanup(void)
  74 {
  75   test_return_value = TET_PASS;
  76 }
  77
  78 // Negative test case for a method
  79 int UtcDaliVideoViewUninitialized(void)
  80 {
  81   ToolkitTestApplication application;
  82   tet_infoline(" UtcDaliVideoViewUninitialized");
  83
  84   Toolkit::VideoView view;
  85
  86   try
  87   {
  88     // New() must be called to create a VideoView or it wont be valid.
  89     Actor a = Actor::New();
  90     view.Add( a );
  91     DALI_TEST_CHECK( false );
  92   }
  93   catch (Dali::DaliException& e)
  94   {
  95     // Tests that a negative test of an assertion succeeds
  96     DALI_TEST_PRINT_ASSERT( e );
  97     DALI_TEST_CHECK(!view);
  98   }
  99   END_TEST;
 100 }
 101
 102 // Positive test case for a method
 103 int UtcDaliVideoViewNew(void)
 104 {
 105   ToolkitTestApplication application;
 106   tet_infoline(" UtcDaliVideoViewNew");
 107
 108   Toolkit::VideoView view = Toolkit::VideoView::New();
 109   DALI_TEST_CHECK( view );
 110
 111   const std::string url( DUMMY_STRING );
 112   Toolkit::VideoView view2 = Toolkit::VideoView::New( url );
 113   DALI_TEST_CHECK( view2 );
 114   END_TEST;
 115 }
 116
 117 // Positive test case for a method
 118 int UtcDaliVideoViewDownCast(void)
 119 {
 120   ToolkitTestApplication application;
 121   tet_infoline(" UtcDaliVideoViewDownCast");
 122
 123   Toolkit::VideoView view = Toolkit::VideoView::New();
 124   BaseHandle handle(view);
 125
 126   Toolkit::VideoView view2 = Toolkit::VideoView::DownCast( handle );
 127   DALI_TEST_CHECK( view );
 128   DALI_TEST_CHECK( view2 );
 129   DALI_TEST_CHECK( view == view2 );
 130   END_TEST;
 131 }
 132
 133 // Positive test case for a method
 134 int UtcDaliVideoViewProperty1(void)
 135 {
 136   ToolkitTestApplication application;
 137   tet_infoline(" UtcDaliVideoViewProperty1");
 138
 139   Toolkit::VideoView view = Toolkit::VideoView::New();
 140   DALI_TEST_CHECK( view );
 141
 142   std::string file;
 143   view.SetProperty( VideoView::Property::VIDEO, TEST_FILE );
 144   Property::Value val = view.GetProperty( VideoView::Property::VIDEO );
 145   DALI_TEST_CHECK( val.Get( file ) );
 146   DALI_TEST_CHECK( file == TEST_FILE );
 147   END_TEST;
 148 }
 149
 150 // Positive test case for a method
 151 int UtcDaliVideoViewProperty1b(void)
 152 {
 153   ToolkitTestApplication application;
 154   tet_infoline(" UtcDaliVideoViewProperty1");
 155
 156   Toolkit::VideoView view = Toolkit::VideoView::New();
 157   DALI_TEST_CHECK( view );
 158   Integration::Scene stage = application.GetScene();
 159
 160   std::string file;
 161   Property::Map map;
 162
 163   view.SetProperty( VideoView::Property::VIDEO, Property::Map()
 164                     .Add("rendererType", "IMAGE")
 165                     .Add("url", "video.mpg") // Note, videoView doesn't use this url
 166                     .Add("RENDERING_TARGET", "windowSurfaceTarget" )
 167                     .Add("width", 100)
 168                     .Add("height", 100) );
 169
 170   stage.Add( view );
 171
 172   Property::Value val = view.GetProperty( VideoView::Property::VIDEO );
 173   Property::Map* resultMap = val.GetMap();
 174
 175   DALI_TEST_CHECK( resultMap );
 176   Property::Value* value = resultMap->Find("url");
 177   DALI_TEST_CHECK( value );
 178   DALI_TEST_EQUALS( value->Get<std::string>(), "video.mpg", TEST_LOCATION );
 179
 180   stage.Remove( view );
 181
 182   END_TEST;
 183 }
 184
 185 int UtcDaliVideoViewProperty2(void)
 186 {
 187   ToolkitTestApplication application;
 188   tet_infoline(" UtcDaliVideoViewProperty2");
 189
 190   Toolkit::VideoView view = Toolkit::VideoView::New();
 191   DALI_TEST_CHECK( view );
 192
 193   bool looping;
 194   Property::Value val = view.GetProperty( VideoView::Property::LOOPING );
 195   DALI_TEST_CHECK( val.Get( looping ) );
 196   DALI_TEST_CHECK( !looping );
 197
 198   view.SetProperty( VideoView::Property::LOOPING, true );
 199   val = view.GetProperty( VideoView::Property::LOOPING );
 200   DALI_TEST_CHECK( val.Get( looping ) );
 201   DALI_TEST_CHECK( looping );
 202   END_TEST;
 203 }
 204
 205 int UtcDaliVideoViewProperty3(void)
 206 {
 207   ToolkitTestApplication application;
 208   tet_infoline(" UtcDaliVideoViewProperty3");
 209
 210   Toolkit::VideoView view = Toolkit::VideoView::New();
 211   DALI_TEST_CHECK( view );
 212
 213   bool muted;
 214   Property::Value val = view.GetProperty( VideoView::Property::MUTED );
 215   DALI_TEST_CHECK( val.Get( muted ) );
 216   DALI_TEST_CHECK( !muted );
 217
 218   view.SetProperty( VideoView::Property::MUTED, true );
 219   val = view.GetProperty( VideoView::Property::MUTED );
 220   DALI_TEST_CHECK( val.Get( muted ) );
 221   DALI_TEST_CHECK( muted );
 222
 223   END_TEST;
 224 }
 225
 226 int UtcDaliVideoViewProperty4(void)
 227 {
 228   ToolkitTestApplication application;
 229   tet_infoline(" UtcDaliVideoViewProperty4");
 230
 231   Toolkit::VideoView view = Toolkit::VideoView::New();
 232   DALI_TEST_CHECK( view );
 233
 234   float left, right;
 235   left = right = 0.f;
 236
 237   Property::Map map;
 238   map.Insert( VOLUME_LEFT, 0.5f );
 239   map.Insert( VOLUME_RIGHT, 0.5f );
 240
 241   view.SetProperty( VideoView::Property::VOLUME, map );
 242   Property::Value val = view.GetProperty( VideoView::Property::VOLUME );
 243
 244   Property::Map map2;
 245   DALI_TEST_CHECK( val.Get( map2 ) );
 246
 247   Property::Value* volumeLeft = map2.Find( VOLUME_LEFT );
 248   Property::Value* volumeRight = map2.Find( VOLUME_RIGHT );
 249
 250   DALI_TEST_CHECK( volumeLeft && volumeLeft->Get( left ) );
 251   DALI_TEST_CHECK( volumeRight && volumeRight->Get( right ) );
 252   DALI_TEST_CHECK( left == 0.5f );
 253   DALI_TEST_CHECK( right == 0.5f );
 254
 255   END_TEST;
 256 }
 257
 258 int UtcDaliVideoViewCopyAndAssignment(void)
 259 {
 260   ToolkitTestApplication application;
 261
 262   VideoView view = Toolkit::VideoView::New();
 263   DALI_TEST_CHECK( view );
 264
 265   VideoView copy( view );
 266   DALI_TEST_CHECK( view == copy );
 267
 268   VideoView assign;
 269   DALI_TEST_CHECK( !assign );
 270
 271   assign = copy;
 272   DALI_TEST_CHECK( assign == view );
 273
 274   END_TEST;
 275 }
 276
 277 int UtcDaliVideoViewTypeRegistry(void)
 278 {
 279   ToolkitTestApplication application;
 280
 281   TypeRegistry typeRegistry = TypeRegistry::Get();
 282   DALI_TEST_CHECK( typeRegistry );
 283
 284   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "VideoView" );
 285   DALI_TEST_CHECK( typeInfo );
 286
 287   BaseHandle handle = typeInfo.CreateInstance();
 288   DALI_TEST_CHECK( handle );
 289
 290   VideoView view = VideoView::DownCast( handle );
 291   DALI_TEST_CHECK( view );
 292
 293   END_TEST;
 294 }
 295
 296 int UtcDaliVideoViewMethodsForCoverage(void)
 297 {
 298   ToolkitTestApplication application;
 299
 300   VideoView videoView = VideoView::New();
 301   DALI_TEST_CHECK( videoView );
 302
 303   videoView.Play();
 304   videoView.Pause();
 305   videoView.Stop();
 306   videoView.Forward(10);
 307   videoView.Backward(10);
 308
 309   Toolkit::DevelVideoView::GetMediaPlayer( videoView );
 310
 311   VideoView::VideoViewSignalType& signal = videoView.FinishedSignal();
 312   DALI_TEST_EQUALS( 0, signal.GetConnectionCount(), TEST_LOCATION );
 313
 314   END_TEST;
 315 }
 316
 317 int UtcDaliVideoViewMethodsForRenderType(void)
 318 {
 319   ToolkitTestApplication application;
 320   VideoView videoView = VideoView::New();
 321   DALI_TEST_CHECK( videoView );
 322
 323   Property::Map windowSurfaceTarget;
 324   Property::Map nativeImageTarget;
 325
 326   windowSurfaceTarget.Insert( RENDERING_TYPE, "windowSurfaceTarget" );
 327   nativeImageTarget.Insert( RENDERING_TYPE, "nativeImageTarget" );
 328
 329   Property::Map map;
 330   Property::Value value;
 331   videoView.SetProperty( VideoView::Property::VIDEO, windowSurfaceTarget );
 332
 333   value = videoView.GetProperty( VideoView::Property::VIDEO );
 334   DALI_TEST_CHECK( value.Get( map ) );
 335
 336   Property::Value* type = map.Find( RENDERING_TYPE );
 337   DALI_TEST_CHECK( type );
 338   DALI_TEST_EQUALS( "windowSurfaceTarget", type->Get<std::string>(), TEST_LOCATION );
 339
 340   videoView.SetProperty( VideoView::Property::VIDEO, nativeImageTarget );
 341
 342   value = videoView.GetProperty( VideoView::Property::VIDEO );
 343   DALI_TEST_CHECK( value.Get( map ) );
 344   type = map.Find( RENDERING_TYPE );
 345
 346   DALI_TEST_CHECK( type );
 347   DALI_TEST_EQUALS( "nativeImageTarget", type->Get<std::string>(), TEST_LOCATION );
 348
 349   END_TEST;
 350 }
 351
 352 int UtcDaliVideoViewCustomShaderForCoverage(void)
 353 {
 354   ToolkitTestApplication application;
 355   VideoView videoView = VideoView::New();
 356   DALI_TEST_CHECK( videoView );
 357
 358   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 359
 360   videoView.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 361   bool isUnderlay = videoView.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 362   DALI_TEST_CHECK( !isUnderlay );
 363
 364   application.GetScene().Add( videoView );
 365   videoView.SetProperty( VideoView::Property::VIDEO, "testvideo" );
 366
 367   Property::Map customShader;
 368   customShader.Insert( "vertexShader", VERTEX_SHADER );
 369   customShader.Insert( "fragmentShader", FRAGMENT_SHADER );
 370
 371   Property::Map map;
 372   map.Insert( "shader", customShader );
 373
 374   videoView.SetProperty( VideoView::Property::VIDEO, map );
 375
 376   Property::Map map2;
 377   Property::Value value = videoView.GetProperty( VideoView::Property::VIDEO );
 378
 379   DALI_TEST_CHECK( !value.Get( map2 ) );
 380   END_TEST;
 381 }
 382
 383 int UtcDaliVideoViewMethodsForCoverage2(void)
 384 {
 385   ToolkitTestApplication application;
 386   VideoView videoView = VideoView::New();
 387   DALI_TEST_CHECK( videoView );
 388
 389   Property::Map windowSurfaceTarget;
 390
 391   windowSurfaceTarget.Insert( RENDERING_TYPE, "windowSurfaceTarget" );
 392
 393   application.GetScene().Add( videoView );
 394
 395   application.SendNotification();
 396   application.Render();
 397
 398   Property::Map map;
 399   Property::Value value;
 400   videoView.SetProperty( VideoView::Property::VIDEO, windowSurfaceTarget );
 401
 402   value = videoView.GetProperty( VideoView::Property::VIDEO );
 403   DALI_TEST_CHECK( value.Get( map ) );
 404
 405   Property::Value* type = map.Find( RENDERING_TYPE );
 406   DALI_TEST_CHECK( type );
 407   DALI_TEST_EQUALS( "windowSurfaceTarget", type->Get<std::string>(), TEST_LOCATION );
 408
 409   Vector3 vector(100.0f, 100.0f, 0.0f);
 410
 411   DALI_TEST_CHECK(vector != videoView.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 412   videoView.SetProperty( Actor::Property::SIZE, vector );
 413
 414   application.SendNotification();
 415   application.Render();
 416
 417   // Check the size in the new frame
 418   DALI_TEST_CHECK(vector == videoView.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 419
 420   END_TEST;
 421 }
 422
 423 int UtcDaliVideoViewPropertyUnderlay(void)
 424 {
 425   ToolkitTestApplication application;
 426   tet_infoline("UtcDaliVideoViewPropertyUnderlay");
 427   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 428
 429   VideoView view = VideoView::New();
 430   DALI_TEST_CHECK( view );
 431
 432   application.GetScene().Add( view );
 433   view.Play();
 434
 435   application.SendNotification();
 436   application.Render();
 437
 438   bool isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 439   DALI_TEST_CHECK( isUnderlay );
 440
 441   view.Play();
 442   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 443   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 444   DALI_TEST_CHECK( !isUnderlay );
 445
 446   view.Play();
 447   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, true );
 448   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 449   DALI_TEST_CHECK( isUnderlay );
 450
 451   // If platform api doesn't provide any API or feature for decoded images of video,
 452   // UNDERLAY should be true
 453   ToolkitApplication::DECODED_IMAGES_SUPPORTED = false;
 454
 455   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 456   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 457   DALI_TEST_CHECK( isUnderlay );
 458
 459   // For coverage
 460   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 461
 462   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, true );
 463   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 464   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 465   DALI_TEST_CHECK( !isUnderlay );
 466
 467   view.Stop();
 468
 469   END_TEST;
 470 }
 471
 472 int UtcDaliVideoViewPropertyPlayPosition(void)
 473 {
 474   ToolkitTestApplication application;
 475   tet_infoline("UtcDaliVideoViewPropertyPlayPosition");
 476
 477   VideoView view = VideoView::New();
 478   DALI_TEST_CHECK( view );
 479
 480   application.GetScene().Add( view );
 481   view.Play();
 482
 483   application.SendNotification();
 484   application.Render();
 485
 486   int playPos = view.GetProperty( Toolkit::VideoView::Property::PLAY_POSITION ).Get< int >();
 487   DALI_TEST_CHECK( playPos == 0 );
 488
 489   view.SetProperty( Toolkit::VideoView::Property::PLAY_POSITION, 10 );
 490   playPos = view.GetProperty( Toolkit::VideoView::Property::PLAY_POSITION ).Get< int >();
 491   // Actually setting play position will be async
 492   // Actual platform result may be different.
 493   DALI_TEST_CHECK( playPos == 10 );
 494
 495   END_TEST;
 496 }
 497
 498 // For coverage.
 499 int UtcDaliVideoViewNew2(void)
 500 {
 501   ToolkitTestApplication application;
 502   tet_infoline("UtcDaliVideoViewNew2");
 503
 504   VideoView view = VideoView::New( true );
 505   DALI_TEST_CHECK( view );
 506
 507   application.GetScene().Add( view );
 508   view.Play();
 509
 510   application.SendNotification();
 511   application.Render();
 512
 513   VideoView view2 = VideoView::New( "", false );
 514   DALI_TEST_CHECK( view2 );
 515
 516   application.GetScene().Add( view2 );
 517   view2.Play();
 518
 519   application.SendNotification();
 520   application.Render();
 521
 522   END_TEST;
 523 }
 524
 525 int UtcDaliVideoViewPropertyDisplayMode(void)
 526 {
 527   ToolkitTestApplication application;
 528   tet_infoline("UtcDaliVideoViewPropertyDisplayMode");
 529
 530   VideoView view = VideoView::New();
 531   DALI_TEST_CHECK( view );
 532
 533   application.GetScene().Add( view );
 534   view.Play();
 535
 536   application.SendNotification();
 537   application.Render();
 538
 539   view.SetProperty( Toolkit::VideoView::Property::DISPLAY_MODE, Toolkit::VideoView::DisplayMode::DST_ROI );
 540   int displayMode = view.GetProperty( Toolkit::VideoView::Property::DISPLAY_MODE ).Get< int >();
 541   DALI_TEST_CHECK( displayMode == Toolkit::VideoView::DisplayMode::DST_ROI );
 542
 543   END_TEST;
 544 }
 545
 546
 547 int UtcDaliVideoViewCustomShader(void)
 548 {
 549   ToolkitTestApplication application;
 550   tet_infoline( "VideoView with custom shader" );
 551
 552   VideoView view = VideoView::New( false );
 553   DALI_TEST_CHECK( view );
 554
 555   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 556
 557   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 558   bool isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 559   DALI_TEST_CHECK( !isUnderlay );
 560
 561   application.GetScene().Add( view );
 562   view.SetProperty( VideoView::Property::VIDEO, "testvideo" );
 563
 564   /* insert custom shader */
 565   Property::Map customShader;
 566   std::string fragmentShaderString;
 567   fragmentShaderString.reserve( strlen( fragmentShaderPrefix ) + strlen( FRAGMENT_SHADER ) );
 568   fragmentShaderString.append( fragmentShaderPrefix );
 569   fragmentShaderString.append( FRAGMENT_SHADER );
 570   customShader.Insert( "vertexShader", VERTEX_SHADER );
 571   customShader.Insert( "fragmentShader", fragmentShaderString );
 572
 573   Property::Map map;
 574   map.Insert( "shader", customShader );
 575
 576   view.SetProperty( VideoView::Property::VIDEO, map );
 577
 578   /* do render for check custom shader */
 579   application.GetScene().Add( view );
 580   view.Play();
 581
 582   application.SendNotification();
 583   application.Render();
 584
 585   /* get renderer */
 586   DALI_TEST_CHECK( view.GetRendererCount() == 1u );
 587   Renderer renderer = view.GetRendererAt( 0 );
 588   Shader shader = renderer.GetShader();
 589   DALI_TEST_CHECK( shader );
 590
 591   Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
 592   Property::Map* shaderMap = value.GetMap();
 593   DALI_TEST_CHECK( shaderMap );
 594
 595   Property::Value* fragment = shaderMap->Find( "fragment" ); // fragment key name from shader-impl.cpp
 596   DALI_TEST_EQUALS( fragmentShaderString, fragment->Get<std::string>(), TEST_LOCATION );
 597
 598   Property::Value* vertex = shaderMap->Find( "vertex" ); // vertex key name from shader-impl.cpp
 599   DALI_TEST_EQUALS( VERTEX_SHADER, vertex->Get<std::string>(), TEST_LOCATION );
 600
 601   END_TEST;
 602 }
 603
 604 // Functor to test whether a Finish signal is emitted
 605 struct AnimationFinishCheck
 606 {
 607   AnimationFinishCheck(bool& signalReceived)
 608   : mSignalReceived(signalReceived)
 609   {
 610   }
 611
 612   void operator()(Animation& animation)
 613   {
 614     mSignalReceived = true;
 615   }
 616
 617   void Reset()
 618   {
 619     mSignalReceived = false;
 620   }
 621
 622   void CheckSignalReceived()
 623   {
 624     if (!mSignalReceived)
 625     {
 626       tet_printf("Expected Finish signal was not received\n");
 627       tet_result(TET_FAIL);
 628     }
 629     else
 630     {
 631       tet_result(TET_PASS);
 632     }
 633   }
 634
 635   void CheckSignalNotReceived()
 636   {
 637     if (mSignalReceived)
 638     {
 639       tet_printf("Unexpected Finish signal was received\n");
 640       tet_result(TET_FAIL);
 641     }
 642     else
 643     {
 644       tet_result(TET_PASS);
 645     }
 646   }
 647
 648   bool& mSignalReceived; // owned by individual tests
 649 };
 650
 651 int UtcDaliVideoViewSyncAniamtionForCoverage(void)
 652 {
 653   ToolkitTestApplication application;
 654
 655   VideoView videoView = DevelVideoView::New( Dali::VideoSyncMode::ENABLED );
 656   DALI_TEST_CHECK( videoView );
 657
 658   // Build the animation
 659   float durationSeconds(1.0f);
 660   Animation animation = Animation::New(durationSeconds);
 661
 662   // Start the animation
 663   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 664   animation.AnimateTo(Property(videoView, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 665   DevelVideoView::PlayAnimation( videoView, animation );
 666
 667   bool signalReceived(false);
 668   AnimationFinishCheck finishCheck(signalReceived);
 669   animation.FinishedSignal().Connect(&application, finishCheck);
 670
 671   application.SendNotification();
 672   application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) - 1u/*just less than the animation duration*/);
 673
 674   // We didn't expect the animation to finish yet
 675   application.SendNotification();
 676   finishCheck.CheckSignalNotReceived();
 677
 678   application.Render(2u/*just beyond the animation duration*/);
 679
 680   // We did expect the animation to finish
 681   application.SendNotification();
 682   finishCheck.CheckSignalReceived();
 683   DALI_TEST_EQUALS( targetPosition, videoView.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
 684
 685   // Restart the animation, with a different duration
 686   finishCheck.Reset();
 687
 688   END_TEST;
 689 }
 690
 691 int UtcDaliVideoViewASyncAniamtionForCoverage(void)
 692 {
 693   ToolkitTestApplication application;
 694
 695   VideoView videoView = DevelVideoView::New( Dali::VideoSyncMode::DISABLED );
 696   DALI_TEST_CHECK( videoView );
 697
 698   // Build the animation
 699   float durationSeconds(1.0f);
 700   Animation animation = Animation::New(durationSeconds);
 701
 702   // Start the animation
 703   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 704   animation.AnimateTo(Property(videoView, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 705   DevelVideoView::PlayAnimation( videoView, animation );
 706
 707   bool signalReceived(false);
 708   AnimationFinishCheck finishCheck(signalReceived);
 709   animation.FinishedSignal().Connect(&application, finishCheck);
 710
 711   application.SendNotification();
 712   application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) - 1u/*just less than the animation duration*/);
 713
 714   // We didn't expect the animation to finish yet
 715   application.SendNotification();
 716   finishCheck.CheckSignalNotReceived();
 717
 718   application.Render(2u/*just beyond the animation duration*/);
 719
 720   // We did expect the animation to finish
 721   application.SendNotification();
 722   finishCheck.CheckSignalReceived();
 723   DALI_TEST_EQUALS( targetPosition, videoView.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
 724
 725   // Restart the animation, with a different duration
 726   finishCheck.Reset();
 727
 728   END_TEST;
 729 }
 730
 731 int UtcDaliVideoViewResizeWithSynchronization(void)
 732 {
 733   ToolkitTestApplication application;
 734   VideoView videoView = DevelVideoView::New( Dali::VideoSyncMode::ENABLED );
 735   DALI_TEST_CHECK( videoView );
 736
 737   application.GetScene().Add( videoView );
 738
 739   Vector3 vector(50.0f, 200.0f, 0.0f);
 740   videoView.SetProperty( Actor::Property::SIZE, vector );
 741
 742   application.SendNotification();
 743   application.Render();
 744
 745   DALI_TEST_CHECK(vector == videoView.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 746
 747   END_TEST;
 748 }