automated-tests/src/dali/utc-Dali-ObjectRegistry.cpp

   1 /*
   2  * Copyright (c) 2014 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
  20 #include <stdlib.h>
  21 #include <dali-test-suite-utils.h>
  22 #include <dali/public-api/dali-core.h>
  23
  24 using namespace Dali;
  25
  26 #include "mesh-builder.h"
  27
  28 namespace
  29 {
  30
  31 // Functors to test whether Object created/destroyed signal is emitted for different types of Objects
  32
  33 struct TestObjectDestroyedCallback
  34 {
  35   TestObjectDestroyedCallback(bool& signalReceived, Dali::RefObject*& objectPointer)
  36   : mSignalVerified(signalReceived),
  37     mObjectPointer(objectPointer)
  38   {
  39   }
  40
  41   void operator()(const Dali::RefObject* objectPointer)
  42   {
  43     tet_infoline("Verifying TestObjectDestroyedCallback()");
  44
  45     if(objectPointer == mObjectPointer)
  46     {
  47       mSignalVerified = true;
  48     }
  49   }
  50
  51   bool& mSignalVerified;
  52   Dali::RefObject*& mObjectPointer;
  53 };
  54
  55 struct TestActorCallback
  56 {
  57   TestActorCallback(bool& signalReceived)
  58   : mSignalVerified(signalReceived)
  59   {
  60   }
  61
  62   void operator()(BaseHandle object)
  63   {
  64     tet_infoline("Verifying TestActorCallback()");
  65     Actor actor = Actor::DownCast(object);
  66     if(actor)
  67     {
  68       mSignalVerified = true;
  69     }
  70   }
  71
  72   bool& mSignalVerified;
  73 };
  74
  75 struct TestCameraActorCallback
  76 {
  77   TestCameraActorCallback(bool& signalReceived)
  78   : mSignalVerified(signalReceived)
  79   {
  80   }
  81   void operator()(BaseHandle object)
  82   {
  83     tet_infoline("Verifying TestCameraActorCallback()");
  84     CameraActor actor = CameraActor::DownCast(object);
  85     if(actor)
  86     {
  87       mSignalVerified = true;
  88     }
  89   }
  90   bool& mSignalVerified;
  91 };
  92
  93 struct TestImageActorCallback
  94 {
  95   TestImageActorCallback(bool& signalReceived)
  96   : mSignalVerified(signalReceived)
  97   {
  98   }
  99   void operator()(BaseHandle object)
 100   {
 101     tet_infoline("Verifying TestImageActorCallback()");
 102     ImageActor actor = ImageActor::DownCast(object);
 103     if(actor)
 104     {
 105       mSignalVerified = true;
 106     }
 107   }
 108   bool& mSignalVerified;
 109 };
 110
 111 struct TestLayerCallback
 112 {
 113   TestLayerCallback(bool& signalReceived)
 114   : mSignalVerified(signalReceived)
 115   {
 116   }
 117   void operator()(BaseHandle object)
 118   {
 119     tet_infoline("Verifying TestLayerCallback()");
 120     Layer actor = Layer::DownCast(object);
 121     if(actor)
 122     {
 123       mSignalVerified = true;
 124     }
 125   }
 126   bool& mSignalVerified;
 127 };
 128
 129 struct TestLightActorCallback
 130 {
 131   TestLightActorCallback(bool& signalReceived)
 132   : mSignalVerified(signalReceived)
 133   {
 134   }
 135   void operator()(BaseHandle object)
 136   {
 137     tet_infoline("Verifying TestLightActorCallback()");
 138     LightActor actor = LightActor::DownCast(object);
 139     if(actor)
 140     {
 141       mSignalVerified = true;
 142     }
 143   }
 144   bool& mSignalVerified;
 145 };
 146
 147 struct TestMeshActorCallback
 148 {
 149   TestMeshActorCallback(bool& signalReceived)
 150   : mSignalVerified(signalReceived)
 151   {
 152   }
 153   void operator()(BaseHandle object)
 154   {
 155     tet_infoline("Verifying TestMeshActorCallback()");
 156     MeshActor actor = MeshActor::DownCast(object);
 157     if(actor)
 158     {
 159       mSignalVerified = true;
 160     }
 161   }
 162   bool& mSignalVerified;
 163 };
 164
 165 struct TestModelCallback
 166 {
 167   TestModelCallback(bool& signalReceived)
 168   : mSignalVerified(signalReceived)
 169   {
 170   }
 171   void operator()(BaseHandle object)
 172   {
 173     tet_infoline("Verifying TestModelCallback()");
 174     Model actor = Model::DownCast(object);
 175     if(actor)
 176     {
 177       mSignalVerified = true;
 178     }
 179   }
 180   bool& mSignalVerified;
 181 };
 182
 183 struct TestTextActorCallback
 184 {
 185   TestTextActorCallback(bool& signalReceived)
 186   : mSignalVerified(signalReceived)
 187   {
 188   }
 189   void operator()(BaseHandle object)
 190   {
 191     tet_infoline("Verifying TestTextActorCallback()");
 192     TextActor actor = TextActor::DownCast(object);
 193     if(actor)
 194     {
 195       mSignalVerified = true;
 196     }
 197   }
 198   bool& mSignalVerified;
 199 };
 200
 201 struct TestAnimationCallback
 202 {
 203   TestAnimationCallback(bool& signalReceived)
 204   : mSignalVerified(signalReceived)
 205   {
 206   }
 207   void operator()(BaseHandle object)
 208   {
 209     tet_infoline("Verifying TestAnimationCallback()");
 210     Animation actor = Animation::DownCast(object);
 211     if(actor)
 212     {
 213       mSignalVerified = true;
 214     }
 215   }
 216   bool& mSignalVerified;
 217 };
 218
 219 struct TestShaderEffectCallback
 220 {
 221   TestShaderEffectCallback(bool& signalReceived)
 222   : mSignalVerified(signalReceived)
 223   {
 224   }
 225   void operator()(BaseHandle object)
 226   {
 227     tet_infoline("Verifying TestShaderEffectCallback()");
 228     ShaderEffect actor = ShaderEffect::DownCast(object);
 229     if(actor)
 230     {
 231       mSignalVerified = true;
 232     }
 233   }
 234   bool& mSignalVerified;
 235 };
 236
 237
 238 } // anonymous namespace
 239
 240
 241
 242
 243 int UtcDaliObjectRegistryGet(void)
 244 {
 245   TestApplication application;
 246
 247   ObjectRegistry registry; //  like this for ctor code coverage
 248   registry= Stage::GetCurrent().GetObjectRegistry();
 249
 250   DALI_TEST_CHECK( registry );
 251   END_TEST;
 252 }
 253
 254
 255
 256 int UtcDaliObjectRegistrySignalActorCreated(void)
 257 {
 258   tet_infoline("Testing GetObjectRegistry()");
 259   TestApplication application;
 260   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 261   DALI_TEST_CHECK( registry );
 262
 263   bool verified = false;
 264   TestActorCallback test(verified);
 265
 266   Dali::RefObject* objectPointer = NULL;
 267   TestObjectDestroyedCallback test2(verified, objectPointer);
 268
 269   registry.ObjectCreatedSignal().Connect(&application, test);
 270   registry.ObjectDestroyedSignal().Connect(&application, test2);
 271
 272   {
 273     Actor actor = Actor::New();
 274     DALI_TEST_CHECK( test.mSignalVerified );
 275
 276     verified = false;
 277     objectPointer = actor.GetObjectPtr();
 278   }
 279   DALI_TEST_CHECK( test.mSignalVerified );
 280   END_TEST;
 281 }
 282
 283 int UtcDaliObjectRegistrySignalCameraCreated(void)
 284 {
 285   TestApplication application;
 286
 287   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 288
 289   bool verified = false;
 290   TestCameraActorCallback test(verified);
 291
 292   Dali::RefObject* objectPointer = NULL;
 293   TestObjectDestroyedCallback test2(verified, objectPointer);
 294
 295   registry.ObjectCreatedSignal().Connect(&application, test);
 296   registry.ObjectDestroyedSignal().Connect(&application, test2);
 297
 298   {
 299     CameraActor actor = CameraActor::New();
 300     DALI_TEST_CHECK( test.mSignalVerified );
 301
 302     verified = false;
 303     objectPointer = actor.GetObjectPtr();
 304   }
 305   DALI_TEST_CHECK( test.mSignalVerified );
 306   END_TEST;
 307 }
 308
 309 int UtcDaliObjectRegistrySignalImageActorCreated(void)
 310 {
 311   TestApplication application;
 312   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 313
 314   static const char* TestImageFilename = "icon_wrt.png";
 315   Image image = Image::New(TestImageFilename);
 316
 317   bool verified = false;
 318   TestImageActorCallback test(verified);
 319
 320   Dali::RefObject* objectPointer = NULL;
 321   TestObjectDestroyedCallback test2(verified, objectPointer);
 322
 323   registry.ObjectCreatedSignal().Connect(&application, test);
 324   registry.ObjectDestroyedSignal().Connect(&application, test2);
 325
 326   {
 327     ImageActor actor = ImageActor::New(image);
 328     DALI_TEST_CHECK( test.mSignalVerified );
 329
 330     verified = false;
 331     objectPointer = actor.GetObjectPtr();
 332   }
 333   DALI_TEST_CHECK( test.mSignalVerified );
 334   END_TEST;
 335 }
 336
 337 int UtcDaliObjectRegistrySignalLayerCreated(void)
 338 {
 339   TestApplication application;
 340   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 341
 342   bool verified = false;
 343   TestLayerCallback test(verified);
 344
 345   Dali::RefObject* objectPointer = NULL;
 346   TestObjectDestroyedCallback test2(verified, objectPointer);
 347
 348   registry.ObjectCreatedSignal().Connect(&application, test);
 349   registry.ObjectDestroyedSignal().Connect(&application, test2);
 350
 351   {
 352     Layer actor = Layer::New();
 353     DALI_TEST_CHECK( test.mSignalVerified );
 354
 355     verified = false;
 356     objectPointer = actor.GetObjectPtr();
 357   }
 358   DALI_TEST_CHECK( test.mSignalVerified );
 359   END_TEST;
 360 }
 361
 362 int UtcDaliObjectRegistrySignalLightActorCreated(void)
 363 {
 364   TestApplication application;
 365   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 366
 367   bool verified = false;
 368   TestLightActorCallback test(verified);
 369
 370   Dali::RefObject* objectPointer = NULL;
 371   TestObjectDestroyedCallback test2(verified, objectPointer);
 372
 373   registry.ObjectCreatedSignal().Connect(&application, test);
 374   registry.ObjectDestroyedSignal().Connect(&application, test2);
 375
 376   {
 377     LightActor actor = LightActor::New();
 378     DALI_TEST_CHECK( test.mSignalVerified );
 379
 380     verified = false;
 381     objectPointer = actor.GetObjectPtr();
 382   }
 383   DALI_TEST_CHECK( test.mSignalVerified );
 384   END_TEST;
 385 }
 386
 387 int UtcDaliObjectRegistrySignalMeshActorCreated(void)
 388 {
 389   TestApplication application;
 390   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 391
 392   bool verified = false;
 393   TestMeshActorCallback test(verified);
 394
 395   Dali::RefObject* objectPointer = NULL;
 396   TestObjectDestroyedCallback test2(verified, objectPointer);
 397
 398   registry.ObjectCreatedSignal().Connect(&application, test);
 399   registry.ObjectDestroyedSignal().Connect(&application, test2);
 400
 401   Mesh mesh = ConstructMesh(60);
 402
 403   {
 404     MeshActor actor = MeshActor::New(mesh);
 405
 406     DALI_TEST_CHECK(actor);
 407     DALI_TEST_CHECK( test.mSignalVerified );
 408
 409     verified = false;
 410     objectPointer = actor.GetObjectPtr();
 411   }
 412   DALI_TEST_CHECK( test.mSignalVerified );
 413   END_TEST;
 414 }
 415
 416 int UtcDaliObjectRegistrySignalModelCreated(void)
 417 {
 418   TestApplication application;
 419   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 420
 421   bool verified = false;
 422   TestModelCallback test(verified);
 423
 424   Dali::RefObject* objectPointer = NULL;
 425   TestObjectDestroyedCallback test2(verified, objectPointer);
 426
 427   registry.ObjectCreatedSignal().Connect(&application, test);
 428   registry.ObjectDestroyedSignal().Connect(&application, test2);
 429
 430   {
 431     Model model = Model::New("blah");
 432     DALI_TEST_CHECK( test.mSignalVerified );
 433
 434     verified = false;
 435     objectPointer = model.GetObjectPtr();
 436   }
 437   DALI_TEST_CHECK( test.mSignalVerified );
 438   END_TEST;
 439 }
 440
 441 int UtcDaliObjectRegistrySignalTextActorCreated(void)
 442 {
 443   TestApplication application;
 444   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 445
 446   bool verified = false;
 447   TestTextActorCallback test(verified);
 448
 449   Dali::RefObject* objectPointer = NULL;
 450   TestObjectDestroyedCallback test2(verified, objectPointer);
 451
 452   registry.ObjectCreatedSignal().Connect(&application, test);
 453   registry.ObjectDestroyedSignal().Connect(&application, test2);
 454
 455   {
 456     TextActor actor = TextActor::New("Hello");
 457     DALI_TEST_CHECK( test.mSignalVerified );
 458
 459     verified = false;
 460     objectPointer = actor.GetObjectPtr();
 461   }
 462   DALI_TEST_CHECK( test.mSignalVerified );
 463   END_TEST;
 464 }
 465
 466 int UtcDaliObjectRegistrySignalAnimationCreated(void)
 467 {
 468   TestApplication application;
 469   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 470
 471   bool verified = false;
 472   TestAnimationCallback test(verified);
 473
 474   Dali::RefObject* objectPointer = NULL;
 475   TestObjectDestroyedCallback test2(verified, objectPointer);
 476
 477   registry.ObjectCreatedSignal().Connect(&application, test);
 478   registry.ObjectDestroyedSignal().Connect(&application, test2);
 479
 480   {
 481     Animation animation = Animation::New(1.0f);
 482     DALI_TEST_CHECK( test.mSignalVerified );
 483
 484     verified = false;
 485     objectPointer = animation.GetObjectPtr();
 486   }
 487   DALI_TEST_CHECK( test.mSignalVerified );
 488   END_TEST;
 489 }
 490
 491 int UtcDaliObjectRegistrySignalShaderEffectCreated(void)
 492 {
 493   TestApplication application;
 494   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 495
 496   static const char* VertexSource =
 497   "void main()\n"
 498   "{\n"
 499   "  gl_Position = uProjection * uModelView * vec4(aPosition, 1.0);\n"
 500   "  vTexCoord = aTexCoord;\n"
 501   "}\n";
 502
 503   static const char* FragmentSource =
 504   "void main()\n"
 505   "{\n"
 506   "  gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n"
 507   "}\n";
 508
 509   bool verified = false;
 510   TestShaderEffectCallback test(verified);
 511
 512   Dali::RefObject* objectPointer = NULL;
 513   TestObjectDestroyedCallback test2(verified, objectPointer);
 514
 515   registry.ObjectCreatedSignal().Connect(&application, test);
 516   registry.ObjectDestroyedSignal().Connect(&application, test2);
 517
 518   {
 519     ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 520     DALI_TEST_CHECK( test.mSignalVerified );
 521
 522     verified = false;
 523     objectPointer = effect.GetObjectPtr();
 524   }
 525   DALI_TEST_CHECK( test.mSignalVerified );
 526   END_TEST;
 527 }