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 #include <dali/devel-api/actors/mesh-actor.h>
  24 #include <dali/devel-api/geometry/mesh.h>
  25
  26 using namespace Dali;
  27
  28 #include "mesh-builder.h"
  29
  30 namespace
  31 {
  32
  33 // Functors to test whether Object created/destroyed signal is emitted for different types of Objects
  34
  35 struct TestObjectDestroyedCallback
  36 {
  37   TestObjectDestroyedCallback(bool& signalReceived, Dali::RefObject*& objectPointer)
  38   : mSignalVerified(signalReceived),
  39     mObjectPointer(objectPointer)
  40   {
  41   }
  42
  43   void operator()(const Dali::RefObject* objectPointer)
  44   {
  45     tet_infoline("Verifying TestObjectDestroyedCallback()");
  46
  47     if(objectPointer == mObjectPointer)
  48     {
  49       mSignalVerified = true;
  50     }
  51   }
  52
  53   bool& mSignalVerified;
  54   Dali::RefObject*& mObjectPointer;
  55 };
  56
  57 struct TestActorCallback
  58 {
  59   TestActorCallback(bool& signalReceived)
  60   : mSignalVerified(signalReceived)
  61   {
  62   }
  63
  64   void operator()(BaseHandle object)
  65   {
  66     tet_infoline("Verifying TestActorCallback()");
  67     Actor actor = Actor::DownCast(object);
  68     if(actor)
  69     {
  70       mSignalVerified = true;
  71     }
  72   }
  73
  74   bool& mSignalVerified;
  75 };
  76
  77 struct TestCameraActorCallback
  78 {
  79   TestCameraActorCallback(bool& signalReceived)
  80   : mSignalVerified(signalReceived)
  81   {
  82   }
  83   void operator()(BaseHandle object)
  84   {
  85     tet_infoline("Verifying TestCameraActorCallback()");
  86     CameraActor actor = CameraActor::DownCast(object);
  87     if(actor)
  88     {
  89       mSignalVerified = true;
  90     }
  91   }
  92   bool& mSignalVerified;
  93 };
  94
  95 struct TestImageActorCallback
  96 {
  97   TestImageActorCallback(bool& signalReceived)
  98   : mSignalVerified(signalReceived)
  99   {
 100   }
 101   void operator()(BaseHandle object)
 102   {
 103     tet_infoline("Verifying TestImageActorCallback()");
 104     ImageActor actor = ImageActor::DownCast(object);
 105     if(actor)
 106     {
 107       mSignalVerified = true;
 108     }
 109   }
 110   bool& mSignalVerified;
 111 };
 112
 113 struct TestLayerCallback
 114 {
 115   TestLayerCallback(bool& signalReceived)
 116   : mSignalVerified(signalReceived)
 117   {
 118   }
 119   void operator()(BaseHandle object)
 120   {
 121     tet_infoline("Verifying TestLayerCallback()");
 122     Layer actor = Layer::DownCast(object);
 123     if(actor)
 124     {
 125       mSignalVerified = true;
 126     }
 127   }
 128   bool& mSignalVerified;
 129 };
 130
 131
 132 struct TestMeshActorCallback
 133 {
 134   TestMeshActorCallback(bool& signalReceived)
 135   : mSignalVerified(signalReceived)
 136   {
 137   }
 138   void operator()(BaseHandle object)
 139   {
 140     tet_infoline("Verifying TestMeshActorCallback()");
 141     MeshActor actor = MeshActor::DownCast(object);
 142     if(actor)
 143     {
 144       mSignalVerified = true;
 145     }
 146   }
 147   bool& mSignalVerified;
 148 };
 149
 150 struct TestAnimationCallback
 151 {
 152   TestAnimationCallback(bool& signalReceived)
 153   : mSignalVerified(signalReceived)
 154   {
 155   }
 156   void operator()(BaseHandle object)
 157   {
 158     tet_infoline("Verifying TestAnimationCallback()");
 159     Animation actor = Animation::DownCast(object);
 160     if(actor)
 161     {
 162       mSignalVerified = true;
 163     }
 164   }
 165   bool& mSignalVerified;
 166 };
 167
 168 struct TestShaderEffectCallback
 169 {
 170   TestShaderEffectCallback(bool& signalReceived)
 171   : mSignalVerified(signalReceived)
 172   {
 173   }
 174   void operator()(BaseHandle object)
 175   {
 176     tet_infoline("Verifying TestShaderEffectCallback()");
 177     ShaderEffect actor = ShaderEffect::DownCast(object);
 178     if(actor)
 179     {
 180       mSignalVerified = true;
 181     }
 182   }
 183   bool& mSignalVerified;
 184 };
 185
 186
 187 } // anonymous namespace
 188
 189
 190
 191
 192 int UtcDaliObjectRegistryGet(void)
 193 {
 194   TestApplication application;
 195
 196   ObjectRegistry registry; //  like this for ctor code coverage
 197   registry= Stage::GetCurrent().GetObjectRegistry();
 198
 199   DALI_TEST_CHECK( registry );
 200   END_TEST;
 201 }
 202
 203
 204
 205 int UtcDaliObjectRegistrySignalActorCreated(void)
 206 {
 207   tet_infoline("Testing GetObjectRegistry()");
 208   TestApplication application;
 209   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 210   DALI_TEST_CHECK( registry );
 211
 212   bool verified = false;
 213   TestActorCallback test(verified);
 214
 215   Dali::RefObject* objectPointer = NULL;
 216   TestObjectDestroyedCallback test2(verified, objectPointer);
 217
 218   registry.ObjectCreatedSignal().Connect(&application, test);
 219   registry.ObjectDestroyedSignal().Connect(&application, test2);
 220
 221   {
 222     Actor actor = Actor::New();
 223     DALI_TEST_CHECK( test.mSignalVerified );
 224
 225     verified = false;
 226     objectPointer = actor.GetObjectPtr();
 227   }
 228   DALI_TEST_CHECK( test.mSignalVerified );
 229   END_TEST;
 230 }
 231
 232 int UtcDaliObjectRegistrySignalCameraCreated(void)
 233 {
 234   TestApplication application;
 235
 236   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 237
 238   bool verified = false;
 239   TestCameraActorCallback test(verified);
 240
 241   Dali::RefObject* objectPointer = NULL;
 242   TestObjectDestroyedCallback test2(verified, objectPointer);
 243
 244   registry.ObjectCreatedSignal().Connect(&application, test);
 245   registry.ObjectDestroyedSignal().Connect(&application, test2);
 246
 247   {
 248     CameraActor actor = CameraActor::New();
 249     DALI_TEST_CHECK( test.mSignalVerified );
 250
 251     verified = false;
 252     objectPointer = actor.GetObjectPtr();
 253   }
 254   DALI_TEST_CHECK( test.mSignalVerified );
 255   END_TEST;
 256 }
 257
 258 int UtcDaliObjectRegistrySignalImageActorCreated(void)
 259 {
 260   TestApplication application;
 261   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 262
 263   static const char* TestImageFilename = "icon_wrt.png";
 264   Image image = ResourceImage::New(TestImageFilename);
 265
 266   bool verified = false;
 267   TestImageActorCallback test(verified);
 268
 269   Dali::RefObject* objectPointer = NULL;
 270   TestObjectDestroyedCallback test2(verified, objectPointer);
 271
 272   registry.ObjectCreatedSignal().Connect(&application, test);
 273   registry.ObjectDestroyedSignal().Connect(&application, test2);
 274
 275   {
 276     ImageActor actor = ImageActor::New(image);
 277     DALI_TEST_CHECK( test.mSignalVerified );
 278
 279     verified = false;
 280     objectPointer = actor.GetObjectPtr();
 281   }
 282   DALI_TEST_CHECK( test.mSignalVerified );
 283   END_TEST;
 284 }
 285
 286 int UtcDaliObjectRegistrySignalLayerCreated(void)
 287 {
 288   TestApplication application;
 289   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 290
 291   bool verified = false;
 292   TestLayerCallback test(verified);
 293
 294   Dali::RefObject* objectPointer = NULL;
 295   TestObjectDestroyedCallback test2(verified, objectPointer);
 296
 297   registry.ObjectCreatedSignal().Connect(&application, test);
 298   registry.ObjectDestroyedSignal().Connect(&application, test2);
 299
 300   {
 301     Layer actor = Layer::New();
 302     DALI_TEST_CHECK( test.mSignalVerified );
 303
 304     verified = false;
 305     objectPointer = actor.GetObjectPtr();
 306   }
 307   DALI_TEST_CHECK( test.mSignalVerified );
 308   END_TEST;
 309 }
 310
 311
 312 int UtcDaliObjectRegistrySignalMeshActorCreated(void)
 313 {
 314   TestApplication application;
 315   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 316
 317   bool verified = false;
 318   TestMeshActorCallback 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   Mesh mesh = ConstructMesh(60);
 327
 328   {
 329     MeshActor actor = MeshActor::New(mesh);
 330
 331     DALI_TEST_CHECK(actor);
 332     DALI_TEST_CHECK( test.mSignalVerified );
 333
 334     verified = false;
 335     objectPointer = actor.GetObjectPtr();
 336   }
 337   DALI_TEST_CHECK( test.mSignalVerified );
 338   END_TEST;
 339 }
 340
 341
 342 int UtcDaliObjectRegistrySignalAnimationCreated(void)
 343 {
 344   TestApplication application;
 345   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 346
 347   bool verified = false;
 348   TestAnimationCallback test(verified);
 349
 350   Dali::RefObject* objectPointer = NULL;
 351   TestObjectDestroyedCallback test2(verified, objectPointer);
 352
 353   registry.ObjectCreatedSignal().Connect(&application, test);
 354   registry.ObjectDestroyedSignal().Connect(&application, test2);
 355
 356   {
 357     Animation animation = Animation::New(1.0f);
 358     DALI_TEST_CHECK( test.mSignalVerified );
 359
 360     verified = false;
 361     objectPointer = animation.GetObjectPtr();
 362   }
 363   DALI_TEST_CHECK( test.mSignalVerified );
 364   END_TEST;
 365 }
 366
 367 int UtcDaliObjectRegistrySignalShaderEffectCreated(void)
 368 {
 369   TestApplication application;
 370   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 371
 372   static const char* VertexSource =
 373   "void main()\n"
 374   "{\n"
 375   "  gl_Position = uProjection * uModelView * vec4(aPosition, 1.0);\n"
 376   "  vTexCoord = aTexCoord;\n"
 377   "}\n";
 378
 379   static const char* FragmentSource =
 380   "void main()\n"
 381   "{\n"
 382   "  gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n"
 383   "}\n";
 384
 385   bool verified = false;
 386   TestShaderEffectCallback test(verified);
 387
 388   Dali::RefObject* objectPointer = NULL;
 389   TestObjectDestroyedCallback test2(verified, objectPointer);
 390
 391   registry.ObjectCreatedSignal().Connect(&application, test);
 392   registry.ObjectDestroyedSignal().Connect(&application, test2);
 393
 394   {
 395     ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 396     DALI_TEST_CHECK( test.mSignalVerified );
 397
 398     verified = false;
 399     objectPointer = effect.GetObjectPtr();
 400   }
 401   DALI_TEST_CHECK( test.mSignalVerified );
 402   END_TEST;
 403 }