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