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