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 namespace
  27 {
  28
  29 // Functors to test whether Object created/destroyed signal is emitted for different types of Objects
  30
  31 struct TestObjectDestroyedCallback
  32 {
  33   TestObjectDestroyedCallback(bool& signalReceived, Dali::RefObject*& objectPointer)
  34   : mSignalVerified(signalReceived),
  35     mObjectPointer(objectPointer)
  36   {
  37   }
  38
  39   void operator()(const Dali::RefObject* objectPointer)
  40   {
  41     tet_infoline("Verifying TestObjectDestroyedCallback()");
  42
  43     if(objectPointer == mObjectPointer)
  44     {
  45       mSignalVerified = true;
  46     }
  47   }
  48
  49   bool& mSignalVerified;
  50   Dali::RefObject*& mObjectPointer;
  51 };
  52
  53 struct TestActorCallback
  54 {
  55   TestActorCallback(bool& signalReceived)
  56   : mSignalVerified(signalReceived)
  57   {
  58   }
  59
  60   void operator()(BaseHandle object)
  61   {
  62     tet_infoline("Verifying TestActorCallback()");
  63     Actor actor = Actor::DownCast(object);
  64     if(actor)
  65     {
  66       mSignalVerified = true;
  67     }
  68   }
  69
  70   bool& mSignalVerified;
  71 };
  72
  73 struct TestCameraActorCallback
  74 {
  75   TestCameraActorCallback(bool& signalReceived)
  76   : mSignalVerified(signalReceived)
  77   {
  78   }
  79   void operator()(BaseHandle object)
  80   {
  81     tet_infoline("Verifying TestCameraActorCallback()");
  82     CameraActor actor = CameraActor::DownCast(object);
  83     if(actor)
  84     {
  85       mSignalVerified = true;
  86     }
  87   }
  88   bool& mSignalVerified;
  89 };
  90
  91 struct TestLayerCallback
  92 {
  93   TestLayerCallback(bool& signalReceived)
  94   : mSignalVerified(signalReceived)
  95   {
  96   }
  97   void operator()(BaseHandle object)
  98   {
  99     tet_infoline("Verifying TestLayerCallback()");
 100     Layer actor = Layer::DownCast(object);
 101     if(actor)
 102     {
 103       mSignalVerified = true;
 104     }
 105   }
 106   bool& mSignalVerified;
 107 };
 108
 109 struct TestAnimationCallback
 110 {
 111   TestAnimationCallback(bool& signalReceived)
 112   : mSignalVerified(signalReceived)
 113   {
 114   }
 115   void operator()(BaseHandle object)
 116   {
 117     tet_infoline("Verifying TestAnimationCallback()");
 118     Animation actor = Animation::DownCast(object);
 119     if(actor)
 120     {
 121       mSignalVerified = true;
 122     }
 123   }
 124   bool& mSignalVerified;
 125 };
 126
 127 struct TestShaderEffectCallback
 128 {
 129   TestShaderEffectCallback(bool& signalReceived)
 130   : mSignalVerified(signalReceived)
 131   {
 132   }
 133   void operator()(BaseHandle object)
 134   {
 135     tet_infoline("Verifying TestShaderEffectCallback()");
 136     ShaderEffect actor = ShaderEffect::DownCast(object);
 137     if(actor)
 138     {
 139       mSignalVerified = true;
 140     }
 141   }
 142   bool& mSignalVerified;
 143 };
 144
 145
 146 } // anonymous namespace
 147
 148
 149
 150
 151 int UtcDaliObjectRegistryGet(void)
 152 {
 153   TestApplication application;
 154
 155   ObjectRegistry registry; //  like this for ctor code coverage
 156   registry= Stage::GetCurrent().GetObjectRegistry();
 157
 158   DALI_TEST_CHECK( registry );
 159   END_TEST;
 160 }
 161
 162 int UtcDaliObjectRegistryCopyConstructor(void)
 163 {
 164   TestApplication application;
 165
 166   ObjectRegistry myRegistry;
 167   ObjectRegistry anotherRegistry( myRegistry );
 168
 169   DALI_TEST_EQUALS( myRegistry, anotherRegistry, TEST_LOCATION );
 170   END_TEST;
 171 }
 172
 173 int UtcDaliObjectRegistrySignalActorCreated(void)
 174 {
 175   tet_infoline("Testing GetObjectRegistry()");
 176   TestApplication application;
 177   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 178   DALI_TEST_CHECK( registry );
 179
 180   bool verified = false;
 181   TestActorCallback test(verified);
 182
 183   Dali::RefObject* objectPointer = NULL;
 184   TestObjectDestroyedCallback test2(verified, objectPointer);
 185
 186   registry.ObjectCreatedSignal().Connect(&application, test);
 187   registry.ObjectDestroyedSignal().Connect(&application, test2);
 188
 189   {
 190     Actor actor = Actor::New();
 191     DALI_TEST_CHECK( test.mSignalVerified );
 192
 193     verified = false;
 194     objectPointer = actor.GetObjectPtr();
 195   }
 196   DALI_TEST_CHECK( test.mSignalVerified );
 197   END_TEST;
 198 }
 199
 200 int UtcDaliObjectRegistrySignalCameraCreated(void)
 201 {
 202   TestApplication application;
 203
 204   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 205
 206   bool verified = false;
 207   TestCameraActorCallback test(verified);
 208
 209   Dali::RefObject* objectPointer = NULL;
 210   TestObjectDestroyedCallback test2(verified, objectPointer);
 211
 212   registry.ObjectCreatedSignal().Connect(&application, test);
 213   registry.ObjectDestroyedSignal().Connect(&application, test2);
 214
 215   {
 216     CameraActor actor = CameraActor::New();
 217     DALI_TEST_CHECK( test.mSignalVerified );
 218
 219     verified = false;
 220     objectPointer = actor.GetObjectPtr();
 221   }
 222   DALI_TEST_CHECK( test.mSignalVerified );
 223   END_TEST;
 224 }
 225
 226 int UtcDaliObjectRegistrySignalLayerCreated(void)
 227 {
 228   TestApplication application;
 229   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 230
 231   bool verified = false;
 232   TestLayerCallback test(verified);
 233
 234   Dali::RefObject* objectPointer = NULL;
 235   TestObjectDestroyedCallback test2(verified, objectPointer);
 236
 237   registry.ObjectCreatedSignal().Connect(&application, test);
 238   registry.ObjectDestroyedSignal().Connect(&application, test2);
 239
 240   {
 241     Layer actor = Layer::New();
 242     DALI_TEST_CHECK( test.mSignalVerified );
 243
 244     verified = false;
 245     objectPointer = actor.GetObjectPtr();
 246   }
 247   DALI_TEST_CHECK( test.mSignalVerified );
 248   END_TEST;
 249 }
 250
 251 int UtcDaliObjectRegistrySignalAnimationCreated(void)
 252 {
 253   TestApplication application;
 254   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 255
 256   bool verified = false;
 257   TestAnimationCallback test(verified);
 258
 259   Dali::RefObject* objectPointer = NULL;
 260   TestObjectDestroyedCallback test2(verified, objectPointer);
 261
 262   registry.ObjectCreatedSignal().Connect(&application, test);
 263   registry.ObjectDestroyedSignal().Connect(&application, test2);
 264
 265   {
 266     Animation animation = Animation::New(1.0f);
 267     DALI_TEST_CHECK( test.mSignalVerified );
 268
 269     verified = false;
 270     objectPointer = animation.GetObjectPtr();
 271   }
 272   DALI_TEST_CHECK( test.mSignalVerified );
 273   END_TEST;
 274 }
 275
 276 int UtcDaliObjectRegistrySignalShaderEffectCreated(void)
 277 {
 278   TestApplication application;
 279   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 280
 281   static const char* VertexSource =
 282   "void main()\n"
 283   "{\n"
 284   "  gl_Position = uProjection * uModelView * vec4(aPosition, 1.0);\n"
 285   "  vTexCoord = aTexCoord;\n"
 286   "}\n";
 287
 288   static const char* FragmentSource =
 289   "void main()\n"
 290   "{\n"
 291   "  gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n"
 292   "}\n";
 293
 294   bool verified = false;
 295   TestShaderEffectCallback test(verified);
 296
 297   Dali::RefObject* objectPointer = NULL;
 298   TestObjectDestroyedCallback test2(verified, objectPointer);
 299
 300   registry.ObjectCreatedSignal().Connect(&application, test);
 301   registry.ObjectDestroyedSignal().Connect(&application, test2);
 302
 303   {
 304     ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 305     DALI_TEST_CHECK( test.mSignalVerified );
 306
 307     verified = false;
 308     objectPointer = effect.GetObjectPtr();
 309   }
 310   DALI_TEST_CHECK( test.mSignalVerified );
 311   END_TEST;
 312 }