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