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 int UtcDaliObjectRegistryCopyConstructor(void)
 204 {
 205   TestApplication application;
 206   tet_printf(" copy consturctor ");
 207
 208   ObjectRegistry myRegistry;
 209
 210   ObjectRegistry anotherRegistry( myRegistry );
 211
 212   tet_result( TET_PASS );
 213   END_TEST;
 214 }
 215
 216
 217
 218 int UtcDaliObjectRegistrySignalActorCreated(void)
 219 {
 220   tet_infoline("Testing GetObjectRegistry()");
 221   TestApplication application;
 222   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 223   DALI_TEST_CHECK( registry );
 224
 225   bool verified = false;
 226   TestActorCallback test(verified);
 227
 228   Dali::RefObject* objectPointer = NULL;
 229   TestObjectDestroyedCallback test2(verified, objectPointer);
 230
 231   registry.ObjectCreatedSignal().Connect(&application, test);
 232   registry.ObjectDestroyedSignal().Connect(&application, test2);
 233
 234   {
 235     Actor actor = Actor::New();
 236     DALI_TEST_CHECK( test.mSignalVerified );
 237
 238     verified = false;
 239     objectPointer = actor.GetObjectPtr();
 240   }
 241   DALI_TEST_CHECK( test.mSignalVerified );
 242   END_TEST;
 243 }
 244
 245 int UtcDaliObjectRegistrySignalCameraCreated(void)
 246 {
 247   TestApplication application;
 248
 249   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 250
 251   bool verified = false;
 252   TestCameraActorCallback test(verified);
 253
 254   Dali::RefObject* objectPointer = NULL;
 255   TestObjectDestroyedCallback test2(verified, objectPointer);
 256
 257   registry.ObjectCreatedSignal().Connect(&application, test);
 258   registry.ObjectDestroyedSignal().Connect(&application, test2);
 259
 260   {
 261     CameraActor actor = CameraActor::New();
 262     DALI_TEST_CHECK( test.mSignalVerified );
 263
 264     verified = false;
 265     objectPointer = actor.GetObjectPtr();
 266   }
 267   DALI_TEST_CHECK( test.mSignalVerified );
 268   END_TEST;
 269 }
 270
 271 int UtcDaliObjectRegistrySignalImageActorCreated(void)
 272 {
 273   TestApplication application;
 274   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 275
 276   static const char* TestImageFilename = "icon_wrt.png";
 277   Image image = ResourceImage::New(TestImageFilename);
 278
 279   bool verified = false;
 280   TestImageActorCallback test(verified);
 281
 282   Dali::RefObject* objectPointer = NULL;
 283   TestObjectDestroyedCallback test2(verified, objectPointer);
 284
 285   registry.ObjectCreatedSignal().Connect(&application, test);
 286   registry.ObjectDestroyedSignal().Connect(&application, test2);
 287
 288   {
 289     ImageActor actor = ImageActor::New(image);
 290     DALI_TEST_CHECK( test.mSignalVerified );
 291
 292     verified = false;
 293     objectPointer = actor.GetObjectPtr();
 294   }
 295   DALI_TEST_CHECK( test.mSignalVerified );
 296   END_TEST;
 297 }
 298
 299 int UtcDaliObjectRegistrySignalLayerCreated(void)
 300 {
 301   TestApplication application;
 302   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 303
 304   bool verified = false;
 305   TestLayerCallback test(verified);
 306
 307   Dali::RefObject* objectPointer = NULL;
 308   TestObjectDestroyedCallback test2(verified, objectPointer);
 309
 310   registry.ObjectCreatedSignal().Connect(&application, test);
 311   registry.ObjectDestroyedSignal().Connect(&application, test2);
 312
 313   {
 314     Layer actor = Layer::New();
 315     DALI_TEST_CHECK( test.mSignalVerified );
 316
 317     verified = false;
 318     objectPointer = actor.GetObjectPtr();
 319   }
 320   DALI_TEST_CHECK( test.mSignalVerified );
 321   END_TEST;
 322 }
 323
 324
 325 int UtcDaliObjectRegistrySignalMeshActorCreated(void)
 326 {
 327   TestApplication application;
 328   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 329
 330   bool verified = false;
 331   TestMeshActorCallback test(verified);
 332
 333   Dali::RefObject* objectPointer = NULL;
 334   TestObjectDestroyedCallback test2(verified, objectPointer);
 335
 336   registry.ObjectCreatedSignal().Connect(&application, test);
 337   registry.ObjectDestroyedSignal().Connect(&application, test2);
 338
 339   Mesh mesh = ConstructMesh(60);
 340
 341   {
 342     MeshActor actor = MeshActor::New(mesh);
 343
 344     DALI_TEST_CHECK(actor);
 345     DALI_TEST_CHECK( test.mSignalVerified );
 346
 347     verified = false;
 348     objectPointer = actor.GetObjectPtr();
 349   }
 350   DALI_TEST_CHECK( test.mSignalVerified );
 351   END_TEST;
 352 }
 353
 354
 355 int UtcDaliObjectRegistrySignalAnimationCreated(void)
 356 {
 357   TestApplication application;
 358   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 359
 360   bool verified = false;
 361   TestAnimationCallback test(verified);
 362
 363   Dali::RefObject* objectPointer = NULL;
 364   TestObjectDestroyedCallback test2(verified, objectPointer);
 365
 366   registry.ObjectCreatedSignal().Connect(&application, test);
 367   registry.ObjectDestroyedSignal().Connect(&application, test2);
 368
 369   {
 370     Animation animation = Animation::New(1.0f);
 371     DALI_TEST_CHECK( test.mSignalVerified );
 372
 373     verified = false;
 374     objectPointer = animation.GetObjectPtr();
 375   }
 376   DALI_TEST_CHECK( test.mSignalVerified );
 377   END_TEST;
 378 }
 379
 380 int UtcDaliObjectRegistrySignalShaderEffectCreated(void)
 381 {
 382   TestApplication application;
 383   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 384
 385   static const char* VertexSource =
 386   "void main()\n"
 387   "{\n"
 388   "  gl_Position = uProjection * uModelView * vec4(aPosition, 1.0);\n"
 389   "  vTexCoord = aTexCoord;\n"
 390   "}\n";
 391
 392   static const char* FragmentSource =
 393   "void main()\n"
 394   "{\n"
 395   "  gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n"
 396   "}\n";
 397
 398   bool verified = false;
 399   TestShaderEffectCallback test(verified);
 400
 401   Dali::RefObject* objectPointer = NULL;
 402   TestObjectDestroyedCallback test2(verified, objectPointer);
 403
 404   registry.ObjectCreatedSignal().Connect(&application, test);
 405   registry.ObjectDestroyedSignal().Connect(&application, test2);
 406
 407   {
 408     ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 409     DALI_TEST_CHECK( test.mSignalVerified );
 410
 411     verified = false;
 412     objectPointer = effect.GetObjectPtr();
 413   }
 414   DALI_TEST_CHECK( test.mSignalVerified );
 415   END_TEST;
 416 }