automated-tests/src/dali/utc-Dali-Handle.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/public-api/dali-core.h>
  22 #include "dali-test-suite-utils/dali-test-suite-utils.h"
  23
  24 using namespace Dali;
  25
  26 void handle_test_startup(void)
  27 {
  28   test_return_value = TET_UNDEF;
  29 }
  30
  31 void handle_test_cleanup(void)
  32 {
  33   test_return_value = TET_PASS;
  34 }
  35
  36 namespace
  37 {
  38
  39 /// Allows the creation of a BaseObject
  40 class BaseObjectType : public BaseObject
  41 {
  42 public:
  43   BaseObjectType()
  44   {
  45   }
  46 };
  47
  48 Handle ImplicitCopyConstructor(Handle passedByValue)
  49 {
  50   // object + copy + passedByValue, ref count == 3
  51   DALI_TEST_CHECK(passedByValue);
  52   if (passedByValue)
  53   {
  54     DALI_TEST_EQUALS(3, passedByValue.GetBaseObject().ReferenceCount(), TEST_LOCATION);
  55   }
  56
  57   return passedByValue;
  58 }
  59
  60 void CheckTypeName(const Property::Type& type)
  61 {
  62   switch(type)
  63   {
  64     case Property::NONE:
  65     {
  66       DALI_TEST_CHECK( "NONE" == std::string(PropertyTypes::GetName( type ) ) );
  67       break;
  68     }
  69     case Property::BOOLEAN:
  70     {
  71       DALI_TEST_CHECK( "BOOLEAN" == std::string(PropertyTypes::GetName( type ) ) );
  72       break;
  73     }
  74     case Property::FLOAT:
  75     {
  76       DALI_TEST_CHECK( "FLOAT" == std::string(PropertyTypes::GetName( type ) ) );
  77       break;
  78     }
  79     case Property::INTEGER:
  80     {
  81       DALI_TEST_CHECK( "INTEGER" == std::string(PropertyTypes::GetName( type ) ) );
  82       break;
  83     }
  84     case Property::UNSIGNED_INTEGER:
  85     {
  86       DALI_TEST_CHECK( "UNSIGNED_INTEGER" == std::string(PropertyTypes::GetName( type ) ) );
  87       break;
  88     }
  89     case Property::VECTOR2:
  90     {
  91       DALI_TEST_CHECK( "VECTOR2" == std::string(PropertyTypes::GetName( type ) ) );
  92       break;
  93     }
  94     case Property::VECTOR3:
  95     {
  96       DALI_TEST_CHECK( "VECTOR3" == std::string(PropertyTypes::GetName( type ) ) );
  97       break;
  98     }
  99     case Property::VECTOR4:
 100     {
 101       DALI_TEST_CHECK( "VECTOR4" == std::string(PropertyTypes::GetName( type ) ) );
 102       break;
 103     }
 104     case Property::MATRIX3:
 105     {
 106       DALI_TEST_CHECK( "MATRIX3" == std::string(PropertyTypes::GetName( type  ) ) );
 107       break;
 108     }
 109     case Property::MATRIX:
 110     {
 111       DALI_TEST_CHECK( "MATRIX" == std::string(PropertyTypes::GetName( type ) ) );
 112       break;
 113     }
 114     case Property::RECTANGLE:
 115     {
 116       DALI_TEST_CHECK( "RECTANGLE" == std::string(PropertyTypes::GetName( type ) ) );
 117       break;
 118     }
 119     case Property::ROTATION:
 120     {
 121       DALI_TEST_CHECK( "ROTATION" == std::string(PropertyTypes::GetName( type ) ) );
 122       break;
 123     }
 124     case Property::STRING:
 125     {
 126       DALI_TEST_CHECK( "STRING" == std::string(PropertyTypes::GetName( type ) ) );
 127       break;
 128     }
 129     case Property::ARRAY:
 130     {
 131       DALI_TEST_CHECK( "ARRAY" == std::string(PropertyTypes::GetName( type ) ) );
 132       break;
 133     }
 134     case Property::MAP:
 135     {
 136       DALI_TEST_CHECK( "MAP" == std::string(PropertyTypes::GetName( type ) ) );
 137       break;
 138     }
 139     case Property::TYPE_COUNT:
 140     {
 141       DALI_TEST_CHECK( "NONE" == std::string(PropertyTypes::GetName( type ) ) );
 142       break;
 143     }
 144   } // switch(type)
 145
 146 } // CheckTypeName
 147
 148 } // anon namespace
 149
 150
 151 int UtcDaliHandleConstructorVoid(void)
 152 {
 153   TestApplication application;
 154   tet_infoline("Testing Dali::Handle::Handle()");
 155
 156   Handle object;
 157
 158   DALI_TEST_CHECK(!object);
 159   END_TEST;
 160 }
 161
 162 int UtcDaliHandleCopyConstructor(void)
 163 {
 164   TestApplication application;
 165   tet_infoline("Testing Dali::Handle::Handle(const Handle&)");
 166
 167   // Initialize an object, ref count == 1
 168   Handle object = Actor::New();
 169
 170   DALI_TEST_EQUALS(1, object.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 171
 172   // Copy the object, ref count == 2
 173   Handle copy(object);
 174   DALI_TEST_CHECK(copy);
 175   if (copy)
 176   {
 177     DALI_TEST_EQUALS(2, copy.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 178   }
 179
 180   {
 181     // Pass by value, and return another copy, ref count == 3
 182     Handle anotherCopy = ImplicitCopyConstructor(copy);
 183
 184     DALI_TEST_CHECK(anotherCopy);
 185     if (anotherCopy)
 186     {
 187       DALI_TEST_EQUALS(3, anotherCopy.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 188     }
 189   }
 190
 191   // anotherCopy out of scope, ref count == 2
 192   DALI_TEST_CHECK(copy);
 193   if (copy)
 194   {
 195     DALI_TEST_EQUALS(2, copy.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 196   }
 197   END_TEST;
 198 }
 199
 200 int UtcDaliHandleAssignmentOperator(void)
 201 {
 202   TestApplication application;
 203   tet_infoline("Testing Dali::Handle::operator=");
 204
 205   Handle object = Actor::New();
 206
 207   DALI_TEST_CHECK(object);
 208   DALI_TEST_EQUALS(1, object.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 209
 210   Handle copy;
 211   DALI_TEST_CHECK(!copy);
 212
 213   copy = object;
 214   DALI_TEST_CHECK(copy);
 215   DALI_TEST_EQUALS(2, copy.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 216   DALI_TEST_CHECK(&(copy.GetBaseObject()) == &(object.GetBaseObject()));
 217   END_TEST;
 218 }
 219
 220 int UtcDaliHandleSupports(void)
 221 {
 222   tet_infoline("Positive Test Dali::Handle::Supports()");
 223   TestApplication application;
 224
 225   Actor actor = Actor::New();
 226   DALI_TEST_CHECK( true == actor.Supports( Handle::DYNAMIC_PROPERTIES ) );
 227   END_TEST;
 228 }
 229
 230 int UtcDaliHandleGetPropertyCount(void)
 231 {
 232   tet_infoline("Positive Test Dali::Handle::GetPropertyCount()");
 233   TestApplication application;
 234
 235   Actor actor = Actor::New();
 236   int defaultPropertyCount( actor.GetPropertyCount() );
 237
 238   // Register a dynamic property
 239   actor.RegisterProperty( "test-property", float(123.0f) );
 240   DALI_TEST_CHECK( (defaultPropertyCount + 1u) == actor.GetPropertyCount() );
 241   END_TEST;
 242 }
 243
 244 int UtcDaliHandleGetPropertyName(void)
 245 {
 246   tet_infoline("Positive Test Dali::Handle::GetPropertyName()");
 247   TestApplication application;
 248
 249   Actor actor = Actor::New();
 250   DALI_TEST_CHECK( "parent-origin" == actor.GetPropertyName( Actor::PARENT_ORIGIN ) );
 251
 252   // Register a dynamic property
 253   std::string name("this-name-should-match");
 254   Property::Index index = actor.RegisterProperty( name, float(123.0f) );
 255   DALI_TEST_CHECK( name == actor.GetPropertyName( index ) );
 256
 257   END_TEST;
 258 }
 259
 260 int UtcDaliHandleGetPropertyIndex(void)
 261 {
 262   tet_infoline("Positive Test Dali::Handle::GetPropertyIndex()");
 263   TestApplication application;
 264
 265   Actor actor = Actor::New();
 266   DALI_TEST_CHECK( Actor::PARENT_ORIGIN == actor.GetPropertyIndex("parent-origin") );
 267
 268   // Register a dynamic property
 269   std::string name("this-name-should-match");
 270   Property::Index index = actor.RegisterProperty( name, float(123.0f) );
 271   DALI_TEST_CHECK( index == actor.GetPropertyIndex( name ) );
 272   END_TEST;
 273 }
 274
 275 int UtcDaliHandleIsPropertyWritable(void)
 276 {
 277   tet_infoline("Positive Test Dali::Handle::IsPropertyWritable()");
 278   TestApplication application;
 279
 280   Actor actor = Actor::New();
 281
 282   // Actor properties which are writable:
 283   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::PARENT_ORIGIN ) );
 284   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::PARENT_ORIGIN_X ) );
 285   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::PARENT_ORIGIN_Y ) );
 286   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::PARENT_ORIGIN_Z ) );
 287   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::ANCHOR_POINT ) );
 288   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::ANCHOR_POINT_X ) );
 289   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::ANCHOR_POINT_Y ) );
 290   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::ANCHOR_POINT_Z ) );
 291   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::SIZE ) );
 292   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::SIZE_WIDTH  ) );
 293   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::SIZE_HEIGHT ) );
 294   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::SIZE_DEPTH  ) );
 295   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::POSITION ) );
 296   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::POSITION_X ) );
 297   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::POSITION_Y ) );
 298   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::POSITION_Z ) );
 299   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::ROTATION ) );
 300   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::SCALE ) );
 301   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::SCALE_X ) );
 302   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::SCALE_Y ) );
 303   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::SCALE_Z ) );
 304   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::VISIBLE ) );
 305   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::COLOR ) );
 306   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::COLOR_RED ) );
 307   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::COLOR_GREEN ) );
 308   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::COLOR_BLUE ) );
 309   DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::COLOR_ALPHA ) );
 310
 311   // World-properties are not writable:
 312   DALI_TEST_CHECK( false == actor.IsPropertyWritable( Actor::WORLD_POSITION ) );
 313   DALI_TEST_CHECK( false == actor.IsPropertyWritable( Actor::WORLD_ROTATION ) );
 314   DALI_TEST_CHECK( false == actor.IsPropertyWritable( Actor::WORLD_SCALE ) );
 315   DALI_TEST_CHECK( false == actor.IsPropertyWritable( Actor::WORLD_COLOR ) );
 316   DALI_TEST_CHECK( false == actor.IsPropertyWritable( Actor::WORLD_POSITION_X ) );
 317   DALI_TEST_CHECK( false == actor.IsPropertyWritable( Actor::WORLD_POSITION_Y ) );
 318   DALI_TEST_CHECK( false == actor.IsPropertyWritable( Actor::WORLD_POSITION_Z ) );
 319
 320   END_TEST;
 321 }
 322
 323 int UtcDaliHandleIsPropertyAnimatable(void)
 324 {
 325   tet_infoline("Positive Test Dali::Handle::IsPropertyAnimatable()");
 326   TestApplication application;
 327
 328   Actor actor = Actor::New();
 329
 330   // Actor properties which are animatable:
 331   DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::PARENT_ORIGIN ) );
 332   DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::PARENT_ORIGIN_X ) );
 333   DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::PARENT_ORIGIN_Y ) );
 334   DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::PARENT_ORIGIN_Z ) );
 335   DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::ANCHOR_POINT ) );
 336   DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::ANCHOR_POINT_X ) );
 337   DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::ANCHOR_POINT_Y ) );
 338   DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::ANCHOR_POINT_Z ) );
 339   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::SIZE ) );
 340   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::SIZE_WIDTH  ) );
 341   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::SIZE_HEIGHT ) );
 342   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::SIZE_DEPTH  ) );
 343   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::POSITION ) );
 344   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::POSITION_X ) );
 345   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::POSITION_Y ) );
 346   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::POSITION_Z ) );
 347   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::ROTATION ) );
 348   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::SCALE ) );
 349   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::SCALE_X ) );
 350   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::SCALE_Y ) );
 351   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::SCALE_Z ) );
 352   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::VISIBLE ) );
 353   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::COLOR ) );
 354   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::COLOR_RED ) );
 355   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::COLOR_GREEN ) );
 356   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::COLOR_BLUE ) );
 357   DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::COLOR_ALPHA ) );
 358
 359   // World-properties can not be animated
 360   DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::WORLD_POSITION ) );
 361   DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::WORLD_ROTATION ) );
 362   DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::WORLD_SCALE ) );
 363   DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::WORLD_COLOR ) );
 364   DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::WORLD_POSITION_X ) );
 365   DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::WORLD_POSITION_Y ) );
 366   DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::WORLD_POSITION_Z ) );
 367
 368   END_TEST;
 369 }
 370
 371 int UtcDaliHandleIsPropertyAConstraintInput(void)
 372 {
 373   TestApplication application;
 374
 375   Actor actor = Actor::New();
 376
 377   // Actor properties which can be used as a constraint input:
 378   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::PARENT_ORIGIN ) );
 379   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::PARENT_ORIGIN_X ) );
 380   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::PARENT_ORIGIN_Y ) );
 381   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::PARENT_ORIGIN_Z ) );
 382   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::ANCHOR_POINT ) );
 383   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::ANCHOR_POINT_X ) );
 384   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::ANCHOR_POINT_Y ) );
 385   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::ANCHOR_POINT_Z ) );
 386   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::SIZE ) );
 387   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::SIZE_WIDTH  ) );
 388   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::SIZE_HEIGHT ) );
 389   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::SIZE_DEPTH  ) );
 390   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::POSITION ) );
 391   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::POSITION_X ) );
 392   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::POSITION_Y ) );
 393   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::POSITION_Z ) );
 394   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::ROTATION ) );
 395   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::SCALE ) );
 396   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::SCALE_X ) );
 397   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::SCALE_Y ) );
 398   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::SCALE_Z ) );
 399   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::VISIBLE ) );
 400   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::COLOR ) );
 401   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::COLOR_RED ) );
 402   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::COLOR_GREEN ) );
 403   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::COLOR_BLUE ) );
 404   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::COLOR_ALPHA ) );
 405   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::WORLD_POSITION ) );
 406   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::WORLD_ROTATION ) );
 407   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::WORLD_SCALE ) );
 408   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::WORLD_COLOR ) );
 409   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::WORLD_POSITION_X ) );
 410   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::WORLD_POSITION_Y ) );
 411   DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::WORLD_POSITION_Z ) );
 412
 413   // Actor properties that cannot be used as a constraint input
 414   DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::NAME ) );
 415   DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::SENSITIVE ) );
 416   DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::LEAVE_REQUIRED ) );
 417   DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::INHERIT_ROTATION ) );
 418   DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::INHERIT_SCALE ) );
 419   DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::COLOR_MODE ) );
 420   DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::POSITION_INHERITANCE ) );
 421   DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::DRAW_MODE ) );
 422   DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::SIZE_MODE ) );
 423   DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::SIZE_MODE_FACTOR ) );
 424
 425   END_TEST;
 426 }
 427
 428
 429 int UtcDaliHandleGetPropertyType(void)
 430 {
 431   tet_infoline("Positive Test Dali::Handle::GetPropertyType()");
 432   TestApplication application;
 433   unsigned int unsingedIntTest = 33;
 434
 435   Actor actor = Actor::New();
 436   DALI_TEST_CHECK( Property::VECTOR3  == actor.GetPropertyType( Actor::PARENT_ORIGIN ) );
 437   DALI_TEST_CHECK( Property::VECTOR3  == actor.GetPropertyType( Actor::ANCHOR_POINT ) );
 438   DALI_TEST_CHECK( Property::VECTOR3  == actor.GetPropertyType( Actor::SIZE ) );
 439   DALI_TEST_CHECK( Property::VECTOR3  == actor.GetPropertyType( Actor::POSITION ) );
 440   DALI_TEST_CHECK( Property::ROTATION == actor.GetPropertyType( Actor::ROTATION ) );
 441   DALI_TEST_CHECK( Property::VECTOR3  == actor.GetPropertyType( Actor::SCALE ) );
 442   DALI_TEST_CHECK( Property::BOOLEAN  == actor.GetPropertyType( Actor::VISIBLE ) );
 443   DALI_TEST_CHECK( Property::VECTOR4  == actor.GetPropertyType( Actor::COLOR ) );
 444
 445   // Register some dynamic properties
 446   Property::Index boolIndex     = actor.RegisterProperty( "bool-property",     bool(true) );
 447   Property::Index floatIndex    = actor.RegisterProperty( "float-property",    float(123.0f) );
 448   Property::Index intIndex      = actor.RegisterProperty( "int-property",      123 );
 449   Property::Index vector2Index  = actor.RegisterProperty( "vector2-property",  Vector2(1.0f, 2.0f) );
 450   Property::Index vector3Index  = actor.RegisterProperty( "vector3-property",  Vector3(1.0f, 2.0f, 3.0f) );
 451   Property::Index vector4Index  = actor.RegisterProperty( "vector4-property",  Vector4(1.0f, 2.0f, 3.0f, 4.0f) );
 452   Property::Index rotationIndex = actor.RegisterProperty( "rotation-property", AngleAxis(Degree(180.0f), Vector3::YAXIS) );
 453
 454   DALI_TEST_CHECK( Property::BOOLEAN  == actor.GetPropertyType( boolIndex ) );
 455   DALI_TEST_CHECK( Property::FLOAT    == actor.GetPropertyType( floatIndex ) );
 456   DALI_TEST_CHECK( Property::INTEGER  == actor.GetPropertyType( intIndex ) );
 457   DALI_TEST_CHECK( Property::VECTOR2  == actor.GetPropertyType( vector2Index ) );
 458   DALI_TEST_CHECK( Property::VECTOR3  == actor.GetPropertyType( vector3Index ) );
 459   DALI_TEST_CHECK( Property::VECTOR4  == actor.GetPropertyType( vector4Index ) );
 460   DALI_TEST_CHECK( Property::ROTATION == actor.GetPropertyType( rotationIndex ) );
 461
 462   // Non animatable properties
 463   Property::Index nonAnimStringIndex = actor.RegisterProperty( "man-from-delmonte", std::string("yes"), Property::READ_WRITE);
 464   Property::Index nonAnimV2Index = actor.RegisterProperty( "v2", Vector2(1.f, 2.f), Property::READ_WRITE);
 465   Property::Index nonAnimV3Index = actor.RegisterProperty( "v3", Vector3(1.f, 2.f, 3.f), Property::READ_WRITE);
 466   Property::Index nonAnimV4Index = actor.RegisterProperty( "v4", Vector4(1.f, 2.f, 3.f, 4.f), Property::READ_WRITE);
 467   Property::Index nonAnimBooleanIndex = actor.RegisterProperty( "bool", true, Property::READ_WRITE);
 468   Property::Index nonAnimFloatIndex = actor.RegisterProperty( "float", 0.f, Property::READ_WRITE);
 469   Property::Index nonAnimIntegerIndex = actor.RegisterProperty( "int", 0, Property::READ_WRITE);
 470   Property::Index nonAnimUnsignedIntIndex = actor.RegisterProperty( "unsinged-int", unsingedIntTest, Property::READ_WRITE);
 471
 472   DALI_TEST_CHECK( nonAnimStringIndex  != Property::INVALID_INDEX );
 473   DALI_TEST_CHECK( nonAnimV2Index      != Property::INVALID_INDEX );
 474   DALI_TEST_CHECK( nonAnimV3Index      != Property::INVALID_INDEX );
 475   DALI_TEST_CHECK( nonAnimV4Index      != Property::INVALID_INDEX );
 476   DALI_TEST_CHECK( nonAnimBooleanIndex != Property::INVALID_INDEX );
 477   DALI_TEST_CHECK( nonAnimFloatIndex   != Property::INVALID_INDEX );
 478   DALI_TEST_CHECK( nonAnimIntegerIndex != Property::INVALID_INDEX );
 479   DALI_TEST_CHECK( nonAnimUnsignedIntIndex != Property::INVALID_INDEX );
 480
 481   DALI_TEST_CHECK( Property::STRING   == actor.GetPropertyType( nonAnimStringIndex ) );
 482   DALI_TEST_CHECK( Property::VECTOR2  == actor.GetPropertyType( nonAnimV2Index ) );
 483   DALI_TEST_CHECK( Property::VECTOR3  == actor.GetPropertyType( nonAnimV3Index ) );
 484   DALI_TEST_CHECK( Property::VECTOR4  == actor.GetPropertyType( nonAnimV4Index ) );
 485   DALI_TEST_CHECK( Property::BOOLEAN  == actor.GetPropertyType( nonAnimBooleanIndex ) );
 486   DALI_TEST_CHECK( Property::FLOAT    == actor.GetPropertyType( nonAnimFloatIndex ) );
 487   DALI_TEST_CHECK( Property::INTEGER  == actor.GetPropertyType( nonAnimIntegerIndex ) );
 488   DALI_TEST_CHECK( Property::UNSIGNED_INTEGER == actor.GetPropertyType( nonAnimUnsignedIntIndex ) );
 489
 490   DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimStringIndex ) );
 491   DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimV2Index ) );
 492   DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimV3Index ) );
 493   DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimV4Index ) );
 494   DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimBooleanIndex ) );
 495   DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimFloatIndex ) );
 496   DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimIntegerIndex ) );
 497   DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimUnsignedIntIndex ) );
 498
 499   DALI_TEST_EQUALS( "yes" , actor.GetProperty( nonAnimStringIndex ).Get<std::string>(), TEST_LOCATION );
 500   DALI_TEST_EQUALS( Vector2(1.f, 2.f) , actor.GetProperty( nonAnimV2Index ).Get<Vector2>(), TEST_LOCATION );
 501   DALI_TEST_EQUALS( Vector3(1.f, 2.f, 3.f) , actor.GetProperty( nonAnimV3Index ).Get<Vector3>(), TEST_LOCATION );
 502   DALI_TEST_EQUALS( Vector4(1.f, 2.f, 3.f, 4.f) , actor.GetProperty( nonAnimV4Index ).Get<Vector4>(), TEST_LOCATION );
 503   DALI_TEST_EQUALS( true, actor.GetProperty( nonAnimBooleanIndex ).Get<bool>(), TEST_LOCATION );
 504   DALI_TEST_EQUALS( 0.f, actor.GetProperty( nonAnimFloatIndex ).Get<float>(), TEST_LOCATION );
 505   DALI_TEST_EQUALS( 0, actor.GetProperty( nonAnimIntegerIndex ).Get<int>(), TEST_LOCATION );
 506   DALI_TEST_EQUALS( unsingedIntTest, actor.GetProperty( nonAnimUnsignedIntIndex ).Get<unsigned int>(), TEST_LOCATION );
 507
 508   END_TEST;
 509 }
 510
 511 int UtcDaliHandleNonAnimtableProperties(void)
 512 {
 513   tet_infoline("Test Non Animatable Properties");
 514   TestApplication application;
 515
 516   Actor actor = Actor::New();
 517
 518   Property::Index nonAnimStringIndex = actor.RegisterProperty( "man-from-delmonte", std::string("no"), Property::READ_WRITE);
 519
 520   //// modify writable?
 521   try
 522   {
 523     actor.SetProperty( nonAnimStringIndex, Property::Value("yes") );
 524   }
 525   catch (Dali::DaliException& e)
 526   {
 527     DALI_TEST_CHECK(!"exception");
 528   }
 529
 530   DALI_TEST_CHECK( "yes"  == actor.GetProperty( nonAnimStringIndex ).Get<std::string>() );
 531
 532   //// cannot modify read only?
 533   Property::Index readonly = actor.RegisterProperty( "float", 0.f, Property::READ_ONLY);
 534
 535   DALI_TEST_CHECK(!actor.IsPropertyAnimatable(readonly));
 536   DALI_TEST_CHECK(!actor.IsPropertyWritable(readonly));
 537
 538   bool exception = false;
 539   try
 540   {
 541     actor.SetProperty( readonly, Property::Value(1.f) );
 542   }
 543   catch (Dali::DaliException& e)
 544   {
 545     exception = true;
 546   }
 547
 548   DALI_TEST_CHECK(!exception);// trying to set a read-only property is a no-op
 549
 550   DALI_TEST_EQUALS( 0.f, actor.GetProperty( readonly ).Get<float>(), TEST_LOCATION );
 551
 552   /// animatable can be set
 553   Property::Index write_anim = actor.RegisterProperty( "write_float", 0.f, Property::ANIMATABLE);
 554
 555   DALI_TEST_CHECK(actor.IsPropertyAnimatable(write_anim));
 556   DALI_TEST_CHECK(actor.IsPropertyWritable(write_anim));
 557
 558   exception = false;
 559   try
 560   {
 561     actor.SetProperty( write_anim, Property::Value(1.f) );
 562   }
 563   catch (Dali::DaliException& e)
 564   {
 565     exception = true;
 566   }
 567
 568   DALI_TEST_CHECK(!exception);
 569
 570   //// animate a non animatable property is a noop?
 571   float durationSeconds(2.0f);
 572   Animation animation = Animation::New(durationSeconds);
 573   bool relativeValue(true);
 574
 575   exception = false;
 576
 577   try
 578   {
 579     animation.AnimateBy(Property(actor, nonAnimStringIndex), relativeValue, AlphaFunctions::EaseIn);
 580     animation.Play();
 581     application.SendNotification();
 582     application.Render(static_cast<unsigned int>(durationSeconds*0100.0f)/* some progress */);
 583   }
 584   catch (Dali::DaliException& e)
 585   {
 586     exception = true;
 587   }
 588
 589   DALI_TEST_CHECK(!exception);
 590   DALI_TEST_EQUALS( "yes", actor.GetProperty( nonAnimStringIndex ).Get<std::string>(), TEST_LOCATION );
 591
 592   END_TEST;
 593 }
 594
 595 int UtcDaliHandleNonAnimtableCompositeProperties(void)
 596 {
 597   tet_infoline("Test Non Animatable Composite Properties");
 598   TestApplication application;
 599
 600   Actor actor = Actor::New();
 601
 602   Property::Value value(Property::ARRAY);
 603   Property::Array anArray;
 604   DALI_TEST_CHECK( Property::Value(anArray).GetType() == Property::ARRAY ); // 2nd constructor
 605
 606   value.AppendItem( Property::Value( 0.f ) );
 607   value.AppendItem( "a string" );
 608   value.SetItem(0, Property::Value( 5.f )); // exercise SetItem
 609
 610   int index = value.AppendItem( Vector3(1,2,3) );
 611
 612   DALI_TEST_EQUALS( 2, index, TEST_LOCATION);
 613   DALI_TEST_EQUALS( 3, value.GetSize(), TEST_LOCATION);
 614
 615   Property::Index propertyIndex = actor.RegisterProperty( "composite", value, Property::READ_WRITE);
 616
 617   Property::Value out = actor.GetProperty( propertyIndex );
 618
 619   DALI_TEST_CHECK( Property::FLOAT     == out.GetItem(0).GetType());
 620   DALI_TEST_CHECK( Property::STRING    == out.GetItem(1).GetType());
 621   DALI_TEST_CHECK( Property::VECTOR3   == out.GetItem(2).GetType());
 622
 623   DALI_TEST_EQUALS( 5.f,            out.GetItem(0).Get<float>(),        TEST_LOCATION);
 624   DALI_TEST_EQUALS( "a string",     out.GetItem(1).Get<std::string>(),  TEST_LOCATION);
 625   DALI_TEST_EQUALS( Vector3(1,2,3), out.GetItem(2).Get<Vector3>(),      TEST_LOCATION);
 626
 627   // Property Maps
 628   Property::Value valueMap(Property::MAP);
 629   Property::Map aKindofMap;
 630   DALI_TEST_CHECK( Property::Value(aKindofMap).GetType() == Property::MAP ); // 2nd constructor
 631
 632   valueMap.SetValue("key", 5.f);
 633   valueMap.SetValue("2key", "a string");
 634
 635   DALI_TEST_EQUALS( true, valueMap.HasKey("key"),        TEST_LOCATION);
 636   DALI_TEST_EQUALS( "key", valueMap.GetKey(0),           TEST_LOCATION);
 637
 638   DALI_TEST_EQUALS( true, valueMap.HasKey("2key"),       TEST_LOCATION);
 639   DALI_TEST_EQUALS( "2key", valueMap.GetKey(1),          TEST_LOCATION);
 640
 641   DALI_TEST_EQUALS( 5.f,         valueMap.GetValue("key").Get<float>(),         TEST_LOCATION);
 642   DALI_TEST_EQUALS( "a string",  valueMap.GetValue("2key").Get<std::string>(),  TEST_LOCATION);
 643
 644   valueMap.SetItem(0, Property::Value("a string"));
 645   valueMap.SetItem(1, Property::Value(5.f));
 646
 647   DALI_TEST_EQUALS( 5.f,         valueMap.GetValue("2key").Get<float>(),        TEST_LOCATION);
 648   DALI_TEST_EQUALS( "a string",  valueMap.GetValue("key").Get<std::string>(),   TEST_LOCATION);
 649
 650   // ordered map
 651   valueMap = Property::Value(Property::MAP);
 652
 653   valueMap.SetValue("key", 5.f);
 654   valueMap.SetValue("2key", "a string");
 655
 656   DALI_TEST_EQUALS( 5.f,         valueMap.GetItem(0).Get<float>(),         TEST_LOCATION);
 657   DALI_TEST_EQUALS( "a string",  valueMap.GetItem(1).Get<std::string>(),   TEST_LOCATION);
 658
 659   DALI_TEST_EQUALS( 2, valueMap.GetSize(), TEST_LOCATION);
 660
 661   // composite types not animatable
 662   bool exception = false;
 663   try
 664   {
 665     /* Property::Index mapPropertyIndex = */ actor.RegisterProperty( "compositemap", value, Property::ANIMATABLE);
 666   }
 667   catch (Dali::DaliException& e)
 668   {
 669     exception = true;
 670     DALI_TEST_PRINT_ASSERT( e );
 671   }
 672
 673   DALI_TEST_EQUALS(exception, true, TEST_LOCATION);
 674
 675   // Map of maps
 676   Property::Value mapOfMaps(Property::MAP);
 677
 678   mapOfMaps.SetValue( "key", Property::Value(Property::MAP) );
 679   mapOfMaps.SetValue( "2key", "a string" );
 680
 681   DALI_TEST_EQUALS( "a string",  mapOfMaps.GetValue("2key").Get<std::string>(),  TEST_LOCATION);
 682
 683   mapOfMaps.GetValue("key").SetValue("subkey", 5.f);
 684
 685   DALI_TEST_EQUALS( true, mapOfMaps.GetValue("key").HasKey("subkey"), TEST_LOCATION);
 686   DALI_TEST_EQUALS( 5.f, mapOfMaps.GetValue("key").GetValue("subkey").Get<float>(), TEST_LOCATION);
 687
 688   // list of maps
 689   Property::Value listOfMaps(Property::ARRAY);
 690
 691   listOfMaps.AppendItem( Property::Value(Property::MAP) );
 692   listOfMaps.AppendItem( Property::Value(Property::MAP) );
 693
 694   listOfMaps.GetItem(0).SetValue("key", 5.f);
 695   listOfMaps.GetItem(1).SetValue("key",10.f);
 696
 697   DALI_TEST_EQUALS( 5.f, listOfMaps.GetItem(0).GetValue("key").Get<float>(), TEST_LOCATION );
 698   DALI_TEST_EQUALS( 10.f, listOfMaps.GetItem(1).GetValue("key").Get<float>(), TEST_LOCATION );
 699
 700   END_TEST;
 701 }
 702
 703 int UtcDaliHandleSetProperty01(void)
 704 {
 705   tet_infoline("Positive Test Dali::Handle::SetProperty()");
 706   TestApplication application;
 707
 708   Actor actor = Actor::New();
 709   DALI_TEST_CHECK( ParentOrigin::TOP_LEFT == actor.GetProperty( Actor::PARENT_ORIGIN ).Get<Vector3>() );
 710
 711   actor.SetProperty( Actor::PARENT_ORIGIN, ParentOrigin::CENTER );
 712   // flush the queue and render once
 713   application.SendNotification();
 714   application.Render();
 715   DALI_TEST_CHECK( ParentOrigin::CENTER == actor.GetProperty( Actor::PARENT_ORIGIN ).Get<Vector3>() );
 716   END_TEST;
 717 }
 718
 719 int UtcDaliHandleSetProperty02(void)
 720 {
 721   tet_infoline("Positive Test Dali::Handle::SetProperty()");
 722   TestApplication application;
 723
 724   Actor actor = Actor::New();
 725
 726   DALI_TEST_CHECK( !actor.IsPropertyWritable( Actor::WORLD_POSITION ) );
 727
 728   // World position is not writable so this is a no-op and should not crash
 729   actor.SetProperty( Actor::WORLD_POSITION, Vector3(1,2,3) );
 730
 731   END_TEST;
 732 }
 733
 734 int UtcDaliHandleRegisterProperty(void)
 735 {
 736   tet_infoline("Positive Test Dali::Handle::RegisterProperty()");
 737   TestApplication application;
 738
 739   Actor actor = Actor::New();
 740   DALI_TEST_CHECK( ParentOrigin::TOP_LEFT == actor.GetProperty( Actor::PARENT_ORIGIN ).Get<Vector3>() );
 741
 742   END_TEST;
 743 }
 744
 745 int UtcDaliHandleGetProperty(void)
 746 {
 747   tet_infoline("Positive Test Dali::Handle::GetProperty()");
 748   TestApplication application;
 749
 750   Actor actor = Actor::New();
 751
 752   DALI_TEST_CHECK( ParentOrigin::TOP_LEFT == actor.GetProperty( Actor::PARENT_ORIGIN   ).Get<Vector3>() );
 753   DALI_TEST_CHECK( AnchorPoint::CENTER    == actor.GetProperty( Actor::ANCHOR_POINT    ).Get<Vector3>() );
 754   DALI_TEST_CHECK( Vector3::ZERO          == actor.GetProperty( Actor::SIZE            ).Get<Vector3>() );
 755   DALI_TEST_CHECK( Vector3::ZERO          == actor.GetProperty( Actor::POSITION        ).Get<Vector3>() );
 756   DALI_TEST_CHECK( Vector3::ONE           == actor.GetProperty( Actor::SCALE           ).Get<Vector3>() );
 757   DALI_TEST_CHECK( true                   == actor.GetProperty( Actor::VISIBLE         ).Get<bool>() );
 758   DALI_TEST_CHECK( Color::WHITE           == actor.GetProperty( Actor::COLOR           ).Get<Vector4>() );
 759   END_TEST;
 760 }
 761
 762 int UtcDaliHandleDownCast(void)
 763 {
 764   TestApplication application;
 765   tet_infoline("Testing Dali::Handle::DownCast()");
 766
 767   Actor actor = Actor::New();
 768
 769   BaseHandle baseHandle = actor;
 770
 771   Handle handle = Handle::DownCast(baseHandle);
 772
 773   DALI_TEST_CHECK( handle );
 774
 775   baseHandle = BaseHandle();
 776
 777   handle = Handle::DownCast(baseHandle);
 778
 779   DALI_TEST_CHECK( !handle );
 780
 781   END_TEST;
 782 }
 783
 784 int UtcDaliHandleDownCastNegative(void)
 785 {
 786   TestApplication application;
 787
 788   // BaseObject is NOT an Object, so this DownCast should fail
 789   BaseHandle handle( new BaseObjectType );
 790   Handle customHandle1 = Handle::DownCast( handle );
 791   DALI_TEST_CHECK( ! customHandle1 );
 792
 793   // A DownCast on an empty handle will also fail
 794   Handle empty;
 795   Handle customHandle2 = Handle::DownCast( empty );
 796   DALI_TEST_CHECK( ! customHandle2 );
 797   END_TEST;
 798 }
 799
 800 int UtcDaliHandleCreateProperty(void)
 801 {
 802   TestApplication application;
 803   tet_infoline("Testing PropertyTypes::GetName()");
 804
 805   Property::Type type = Property::NONE;
 806   CheckTypeName(type);
 807   // Value(Value&) ctor and Value(Type&) ctor
 808   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 809   DALI_TEST_CHECK( Property::NONE == type );
 810
 811   // PropertyTypes
 812   type = Property::BOOLEAN;
 813   CheckTypeName(type);
 814   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 815   DALI_TEST_CHECK( PropertyTypes::Get<bool>()            == type );
 816
 817   type = Property::FLOAT;
 818   CheckTypeName(type);
 819   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 820   DALI_TEST_CHECK( PropertyTypes::Get<float>()           == type );
 821
 822   type = Property::INTEGER;
 823   CheckTypeName(type);
 824   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 825   DALI_TEST_CHECK( PropertyTypes::Get<int>()             == type );
 826
 827   type = Property::UNSIGNED_INTEGER;
 828   CheckTypeName(type);
 829   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 830   DALI_TEST_CHECK( PropertyTypes::Get<unsigned int>()    == type );
 831
 832   type = Property::VECTOR2;
 833   CheckTypeName(type);
 834   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 835   DALI_TEST_CHECK( PropertyTypes::Get<Vector2>()         == type );
 836
 837   type = Property::VECTOR3;
 838   CheckTypeName(type);
 839   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 840   DALI_TEST_CHECK( PropertyTypes::Get<Vector3>()         == type );
 841
 842   type = Property::VECTOR4;
 843   CheckTypeName(type);
 844   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 845   DALI_TEST_CHECK( PropertyTypes::Get<Vector4>()         == type );
 846
 847   type = Property::MATRIX3;
 848   CheckTypeName(type);
 849   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 850   DALI_TEST_CHECK( PropertyTypes::Get<Matrix3>()         == type );
 851
 852   type = Property::MATRIX;
 853   CheckTypeName(type);
 854   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 855   DALI_TEST_CHECK( PropertyTypes::Get<Matrix>()          == type );
 856
 857   typedef Dali::Rect<int> Rectangle;
 858   type = Property::RECTANGLE;
 859   CheckTypeName(type);
 860   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 861   DALI_TEST_CHECK( PropertyTypes::Get<Rectangle>()       == type );
 862
 863   type = Property::ROTATION;
 864   CheckTypeName(type);
 865   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 866   DALI_TEST_CHECK( PropertyTypes::Get<Quaternion>()      == type );
 867
 868   type = Property::ROTATION;
 869   CheckTypeName(type);
 870   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 871   DALI_TEST_CHECK( PropertyTypes::Get<AngleAxis>()       == type );
 872
 873   type = Property::STRING;
 874   CheckTypeName(type);
 875   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 876   DALI_TEST_CHECK( PropertyTypes::Get<std::string>()     == type );
 877
 878   type = Property::ARRAY;
 879   CheckTypeName(type);
 880   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 881   DALI_TEST_CHECK( PropertyTypes::Get<Property::Array>() == type );
 882
 883   type = Property::MAP;
 884   CheckTypeName(type);
 885   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 886   DALI_TEST_CHECK( PropertyTypes::Get<Property::Map>()   == type );
 887   END_TEST;
 888 }
 889
 890 int UtcDaliHandleGetPropertyGet(void)
 891 {
 892   TestApplication application;
 893   tet_infoline("Testing PropertyTypes::GetName()");
 894
 895   Property::Value value;
 896
 897   bool b = false;
 898   value = Property::Value(true);
 899   value.Get(b);
 900   DALI_TEST_CHECK( true == b );
 901
 902   float f = 5.f;
 903   value = Property::Value(10.f);
 904   value.Get(f);
 905   DALI_TEST_CHECK( Dali::Equals(10.f, f) );
 906
 907   int i = 5;
 908   value = Property::Value(10);
 909   value.Get(i);
 910   DALI_TEST_CHECK( 10 == i );
 911
 912   unsigned int ui = 5;
 913   value = Property::Value(10U);
 914   value.Get(ui);
 915   DALI_TEST_CHECK( 10 == ui );
 916
 917   Vector2 v2 = Vector2(0,0);
 918   value = Property::Value( Vector2(1,1) );
 919   value.Get(v2);
 920   DALI_TEST_CHECK( Vector2(1,1) == v2 );
 921
 922   Vector3 v3 = Vector3(0.f,0.f,0.f);
 923   value = Property::Value( Vector3(1.f,1.f,1.f) );
 924   value.Get(v3);
 925   DALI_TEST_CHECK( Vector3(1.f,1.f,1.f) == v3 );
 926
 927   Vector4 v4 = Vector4(0,0,0,0);
 928   value = Property::Value( Vector4(1,1,1,1) );
 929   value.Get(v4);
 930   DALI_TEST_CHECK( Vector4(1,1,1,1) == v4 );
 931
 932   Matrix3 m3 = Matrix3(0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f);
 933   value = Property::Value( Matrix3::IDENTITY );
 934   value.Get(m3);
 935   DALI_TEST_CHECK( Matrix3::IDENTITY == m3 );
 936
 937   Matrix m = Matrix(true);
 938   value = Property::Value( Matrix::IDENTITY );
 939   value.Get(m);
 940   DALI_TEST_CHECK( Matrix::IDENTITY == m );
 941
 942   typedef Dali::Rect<int> Rectangle;
 943   Rectangle r = Rectangle(0,0,0,0);
 944   value = Property::Value( Rectangle(1,1,1,1) );
 945   value.Get(r);
 946   DALI_TEST_CHECK( Rectangle(1,1,1,1) == r );
 947
 948   Quaternion q = Quaternion(0,0,0,0);
 949   value = Property::Value( Quaternion(1,1,1,1) );
 950   value.Get(q);
 951   DALI_TEST_CHECK( Quaternion(1,1,1,1) == q );
 952
 953   AngleAxis aa = AngleAxis( Degree(0), Vector3(0.f,0.f,0.f) );
 954   value = Property::Value( AngleAxis( Radian(Math::PI_2), Vector3::XAXIS  ));
 955   value.Get(aa);
 956   Quaternion r8(Radian(Degree(aa.angle)), aa.axis);
 957   DALI_TEST_EQUALS(r8, Quaternion(Math::PI_2, Vector3::XAXIS), 0.001, TEST_LOCATION);
 958
 959   std::string s = "no";
 960   value = Property::Value("yes");
 961   value.Get(s);
 962   DALI_TEST_CHECK( "yes" == s );
 963
 964   Property::Array array;
 965   value = Property::Value(Property::ARRAY);
 966   value.AppendItem(10);
 967   value.Get(array);
 968   int getItem = 0;
 969   array[0].Get(getItem);
 970   DALI_TEST_CHECK( getItem == 10 );
 971
 972   Property::Map map;
 973   value = Property::Value(Property::MAP);
 974   value.SetValue("key", "value");
 975   value.Get(map);
 976   DALI_TEST_CHECK( map.GetKey(0) == "key" );
 977
 978   END_TEST;
 979 }
 980
 981 int UtcDaliHandleGetPropertyIndices(void)
 982 {
 983   TestApplication application;
 984   Property::IndexContainer indices;
 985
 986   // Actor
 987   Actor actor = Actor::New();
 988   actor.GetPropertyIndices( indices );
 989   DALI_TEST_CHECK( ! indices.empty() );
 990   DALI_TEST_EQUALS( indices.size(), actor.GetPropertyCount(), TEST_LOCATION );
 991   END_TEST;
 992 }
 993
 994 int UtcDaliHandleRegisterPropertyTypes(void)
 995 {
 996   TestApplication application;
 997
 998   struct PropertyTypeAnimatable
 999   {
1000     const char * name;
1001     Property::Value value;
1002     bool animatable;
1003   };
1004
1005   Property::Array array;
1006   Property::Map map;
1007
1008   PropertyTypeAnimatable properties[] =
1009   {
1010     { "Property::BOOLEAN",          true,              true  },
1011     { "Property::FLOAT",            1.0f,              true  },
1012     { "Property::INTEGER",          1,                 true  },
1013     { "Property::UNSIGNED_INTEGER", 1u,                false },
1014     { "Property::VECTOR2",          Vector2::ONE,      true  },
1015     { "Property::VECTOR3",          Vector3::ONE,      true  },
1016     { "Property::VECTOR4",          Vector4::ONE,      true  },
1017     { "Property::MATRIX3",          Matrix3::IDENTITY, true  },
1018     { "Property::MATRIX",           Matrix::IDENTITY,  true  },
1019     { "Property::RECTANGLE",        Rect<int>(),       false },
1020     { "Property::ROTATION",         AngleAxis(),       true  },
1021     { "Property::STRING",           std::string("Me"), false },
1022     { "Property::ARRAY",            array,             false },
1023     { "Property::MAP",              map,               false },
1024   };
1025   unsigned int numOfProperties( sizeof( properties ) / sizeof( properties[0] ) );
1026
1027   for ( unsigned int i = 0; i < numOfProperties; ++i )
1028   {
1029     tet_printf( "Testing: %s\n", properties[i].name );
1030
1031     bool exception = false;
1032     try
1033     {
1034       Actor actor = Actor::New();
1035       actor.RegisterProperty( "man-from-delmonte", properties[i].value );
1036     }
1037     catch (Dali::DaliException& e)
1038     {
1039       exception = true;
1040     }
1041
1042     DALI_TEST_CHECK( properties[i].animatable != exception );
1043   }
1044   END_TEST;
1045 }
1046
1047 int UtcDaliHandleCustomProperty(void)
1048 {
1049   TestApplication application;
1050
1051   Handle handle = Handle::New();
1052
1053   float startValue(1.0f);
1054   Property::Index index = handle.RegisterProperty( "test-property", startValue );
1055   DALI_TEST_CHECK( handle.GetProperty<float>(index) == startValue );
1056
1057   application.SendNotification();
1058   application.Render(0);
1059   DALI_TEST_CHECK( handle.GetProperty<float>(index) == startValue );
1060   application.Render(0);
1061   DALI_TEST_CHECK( handle.GetProperty<float>(index) == startValue );
1062
1063   handle.SetProperty( index, 5.0f );
1064
1065   application.SendNotification();
1066   application.Render(0);
1067   DALI_TEST_CHECK( handle.GetProperty<float>(index) == 5.0f );
1068   application.Render(0);
1069   DALI_TEST_CHECK( handle.GetProperty<float>(index) == 5.0f );
1070   END_TEST;
1071 }