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 UtcDaliVideoViewMoveConstructor(void)
 278 {
 279   ToolkitTestApplication application;
 280
 281   VideoView view = Toolkit::VideoView::New();
 282   DALI_TEST_EQUALS( 1, view.GetBaseObject().ReferenceCount(), TEST_LOCATION );
 283   view.SetProperty( VideoView::Property::LOOPING, true );
 284   DALI_TEST_CHECK( view.GetProperty<bool>( VideoView::Property::LOOPING ) );
 285
 286   VideoView moved = std::move( view );
 287   DALI_TEST_CHECK( moved );
 288   DALI_TEST_EQUALS( 1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION );
 289   DALI_TEST_CHECK( moved.GetProperty<bool>( VideoView::Property::LOOPING ) );
 290   DALI_TEST_CHECK( !view );
 291
 292   END_TEST;
 293 }
 294
 295 int UtcDaliVideoViewMoveAssignment(void)
 296 {
 297   ToolkitTestApplication application;
 298
 299   VideoView view = Toolkit::VideoView::New();
 300   DALI_TEST_EQUALS( 1, view.GetBaseObject().ReferenceCount(), TEST_LOCATION );
 301   view.SetProperty( VideoView::Property::LOOPING, true );
 302   DALI_TEST_CHECK( view.GetProperty<bool>( VideoView::Property::LOOPING ) );
 303
 304   VideoView moved;
 305   moved = std::move( view );
 306   DALI_TEST_CHECK( moved );
 307   DALI_TEST_EQUALS( 1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION );
 308   DALI_TEST_CHECK( moved.GetProperty<bool>( VideoView::Property::LOOPING ) );
 309   DALI_TEST_CHECK( !view );
 310
 311   END_TEST;
 312 }
 313
 314 int UtcDaliVideoViewTypeRegistry(void)
 315 {
 316   ToolkitTestApplication application;
 317
 318   TypeRegistry typeRegistry = TypeRegistry::Get();
 319   DALI_TEST_CHECK( typeRegistry );
 320
 321   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "VideoView" );
 322   DALI_TEST_CHECK( typeInfo );
 323
 324   BaseHandle handle = typeInfo.CreateInstance();
 325   DALI_TEST_CHECK( handle );
 326
 327   VideoView view = VideoView::DownCast( handle );
 328   DALI_TEST_CHECK( view );
 329
 330   END_TEST;
 331 }
 332
 333 int UtcDaliVideoViewMethodsForCoverage(void)
 334 {
 335   ToolkitTestApplication application;
 336
 337   VideoView videoView = VideoView::New();
 338   DALI_TEST_CHECK( videoView );
 339
 340   videoView.Play();
 341   videoView.Pause();
 342   videoView.Stop();
 343   videoView.Forward(10);
 344   videoView.Backward(10);
 345
 346   Toolkit::DevelVideoView::GetMediaPlayer( videoView );
 347
 348   VideoView::VideoViewSignalType& signal = videoView.FinishedSignal();
 349   DALI_TEST_EQUALS( 0, signal.GetConnectionCount(), TEST_LOCATION );
 350
 351   END_TEST;
 352 }
 353
 354 int UtcDaliVideoViewMethodsForRenderType(void)
 355 {
 356   ToolkitTestApplication application;
 357   VideoView videoView = VideoView::New();
 358   DALI_TEST_CHECK( videoView );
 359
 360   Property::Map windowSurfaceTarget;
 361   Property::Map nativeImageTarget;
 362
 363   windowSurfaceTarget.Insert( RENDERING_TYPE, "windowSurfaceTarget" );
 364   nativeImageTarget.Insert( RENDERING_TYPE, "nativeImageTarget" );
 365
 366   Property::Map map;
 367   Property::Value value;
 368   videoView.SetProperty( VideoView::Property::VIDEO, windowSurfaceTarget );
 369
 370   value = videoView.GetProperty( VideoView::Property::VIDEO );
 371   DALI_TEST_CHECK( value.Get( map ) );
 372
 373   Property::Value* type = map.Find( RENDERING_TYPE );
 374   DALI_TEST_CHECK( type );
 375   DALI_TEST_EQUALS( "windowSurfaceTarget", type->Get<std::string>(), TEST_LOCATION );
 376
 377   videoView.SetProperty( VideoView::Property::VIDEO, nativeImageTarget );
 378
 379   value = videoView.GetProperty( VideoView::Property::VIDEO );
 380   DALI_TEST_CHECK( value.Get( map ) );
 381   type = map.Find( RENDERING_TYPE );
 382
 383   DALI_TEST_CHECK( type );
 384   DALI_TEST_EQUALS( "nativeImageTarget", type->Get<std::string>(), TEST_LOCATION );
 385
 386   END_TEST;
 387 }
 388
 389 int UtcDaliVideoViewCustomShaderForCoverage(void)
 390 {
 391   ToolkitTestApplication application;
 392   VideoView videoView = VideoView::New();
 393   DALI_TEST_CHECK( videoView );
 394
 395   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 396
 397   videoView.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 398   bool isUnderlay = videoView.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 399   DALI_TEST_CHECK( !isUnderlay );
 400
 401   application.GetScene().Add( videoView );
 402   videoView.SetProperty( VideoView::Property::VIDEO, "testvideo" );
 403
 404   Property::Map customShader;
 405   customShader.Insert( "vertexShader", VERTEX_SHADER );
 406   customShader.Insert( "fragmentShader", FRAGMENT_SHADER );
 407
 408   Property::Map map;
 409   map.Insert( "shader", customShader );
 410
 411   videoView.SetProperty( VideoView::Property::VIDEO, map );
 412
 413   Property::Map map2;
 414   Property::Value value = videoView.GetProperty( VideoView::Property::VIDEO );
 415
 416   DALI_TEST_CHECK( !value.Get( map2 ) );
 417   END_TEST;
 418 }
 419
 420 int UtcDaliVideoViewMethodsForCoverage2(void)
 421 {
 422   ToolkitTestApplication application;
 423   VideoView videoView = VideoView::New();
 424   DALI_TEST_CHECK( videoView );
 425
 426   Property::Map windowSurfaceTarget;
 427
 428   windowSurfaceTarget.Insert( RENDERING_TYPE, "windowSurfaceTarget" );
 429
 430   application.GetScene().Add( videoView );
 431
 432   application.SendNotification();
 433   application.Render();
 434
 435   Property::Map map;
 436   Property::Value value;
 437   videoView.SetProperty( VideoView::Property::VIDEO, windowSurfaceTarget );
 438
 439   value = videoView.GetProperty( VideoView::Property::VIDEO );
 440   DALI_TEST_CHECK( value.Get( map ) );
 441
 442   Property::Value* type = map.Find( RENDERING_TYPE );
 443   DALI_TEST_CHECK( type );
 444   DALI_TEST_EQUALS( "windowSurfaceTarget", type->Get<std::string>(), TEST_LOCATION );
 445
 446   Vector3 vector(100.0f, 100.0f, 0.0f);
 447
 448   DALI_TEST_CHECK(vector != videoView.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 449   videoView.SetProperty( Actor::Property::SIZE, vector );
 450
 451   application.SendNotification();
 452   application.Render();
 453
 454   // Check the size in the new frame
 455   DALI_TEST_CHECK(vector == videoView.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 456
 457   END_TEST;
 458 }
 459
 460 int UtcDaliVideoViewPropertyUnderlay(void)
 461 {
 462   ToolkitTestApplication application;
 463   tet_infoline("UtcDaliVideoViewPropertyUnderlay");
 464   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 465
 466   VideoView view = VideoView::New();
 467   DALI_TEST_CHECK( view );
 468
 469   application.GetScene().Add( view );
 470   view.Play();
 471
 472   application.SendNotification();
 473   application.Render();
 474
 475   bool isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 476   DALI_TEST_CHECK( isUnderlay );
 477
 478   view.Play();
 479   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 480   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 481   DALI_TEST_CHECK( !isUnderlay );
 482
 483   view.Play();
 484   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, true );
 485   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 486   DALI_TEST_CHECK( isUnderlay );
 487
 488   // If platform api doesn't provide any API or feature for decoded images of video,
 489   // UNDERLAY should be true
 490   ToolkitApplication::DECODED_IMAGES_SUPPORTED = false;
 491
 492   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 493   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 494   DALI_TEST_CHECK( isUnderlay );
 495
 496   // For coverage
 497   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 498
 499   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, true );
 500   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 501   isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 502   DALI_TEST_CHECK( !isUnderlay );
 503
 504   view.Stop();
 505
 506   END_TEST;
 507 }
 508
 509 int UtcDaliVideoViewPropertyPlayPosition(void)
 510 {
 511   ToolkitTestApplication application;
 512   tet_infoline("UtcDaliVideoViewPropertyPlayPosition");
 513
 514   VideoView view = VideoView::New();
 515   DALI_TEST_CHECK( view );
 516
 517   application.GetScene().Add( view );
 518   view.Play();
 519
 520   application.SendNotification();
 521   application.Render();
 522
 523   int playPos = view.GetProperty( Toolkit::VideoView::Property::PLAY_POSITION ).Get< int >();
 524   DALI_TEST_CHECK( playPos == 0 );
 525
 526   view.SetProperty( Toolkit::VideoView::Property::PLAY_POSITION, 10 );
 527   playPos = view.GetProperty( Toolkit::VideoView::Property::PLAY_POSITION ).Get< int >();
 528   // Actually setting play position will be async
 529   // Actual platform result may be different.
 530   DALI_TEST_CHECK( playPos == 10 );
 531
 532   END_TEST;
 533 }
 534
 535 // For coverage.
 536 int UtcDaliVideoViewNew2(void)
 537 {
 538   ToolkitTestApplication application;
 539   tet_infoline("UtcDaliVideoViewNew2");
 540
 541   VideoView view = VideoView::New( true );
 542   DALI_TEST_CHECK( view );
 543
 544   application.GetScene().Add( view );
 545   view.Play();
 546
 547   application.SendNotification();
 548   application.Render();
 549
 550   VideoView view2 = VideoView::New( "", false );
 551   DALI_TEST_CHECK( view2 );
 552
 553   application.GetScene().Add( view2 );
 554   view2.Play();
 555
 556   application.SendNotification();
 557   application.Render();
 558
 559   END_TEST;
 560 }
 561
 562 int UtcDaliVideoViewPropertyDisplayMode(void)
 563 {
 564   ToolkitTestApplication application;
 565   tet_infoline("UtcDaliVideoViewPropertyDisplayMode");
 566
 567   VideoView view = VideoView::New();
 568   DALI_TEST_CHECK( view );
 569
 570   application.GetScene().Add( view );
 571   view.Play();
 572
 573   application.SendNotification();
 574   application.Render();
 575
 576   view.SetProperty( Toolkit::VideoView::Property::DISPLAY_MODE, Toolkit::VideoView::DisplayMode::DST_ROI );
 577   int displayMode = view.GetProperty( Toolkit::VideoView::Property::DISPLAY_MODE ).Get< int >();
 578   DALI_TEST_CHECK( displayMode == Toolkit::VideoView::DisplayMode::DST_ROI );
 579
 580   END_TEST;
 581 }
 582
 583
 584 int UtcDaliVideoViewCustomShader(void)
 585 {
 586   ToolkitTestApplication application;
 587   tet_infoline( "VideoView with custom shader" );
 588
 589   VideoView view = VideoView::New( false );
 590   DALI_TEST_CHECK( view );
 591
 592   ToolkitApplication::DECODED_IMAGES_SUPPORTED = true;
 593
 594   view.SetProperty( Toolkit::VideoView::Property::UNDERLAY, false );
 595   bool isUnderlay = view.GetProperty( Toolkit::VideoView::Property::UNDERLAY ).Get< bool >();
 596   DALI_TEST_CHECK( !isUnderlay );
 597
 598   application.GetScene().Add( view );
 599   view.SetProperty( VideoView::Property::VIDEO, "testvideo" );
 600
 601   /* insert custom shader */
 602   Property::Map customShader;
 603   std::string fragmentShaderString;
 604   fragmentShaderString.reserve( strlen( fragmentShaderPrefix ) + strlen( FRAGMENT_SHADER ) );
 605   fragmentShaderString.append( fragmentShaderPrefix );
 606   fragmentShaderString.append( FRAGMENT_SHADER );
 607   customShader.Insert( "vertexShader", VERTEX_SHADER );
 608   customShader.Insert( "fragmentShader", fragmentShaderString );
 609
 610   Property::Map map;
 611   map.Insert( "shader", customShader );
 612
 613   view.SetProperty( VideoView::Property::VIDEO, map );
 614
 615   /* do render for check custom shader */
 616   application.GetScene().Add( view );
 617   view.Play();
 618
 619   application.SendNotification();
 620   application.Render();
 621
 622   /* get renderer */
 623   DALI_TEST_CHECK( view.GetRendererCount() == 1u );
 624   Renderer renderer = view.GetRendererAt( 0 );
 625   Shader shader = renderer.GetShader();
 626   DALI_TEST_CHECK( shader );
 627
 628   Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
 629   Property::Map* shaderMap = value.GetMap();
 630   DALI_TEST_CHECK( shaderMap );
 631
 632   Property::Value* fragment = shaderMap->Find( "fragment" ); // fragment key name from shader-impl.cpp
 633   DALI_TEST_EQUALS( fragmentShaderString, fragment->Get<std::string>(), TEST_LOCATION );
 634
 635   Property::Value* vertex = shaderMap->Find( "vertex" ); // vertex key name from shader-impl.cpp
 636   DALI_TEST_EQUALS( VERTEX_SHADER, vertex->Get<std::string>(), TEST_LOCATION );
 637
 638   END_TEST;
 639 }
 640
 641 // Functor to test whether a Finish signal is emitted
 642 struct AnimationFinishCheck
 643 {
 644   AnimationFinishCheck(bool& signalReceived)
 645   : mSignalReceived(signalReceived)
 646   {
 647   }
 648
 649   void operator()(Animation& animation)
 650   {
 651     mSignalReceived = true;
 652   }
 653
 654   void Reset()
 655   {
 656     mSignalReceived = false;
 657   }
 658
 659   void CheckSignalReceived()
 660   {
 661     if (!mSignalReceived)
 662     {
 663       tet_printf("Expected Finish signal was not received\n");
 664       tet_result(TET_FAIL);
 665     }
 666     else
 667     {
 668       tet_result(TET_PASS);
 669     }
 670   }
 671
 672   void CheckSignalNotReceived()
 673   {
 674     if (mSignalReceived)
 675     {
 676       tet_printf("Unexpected Finish signal was received\n");
 677       tet_result(TET_FAIL);
 678     }
 679     else
 680     {
 681       tet_result(TET_PASS);
 682     }
 683   }
 684
 685   bool& mSignalReceived; // owned by individual tests
 686 };
 687
 688 int UtcDaliVideoViewSyncAniamtionForCoverage(void)
 689 {
 690   ToolkitTestApplication application;
 691
 692   VideoView videoView = DevelVideoView::New( Dali::VideoSyncMode::ENABLED );
 693   DALI_TEST_CHECK( videoView );
 694
 695   // Build the animation
 696   float durationSeconds(1.0f);
 697   Animation animation = Animation::New(durationSeconds);
 698
 699   // Start the animation
 700   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 701   animation.AnimateTo(Property(videoView, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 702   DevelVideoView::PlayAnimation( videoView, animation );
 703
 704   bool signalReceived(false);
 705   AnimationFinishCheck finishCheck(signalReceived);
 706   animation.FinishedSignal().Connect(&application, finishCheck);
 707
 708   application.SendNotification();
 709   application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) - 1u/*just less than the animation duration*/);
 710
 711   // We didn't expect the animation to finish yet
 712   application.SendNotification();
 713   finishCheck.CheckSignalNotReceived();
 714
 715   application.Render(2u/*just beyond the animation duration*/);
 716
 717   // We did expect the animation to finish
 718   application.SendNotification();
 719   finishCheck.CheckSignalReceived();
 720   DALI_TEST_EQUALS( targetPosition, videoView.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
 721
 722   // Restart the animation, with a different duration
 723   finishCheck.Reset();
 724
 725   END_TEST;
 726 }
 727
 728 int UtcDaliVideoViewASyncAniamtionForCoverage(void)
 729 {
 730   ToolkitTestApplication application;
 731
 732   VideoView videoView = DevelVideoView::New( Dali::VideoSyncMode::DISABLED );
 733   DALI_TEST_CHECK( videoView );
 734
 735   // Build the animation
 736   float durationSeconds(1.0f);
 737   Animation animation = Animation::New(durationSeconds);
 738
 739   // Start the animation
 740   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 741   animation.AnimateTo(Property(videoView, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 742   DevelVideoView::PlayAnimation( videoView, animation );
 743
 744   bool signalReceived(false);
 745   AnimationFinishCheck finishCheck(signalReceived);
 746   animation.FinishedSignal().Connect(&application, finishCheck);
 747
 748   application.SendNotification();
 749   application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) - 1u/*just less than the animation duration*/);
 750
 751   // We didn't expect the animation to finish yet
 752   application.SendNotification();
 753   finishCheck.CheckSignalNotReceived();
 754
 755   application.Render(2u/*just beyond the animation duration*/);
 756
 757   // We did expect the animation to finish
 758   application.SendNotification();
 759   finishCheck.CheckSignalReceived();
 760   DALI_TEST_EQUALS( targetPosition, videoView.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
 761
 762   // Restart the animation, with a different duration
 763   finishCheck.Reset();
 764
 765   END_TEST;
 766 }
 767
 768 int UtcDaliVideoViewResizeWithSynchronization(void)
 769 {
 770   ToolkitTestApplication application;
 771   VideoView videoView = DevelVideoView::New( Dali::VideoSyncMode::ENABLED );
 772   DALI_TEST_CHECK( videoView );
 773
 774   application.GetScene().Add( videoView );
 775
 776   Vector3 vector(50.0f, 200.0f, 0.0f);
 777   videoView.SetProperty( Actor::Property::SIZE, vector );
 778
 779   application.SendNotification();
 780   application.Render();
 781
 782   DALI_TEST_CHECK(vector == videoView.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 783
 784   END_TEST;
 785 }