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
 130 struct TestMeshActorCallback
 131 {
 132   TestMeshActorCallback(bool& signalReceived)
 133   : mSignalVerified(signalReceived)
 134   {
 135   }
 136   void operator()(BaseHandle object)
 137   {
 138     tet_infoline("Verifying TestMeshActorCallback()");
 139     MeshActor actor = MeshActor::DownCast(object);
 140     if(actor)
 141     {
 142       mSignalVerified = true;
 143     }
 144   }
 145   bool& mSignalVerified;
 146 };
 147
 148 struct TestTextActorCallback
 149 {
 150   TestTextActorCallback(bool& signalReceived)
 151   : mSignalVerified(signalReceived)
 152   {
 153   }
 154   void operator()(BaseHandle object)
 155   {
 156     tet_infoline("Verifying TestTextActorCallback()");
 157     TextActor actor = TextActor::DownCast(object);
 158     if(actor)
 159     {
 160       mSignalVerified = true;
 161     }
 162   }
 163   bool& mSignalVerified;
 164 };
 165
 166 struct TestAnimationCallback
 167 {
 168   TestAnimationCallback(bool& signalReceived)
 169   : mSignalVerified(signalReceived)
 170   {
 171   }
 172   void operator()(BaseHandle object)
 173   {
 174     tet_infoline("Verifying TestAnimationCallback()");
 175     Animation actor = Animation::DownCast(object);
 176     if(actor)
 177     {
 178       mSignalVerified = true;
 179     }
 180   }
 181   bool& mSignalVerified;
 182 };
 183
 184 struct TestShaderEffectCallback
 185 {
 186   TestShaderEffectCallback(bool& signalReceived)
 187   : mSignalVerified(signalReceived)
 188   {
 189   }
 190   void operator()(BaseHandle object)
 191   {
 192     tet_infoline("Verifying TestShaderEffectCallback()");
 193     ShaderEffect actor = ShaderEffect::DownCast(object);
 194     if(actor)
 195     {
 196       mSignalVerified = true;
 197     }
 198   }
 199   bool& mSignalVerified;
 200 };
 201
 202
 203 } // anonymous namespace
 204
 205
 206
 207
 208 int UtcDaliObjectRegistryGet(void)
 209 {
 210   TestApplication application;
 211
 212   ObjectRegistry registry; //  like this for ctor code coverage
 213   registry= Stage::GetCurrent().GetObjectRegistry();
 214
 215   DALI_TEST_CHECK( registry );
 216   END_TEST;
 217 }
 218
 219
 220
 221 int UtcDaliObjectRegistrySignalActorCreated(void)
 222 {
 223   tet_infoline("Testing GetObjectRegistry()");
 224   TestApplication application;
 225   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 226   DALI_TEST_CHECK( registry );
 227
 228   bool verified = false;
 229   TestActorCallback test(verified);
 230
 231   Dali::RefObject* objectPointer = NULL;
 232   TestObjectDestroyedCallback test2(verified, objectPointer);
 233
 234   registry.ObjectCreatedSignal().Connect(&application, test);
 235   registry.ObjectDestroyedSignal().Connect(&application, test2);
 236
 237   {
 238     Actor actor = Actor::New();
 239     DALI_TEST_CHECK( test.mSignalVerified );
 240
 241     verified = false;
 242     objectPointer = actor.GetObjectPtr();
 243   }
 244   DALI_TEST_CHECK( test.mSignalVerified );
 245   END_TEST;
 246 }
 247
 248 int UtcDaliObjectRegistrySignalCameraCreated(void)
 249 {
 250   TestApplication application;
 251
 252   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 253
 254   bool verified = false;
 255   TestCameraActorCallback test(verified);
 256
 257   Dali::RefObject* objectPointer = NULL;
 258   TestObjectDestroyedCallback test2(verified, objectPointer);
 259
 260   registry.ObjectCreatedSignal().Connect(&application, test);
 261   registry.ObjectDestroyedSignal().Connect(&application, test2);
 262
 263   {
 264     CameraActor actor = CameraActor::New();
 265     DALI_TEST_CHECK( test.mSignalVerified );
 266
 267     verified = false;
 268     objectPointer = actor.GetObjectPtr();
 269   }
 270   DALI_TEST_CHECK( test.mSignalVerified );
 271   END_TEST;
 272 }
 273
 274 int UtcDaliObjectRegistrySignalImageActorCreated(void)
 275 {
 276   TestApplication application;
 277   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 278
 279   static const char* TestImageFilename = "icon_wrt.png";
 280   Image image = ResourceImage::New(TestImageFilename);
 281
 282   bool verified = false;
 283   TestImageActorCallback test(verified);
 284
 285   Dali::RefObject* objectPointer = NULL;
 286   TestObjectDestroyedCallback test2(verified, objectPointer);
 287
 288   registry.ObjectCreatedSignal().Connect(&application, test);
 289   registry.ObjectDestroyedSignal().Connect(&application, test2);
 290
 291   {
 292     ImageActor actor = ImageActor::New(image);
 293     DALI_TEST_CHECK( test.mSignalVerified );
 294
 295     verified = false;
 296     objectPointer = actor.GetObjectPtr();
 297   }
 298   DALI_TEST_CHECK( test.mSignalVerified );
 299   END_TEST;
 300 }
 301
 302 int UtcDaliObjectRegistrySignalLayerCreated(void)
 303 {
 304   TestApplication application;
 305   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 306
 307   bool verified = false;
 308   TestLayerCallback test(verified);
 309
 310   Dali::RefObject* objectPointer = NULL;
 311   TestObjectDestroyedCallback test2(verified, objectPointer);
 312
 313   registry.ObjectCreatedSignal().Connect(&application, test);
 314   registry.ObjectDestroyedSignal().Connect(&application, test2);
 315
 316   {
 317     Layer actor = Layer::New();
 318     DALI_TEST_CHECK( test.mSignalVerified );
 319
 320     verified = false;
 321     objectPointer = actor.GetObjectPtr();
 322   }
 323   DALI_TEST_CHECK( test.mSignalVerified );
 324   END_TEST;
 325 }
 326
 327
 328 int UtcDaliObjectRegistrySignalMeshActorCreated(void)
 329 {
 330   TestApplication application;
 331   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 332
 333   bool verified = false;
 334   TestMeshActorCallback test(verified);
 335
 336   Dali::RefObject* objectPointer = NULL;
 337   TestObjectDestroyedCallback test2(verified, objectPointer);
 338
 339   registry.ObjectCreatedSignal().Connect(&application, test);
 340   registry.ObjectDestroyedSignal().Connect(&application, test2);
 341
 342   Mesh mesh = ConstructMesh(60);
 343
 344   {
 345     MeshActor actor = MeshActor::New(mesh);
 346
 347     DALI_TEST_CHECK(actor);
 348     DALI_TEST_CHECK( test.mSignalVerified );
 349
 350     verified = false;
 351     objectPointer = actor.GetObjectPtr();
 352   }
 353   DALI_TEST_CHECK( test.mSignalVerified );
 354   END_TEST;
 355 }
 356
 357
 358 int UtcDaliObjectRegistrySignalTextActorCreated(void)
 359 {
 360   TestApplication application;
 361   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 362
 363   bool verified = false;
 364   TestTextActorCallback test(verified);
 365
 366   Dali::RefObject* objectPointer = NULL;
 367   TestObjectDestroyedCallback test2(verified, objectPointer);
 368
 369   registry.ObjectCreatedSignal().Connect(&application, test);
 370   registry.ObjectDestroyedSignal().Connect(&application, test2);
 371
 372   {
 373     TextActor actor = TextActor::New("Hello");
 374     DALI_TEST_CHECK( test.mSignalVerified );
 375
 376     verified = false;
 377     objectPointer = actor.GetObjectPtr();
 378   }
 379   DALI_TEST_CHECK( test.mSignalVerified );
 380   END_TEST;
 381 }
 382
 383 int UtcDaliObjectRegistrySignalAnimationCreated(void)
 384 {
 385   TestApplication application;
 386   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 387
 388   bool verified = false;
 389   TestAnimationCallback test(verified);
 390
 391   Dali::RefObject* objectPointer = NULL;
 392   TestObjectDestroyedCallback test2(verified, objectPointer);
 393
 394   registry.ObjectCreatedSignal().Connect(&application, test);
 395   registry.ObjectDestroyedSignal().Connect(&application, test2);
 396
 397   {
 398     Animation animation = Animation::New(1.0f);
 399     DALI_TEST_CHECK( test.mSignalVerified );
 400
 401     verified = false;
 402     objectPointer = animation.GetObjectPtr();
 403   }
 404   DALI_TEST_CHECK( test.mSignalVerified );
 405   END_TEST;
 406 }
 407
 408 int UtcDaliObjectRegistrySignalShaderEffectCreated(void)
 409 {
 410   TestApplication application;
 411   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 412
 413   static const char* VertexSource =
 414   "void main()\n"
 415   "{\n"
 416   "  gl_Position = uProjection * uModelView * vec4(aPosition, 1.0);\n"
 417   "  vTexCoord = aTexCoord;\n"
 418   "}\n";
 419
 420   static const char* FragmentSource =
 421   "void main()\n"
 422   "{\n"
 423   "  gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n"
 424   "}\n";
 425
 426   bool verified = false;
 427   TestShaderEffectCallback test(verified);
 428
 429   Dali::RefObject* objectPointer = NULL;
 430   TestObjectDestroyedCallback test2(verified, objectPointer);
 431
 432   registry.ObjectCreatedSignal().Connect(&application, test);
 433   registry.ObjectDestroyedSignal().Connect(&application, test2);
 434
 435   {
 436     ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 437     DALI_TEST_CHECK( test.mSignalVerified );
 438
 439     verified = false;
 440     objectPointer = effect.GetObjectPtr();
 441   }
 442   DALI_TEST_CHECK( test.mSignalVerified );
 443   END_TEST;
 444 }