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