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_ROTATION ) );
 409   DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::INHERIT_SCALE ) );
 410   DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::COLOR_MODE ) );
 411   DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::POSITION_INHERITANCE ) );
 412   DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::DRAW_MODE ) );
 413   DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::SIZE_MODE ) );
 414   DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::SIZE_MODE_FACTOR ) );
 415
 416   END_TEST;
 417 }
 418
 419
 420 int UtcDaliHandleGetPropertyType(void)
 421 {
 422   tet_infoline("Positive Test Dali::Handle::GetPropertyType()");
 423   TestApplication application;
 424   unsigned int unsingedIntTest = 33;
 425
 426   Actor actor = Actor::New();
 427   DALI_TEST_CHECK( Property::VECTOR3  == actor.GetPropertyType( Actor::PARENT_ORIGIN ) );
 428   DALI_TEST_CHECK( Property::VECTOR3  == actor.GetPropertyType( Actor::ANCHOR_POINT ) );
 429   DALI_TEST_CHECK( Property::VECTOR3  == actor.GetPropertyType( Actor::SIZE ) );
 430   DALI_TEST_CHECK( Property::VECTOR3  == actor.GetPropertyType( Actor::POSITION ) );
 431   DALI_TEST_CHECK( Property::ROTATION == actor.GetPropertyType( Actor::ROTATION ) );
 432   DALI_TEST_CHECK( Property::VECTOR3  == actor.GetPropertyType( Actor::SCALE ) );
 433   DALI_TEST_CHECK( Property::BOOLEAN  == actor.GetPropertyType( Actor::VISIBLE ) );
 434   DALI_TEST_CHECK( Property::VECTOR4  == actor.GetPropertyType( Actor::COLOR ) );
 435
 436   // Register some dynamic properties
 437   Property::Index boolIndex     = actor.RegisterProperty( "bool-property",     bool(true) );
 438   Property::Index floatIndex    = actor.RegisterProperty( "float-property",    float(123.0f) );
 439   Property::Index intIndex      = actor.RegisterProperty( "int-property",      123 );
 440   Property::Index vector2Index  = actor.RegisterProperty( "vector2-property",  Vector2(1.0f, 2.0f) );
 441   Property::Index vector3Index  = actor.RegisterProperty( "vector3-property",  Vector3(1.0f, 2.0f, 3.0f) );
 442   Property::Index vector4Index  = actor.RegisterProperty( "vector4-property",  Vector4(1.0f, 2.0f, 3.0f, 4.0f) );
 443   Property::Index rotationIndex = actor.RegisterProperty( "rotation-property", AngleAxis(Degree(180.0f), Vector3::YAXIS) );
 444
 445   DALI_TEST_CHECK( Property::BOOLEAN  == actor.GetPropertyType( boolIndex ) );
 446   DALI_TEST_CHECK( Property::FLOAT    == actor.GetPropertyType( floatIndex ) );
 447   DALI_TEST_CHECK( Property::INTEGER  == actor.GetPropertyType( intIndex ) );
 448   DALI_TEST_CHECK( Property::VECTOR2  == actor.GetPropertyType( vector2Index ) );
 449   DALI_TEST_CHECK( Property::VECTOR3  == actor.GetPropertyType( vector3Index ) );
 450   DALI_TEST_CHECK( Property::VECTOR4  == actor.GetPropertyType( vector4Index ) );
 451   DALI_TEST_CHECK( Property::ROTATION == actor.GetPropertyType( rotationIndex ) );
 452
 453   // Non animatable properties
 454   Property::Index nonAnimStringIndex = actor.RegisterProperty( "man-from-delmonte", std::string("yes"), Property::READ_WRITE);
 455   Property::Index nonAnimV2Index = actor.RegisterProperty( "v2", Vector2(1.f, 2.f), Property::READ_WRITE);
 456   Property::Index nonAnimV3Index = actor.RegisterProperty( "v3", Vector3(1.f, 2.f, 3.f), Property::READ_WRITE);
 457   Property::Index nonAnimV4Index = actor.RegisterProperty( "v4", Vector4(1.f, 2.f, 3.f, 4.f), Property::READ_WRITE);
 458   Property::Index nonAnimBooleanIndex = actor.RegisterProperty( "bool", true, Property::READ_WRITE);
 459   Property::Index nonAnimFloatIndex = actor.RegisterProperty( "float", 0.f, Property::READ_WRITE);
 460   Property::Index nonAnimIntegerIndex = actor.RegisterProperty( "int", 0, Property::READ_WRITE);
 461   Property::Index nonAnimUnsignedIntIndex = actor.RegisterProperty( "unsinged-int", unsingedIntTest, Property::READ_WRITE);
 462
 463   DALI_TEST_CHECK( nonAnimStringIndex  != Property::INVALID_INDEX );
 464   DALI_TEST_CHECK( nonAnimV2Index      != Property::INVALID_INDEX );
 465   DALI_TEST_CHECK( nonAnimV3Index      != Property::INVALID_INDEX );
 466   DALI_TEST_CHECK( nonAnimV4Index      != Property::INVALID_INDEX );
 467   DALI_TEST_CHECK( nonAnimBooleanIndex != Property::INVALID_INDEX );
 468   DALI_TEST_CHECK( nonAnimFloatIndex   != Property::INVALID_INDEX );
 469   DALI_TEST_CHECK( nonAnimIntegerIndex != Property::INVALID_INDEX );
 470   DALI_TEST_CHECK( nonAnimUnsignedIntIndex != Property::INVALID_INDEX );
 471
 472   DALI_TEST_CHECK( Property::STRING   == actor.GetPropertyType( nonAnimStringIndex ) );
 473   DALI_TEST_CHECK( Property::VECTOR2  == actor.GetPropertyType( nonAnimV2Index ) );
 474   DALI_TEST_CHECK( Property::VECTOR3  == actor.GetPropertyType( nonAnimV3Index ) );
 475   DALI_TEST_CHECK( Property::VECTOR4  == actor.GetPropertyType( nonAnimV4Index ) );
 476   DALI_TEST_CHECK( Property::BOOLEAN  == actor.GetPropertyType( nonAnimBooleanIndex ) );
 477   DALI_TEST_CHECK( Property::FLOAT    == actor.GetPropertyType( nonAnimFloatIndex ) );
 478   DALI_TEST_CHECK( Property::INTEGER  == actor.GetPropertyType( nonAnimIntegerIndex ) );
 479   DALI_TEST_CHECK( Property::UNSIGNED_INTEGER == actor.GetPropertyType( nonAnimUnsignedIntIndex ) );
 480
 481   DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimStringIndex ) );
 482   DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimV2Index ) );
 483   DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimV3Index ) );
 484   DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimV4Index ) );
 485   DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimBooleanIndex ) );
 486   DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimFloatIndex ) );
 487   DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimIntegerIndex ) );
 488   DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimUnsignedIntIndex ) );
 489
 490   DALI_TEST_EQUALS( "yes" , actor.GetProperty( nonAnimStringIndex ).Get<std::string>(), TEST_LOCATION );
 491   DALI_TEST_EQUALS( Vector2(1.f, 2.f) , actor.GetProperty( nonAnimV2Index ).Get<Vector2>(), TEST_LOCATION );
 492   DALI_TEST_EQUALS( Vector3(1.f, 2.f, 3.f) , actor.GetProperty( nonAnimV3Index ).Get<Vector3>(), TEST_LOCATION );
 493   DALI_TEST_EQUALS( Vector4(1.f, 2.f, 3.f, 4.f) , actor.GetProperty( nonAnimV4Index ).Get<Vector4>(), TEST_LOCATION );
 494   DALI_TEST_EQUALS( true, actor.GetProperty( nonAnimBooleanIndex ).Get<bool>(), TEST_LOCATION );
 495   DALI_TEST_EQUALS( 0.f, actor.GetProperty( nonAnimFloatIndex ).Get<float>(), TEST_LOCATION );
 496   DALI_TEST_EQUALS( 0, actor.GetProperty( nonAnimIntegerIndex ).Get<int>(), TEST_LOCATION );
 497   DALI_TEST_EQUALS( unsingedIntTest, actor.GetProperty( nonAnimUnsignedIntIndex ).Get<unsigned int>(), TEST_LOCATION );
 498
 499   END_TEST;
 500 }
 501
 502 int UtcDaliHandleNonAnimtableProperties(void)
 503 {
 504   tet_infoline("Test Non Animatable Properties");
 505   TestApplication application;
 506
 507   Actor actor = Actor::New();
 508
 509   Property::Index nonAnimStringIndex = actor.RegisterProperty( "man-from-delmonte", std::string("no"), Property::READ_WRITE);
 510
 511   //// modify writable?
 512   try
 513   {
 514     actor.SetProperty( nonAnimStringIndex, Property::Value("yes") );
 515   }
 516   catch (Dali::DaliException& e)
 517   {
 518     DALI_TEST_CHECK(!"exception");
 519   }
 520
 521   DALI_TEST_CHECK( "yes"  == actor.GetProperty( nonAnimStringIndex ).Get<std::string>() );
 522
 523   //// cannot modify read only?
 524   Property::Index readonly = actor.RegisterProperty( "float", 0.f, Property::READ_ONLY);
 525
 526   DALI_TEST_CHECK(!actor.IsPropertyAnimatable(readonly));
 527   DALI_TEST_CHECK(!actor.IsPropertyWritable(readonly));
 528
 529   bool exception = false;
 530   try
 531   {
 532     actor.SetProperty( readonly, Property::Value(1.f) );
 533   }
 534   catch (Dali::DaliException& e)
 535   {
 536     exception = true;
 537   }
 538
 539   DALI_TEST_CHECK(!exception);// trying to set a read-only property is a no-op
 540
 541   DALI_TEST_EQUALS( 0.f, actor.GetProperty( readonly ).Get<float>(), TEST_LOCATION );
 542
 543   /// animatable can be set
 544   Property::Index write_anim = actor.RegisterProperty( "write_float", 0.f, Property::ANIMATABLE);
 545
 546   DALI_TEST_CHECK(actor.IsPropertyAnimatable(write_anim));
 547   DALI_TEST_CHECK(actor.IsPropertyWritable(write_anim));
 548
 549   exception = false;
 550   try
 551   {
 552     actor.SetProperty( write_anim, Property::Value(1.f) );
 553   }
 554   catch (Dali::DaliException& e)
 555   {
 556     exception = true;
 557   }
 558
 559   DALI_TEST_CHECK(!exception);
 560
 561   //// animate a non animatable property is a noop?
 562   float durationSeconds(2.0f);
 563   Animation animation = Animation::New(durationSeconds);
 564   bool relativeValue(true);
 565
 566   exception = false;
 567
 568   try
 569   {
 570     animation.AnimateBy(Property(actor, nonAnimStringIndex), relativeValue, AlphaFunctions::EaseIn);
 571     animation.Play();
 572     application.SendNotification();
 573     application.Render(static_cast<unsigned int>(durationSeconds*0100.0f)/* some progress */);
 574   }
 575   catch (Dali::DaliException& e)
 576   {
 577     exception = true;
 578   }
 579
 580   DALI_TEST_CHECK(!exception);
 581   DALI_TEST_EQUALS( "yes", actor.GetProperty( nonAnimStringIndex ).Get<std::string>(), TEST_LOCATION );
 582
 583   END_TEST;
 584 }
 585
 586 int UtcDaliHandleNonAnimtableCompositeProperties(void)
 587 {
 588   tet_infoline("Test Non Animatable Composite Properties");
 589   TestApplication application;
 590
 591   Actor actor = Actor::New();
 592
 593   Property::Value value(Property::ARRAY);
 594   Property::Array anArray;
 595   DALI_TEST_CHECK( Property::Value(anArray).GetType() == Property::ARRAY ); // 2nd constructor
 596
 597   value.AppendItem( Property::Value( 0.f ) );
 598   value.AppendItem( "a string" );
 599   value.SetItem(0, Property::Value( 5.f )); // exercise SetItem
 600
 601   int index = value.AppendItem( Vector3(1,2,3) );
 602
 603   DALI_TEST_EQUALS( 2, index, TEST_LOCATION);
 604   DALI_TEST_EQUALS( 3, value.GetSize(), TEST_LOCATION);
 605
 606   Property::Index propertyIndex = actor.RegisterProperty( "composite", value, Property::READ_WRITE);
 607
 608   Property::Value out = actor.GetProperty( propertyIndex );
 609
 610   DALI_TEST_CHECK( Property::FLOAT     == out.GetItem(0).GetType());
 611   DALI_TEST_CHECK( Property::STRING    == out.GetItem(1).GetType());
 612   DALI_TEST_CHECK( Property::VECTOR3   == out.GetItem(2).GetType());
 613
 614   DALI_TEST_EQUALS( 5.f,            out.GetItem(0).Get<float>(),        TEST_LOCATION);
 615   DALI_TEST_EQUALS( "a string",     out.GetItem(1).Get<std::string>(),  TEST_LOCATION);
 616   DALI_TEST_EQUALS( Vector3(1,2,3), out.GetItem(2).Get<Vector3>(),      TEST_LOCATION);
 617
 618   // Property Maps
 619   Property::Value valueMap(Property::MAP);
 620   Property::Map aKindofMap;
 621   DALI_TEST_CHECK( Property::Value(aKindofMap).GetType() == Property::MAP ); // 2nd constructor
 622
 623   valueMap.SetValue("key", 5.f);
 624   valueMap.SetValue("2key", "a string");
 625
 626   DALI_TEST_EQUALS( true, valueMap.HasKey("key"),        TEST_LOCATION);
 627   DALI_TEST_EQUALS( "key", valueMap.GetKey(0),           TEST_LOCATION);
 628
 629   DALI_TEST_EQUALS( true, valueMap.HasKey("2key"),       TEST_LOCATION);
 630   DALI_TEST_EQUALS( "2key", valueMap.GetKey(1),          TEST_LOCATION);
 631
 632   DALI_TEST_EQUALS( 5.f,         valueMap.GetValue("key").Get<float>(),         TEST_LOCATION);
 633   DALI_TEST_EQUALS( "a string",  valueMap.GetValue("2key").Get<std::string>(),  TEST_LOCATION);
 634
 635   valueMap.SetItem(0, Property::Value("a string"));
 636   valueMap.SetItem(1, Property::Value(5.f));
 637
 638   DALI_TEST_EQUALS( 5.f,         valueMap.GetValue("2key").Get<float>(),        TEST_LOCATION);
 639   DALI_TEST_EQUALS( "a string",  valueMap.GetValue("key").Get<std::string>(),   TEST_LOCATION);
 640
 641   // ordered map
 642   valueMap = Property::Value(Property::MAP);
 643
 644   valueMap.SetValue("key", 5.f);
 645   valueMap.SetValue("2key", "a string");
 646
 647   DALI_TEST_EQUALS( 5.f,         valueMap.GetItem(0).Get<float>(),         TEST_LOCATION);
 648   DALI_TEST_EQUALS( "a string",  valueMap.GetItem(1).Get<std::string>(),   TEST_LOCATION);
 649
 650   DALI_TEST_EQUALS( 2, valueMap.GetSize(), TEST_LOCATION);
 651
 652   // composite types not animatable
 653   bool exception = false;
 654   try
 655   {
 656     /* Property::Index mapPropertyIndex = */ actor.RegisterProperty( "compositemap", value, Property::ANIMATABLE);
 657   }
 658   catch (Dali::DaliException& e)
 659   {
 660     exception = true;
 661     DALI_TEST_PRINT_ASSERT( e );
 662   }
 663
 664   DALI_TEST_EQUALS(exception, true, TEST_LOCATION);
 665
 666   // Map of maps
 667   Property::Value mapOfMaps(Property::MAP);
 668
 669   mapOfMaps.SetValue( "key", Property::Value(Property::MAP) );
 670   mapOfMaps.SetValue( "2key", "a string" );
 671
 672   DALI_TEST_EQUALS( "a string",  mapOfMaps.GetValue("2key").Get<std::string>(),  TEST_LOCATION);
 673
 674   mapOfMaps.GetValue("key").SetValue("subkey", 5.f);
 675
 676   DALI_TEST_EQUALS( true, mapOfMaps.GetValue("key").HasKey("subkey"), TEST_LOCATION);
 677   DALI_TEST_EQUALS( 5.f, mapOfMaps.GetValue("key").GetValue("subkey").Get<float>(), TEST_LOCATION);
 678
 679   // list of maps
 680   Property::Value listOfMaps(Property::ARRAY);
 681
 682   listOfMaps.AppendItem( Property::Value(Property::MAP) );
 683   listOfMaps.AppendItem( Property::Value(Property::MAP) );
 684
 685   listOfMaps.GetItem(0).SetValue("key", 5.f);
 686   listOfMaps.GetItem(1).SetValue("key",10.f);
 687
 688   DALI_TEST_EQUALS( 5.f, listOfMaps.GetItem(0).GetValue("key").Get<float>(), TEST_LOCATION );
 689   DALI_TEST_EQUALS( 10.f, listOfMaps.GetItem(1).GetValue("key").Get<float>(), TEST_LOCATION );
 690
 691   END_TEST;
 692 }
 693
 694 int UtcDaliHandleSetProperty01(void)
 695 {
 696   tet_infoline("Positive Test Dali::Handle::SetProperty()");
 697   TestApplication application;
 698
 699   Actor actor = Actor::New();
 700   DALI_TEST_CHECK( ParentOrigin::TOP_LEFT == actor.GetProperty( Actor::PARENT_ORIGIN ).Get<Vector3>() );
 701
 702   actor.SetProperty( Actor::PARENT_ORIGIN, ParentOrigin::CENTER );
 703   // flush the queue and render once
 704   application.SendNotification();
 705   application.Render();
 706   DALI_TEST_CHECK( ParentOrigin::CENTER == actor.GetProperty( Actor::PARENT_ORIGIN ).Get<Vector3>() );
 707   END_TEST;
 708 }
 709
 710 int UtcDaliHandleSetProperty02(void)
 711 {
 712   tet_infoline("Positive Test Dali::Handle::SetProperty()");
 713   TestApplication application;
 714
 715   Actor actor = Actor::New();
 716
 717   DALI_TEST_CHECK( !actor.IsPropertyWritable( Actor::WORLD_POSITION ) );
 718
 719   // World position is not writable so this is a no-op and should not crash
 720   actor.SetProperty( Actor::WORLD_POSITION, Vector3(1,2,3) );
 721
 722   END_TEST;
 723 }
 724
 725 int UtcDaliHandleRegisterProperty(void)
 726 {
 727   tet_infoline("Positive Test Dali::Handle::RegisterProperty()");
 728   TestApplication application;
 729
 730   Actor actor = Actor::New();
 731   DALI_TEST_CHECK( ParentOrigin::TOP_LEFT == actor.GetProperty( Actor::PARENT_ORIGIN ).Get<Vector3>() );
 732
 733   END_TEST;
 734 }
 735
 736 int UtcDaliHandleGetProperty(void)
 737 {
 738   tet_infoline("Positive Test Dali::Handle::GetProperty()");
 739   TestApplication application;
 740
 741   Actor actor = Actor::New();
 742
 743   DALI_TEST_CHECK( ParentOrigin::TOP_LEFT == actor.GetProperty( Actor::PARENT_ORIGIN   ).Get<Vector3>() );
 744   DALI_TEST_CHECK( AnchorPoint::CENTER    == actor.GetProperty( Actor::ANCHOR_POINT    ).Get<Vector3>() );
 745   DALI_TEST_CHECK( Vector3::ZERO          == actor.GetProperty( Actor::SIZE            ).Get<Vector3>() );
 746   DALI_TEST_CHECK( Vector3::ZERO          == actor.GetProperty( Actor::POSITION        ).Get<Vector3>() );
 747   DALI_TEST_CHECK( Vector3::ONE           == actor.GetProperty( Actor::SCALE           ).Get<Vector3>() );
 748   DALI_TEST_CHECK( true                   == actor.GetProperty( Actor::VISIBLE         ).Get<bool>() );
 749   DALI_TEST_CHECK( Color::WHITE           == actor.GetProperty( Actor::COLOR           ).Get<Vector4>() );
 750   END_TEST;
 751 }
 752
 753 int UtcDaliHandleDownCast(void)
 754 {
 755   TestApplication application;
 756   tet_infoline("Testing Dali::Handle::DownCast()");
 757
 758   Actor actor = Actor::New();
 759
 760   BaseHandle baseHandle = actor;
 761
 762   Handle handle = Handle::DownCast(baseHandle);
 763
 764   DALI_TEST_CHECK( handle );
 765
 766   baseHandle = BaseHandle();
 767
 768   handle = Handle::DownCast(baseHandle);
 769
 770   DALI_TEST_CHECK( !handle );
 771
 772   END_TEST;
 773 }
 774
 775 int UtcDaliHandleCreateProperty(void)
 776 {
 777   TestApplication application;
 778   tet_infoline("Testing PropertyTypes::GetName()");
 779
 780   Property::Type type = Property::NONE;
 781   CheckTypeName(type);
 782   // Value(Value&) ctor and Value(Type&) ctor
 783   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 784   DALI_TEST_CHECK( Property::NONE == type );
 785
 786   // PropertyTypes
 787   type = Property::BOOLEAN;
 788   CheckTypeName(type);
 789   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 790   DALI_TEST_CHECK( PropertyTypes::Get<bool>()            == type );
 791
 792   type = Property::FLOAT;
 793   CheckTypeName(type);
 794   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 795   DALI_TEST_CHECK( PropertyTypes::Get<float>()           == type );
 796
 797   type = Property::INTEGER;
 798   CheckTypeName(type);
 799   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 800   DALI_TEST_CHECK( PropertyTypes::Get<int>()             == type );
 801
 802   type = Property::UNSIGNED_INTEGER;
 803   CheckTypeName(type);
 804   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 805   DALI_TEST_CHECK( PropertyTypes::Get<unsigned int>()    == type );
 806
 807   type = Property::VECTOR2;
 808   CheckTypeName(type);
 809   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 810   DALI_TEST_CHECK( PropertyTypes::Get<Vector2>()         == type );
 811
 812   type = Property::VECTOR3;
 813   CheckTypeName(type);
 814   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 815   DALI_TEST_CHECK( PropertyTypes::Get<Vector3>()         == type );
 816
 817   type = Property::VECTOR4;
 818   CheckTypeName(type);
 819   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 820   DALI_TEST_CHECK( PropertyTypes::Get<Vector4>()         == type );
 821
 822   type = Property::MATRIX3;
 823   CheckTypeName(type);
 824   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 825   DALI_TEST_CHECK( PropertyTypes::Get<Matrix3>()         == type );
 826
 827   type = Property::MATRIX;
 828   CheckTypeName(type);
 829   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 830   DALI_TEST_CHECK( PropertyTypes::Get<Matrix>()          == type );
 831
 832   typedef Dali::Rect<int> Rectangle;
 833   type = Property::RECTANGLE;
 834   CheckTypeName(type);
 835   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 836   DALI_TEST_CHECK( PropertyTypes::Get<Rectangle>()       == type );
 837
 838   type = Property::ROTATION;
 839   CheckTypeName(type);
 840   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 841   DALI_TEST_CHECK( PropertyTypes::Get<Quaternion>()      == type );
 842
 843   type = Property::ROTATION;
 844   CheckTypeName(type);
 845   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 846   DALI_TEST_CHECK( PropertyTypes::Get<AngleAxis>()       == type );
 847
 848   type = Property::STRING;
 849   CheckTypeName(type);
 850   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 851   DALI_TEST_CHECK( PropertyTypes::Get<std::string>()     == type );
 852
 853   type = Property::ARRAY;
 854   CheckTypeName(type);
 855   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 856   DALI_TEST_CHECK( PropertyTypes::Get<Property::Array>() == type );
 857
 858   type = Property::MAP;
 859   CheckTypeName(type);
 860   DALI_TEST_CHECK( Property::Value(Property::Value(type)).GetType() == type );
 861   DALI_TEST_CHECK( PropertyTypes::Get<Property::Map>()   == type );
 862   END_TEST;
 863 }
 864
 865 int UtcDaliHandleGetPropertyGet(void)
 866 {
 867   TestApplication application;
 868   tet_infoline("Testing PropertyTypes::GetName()");
 869
 870   Property::Value value;
 871
 872   bool b = false;
 873   value = Property::Value(true);
 874   value.Get(b);
 875   DALI_TEST_CHECK( true == b );
 876
 877   float f = 5.f;
 878   value = Property::Value(10.f);
 879   value.Get(f);
 880   DALI_TEST_CHECK( Dali::Equals(10.f, f) );
 881
 882   int i = 5;
 883   value = Property::Value(10);
 884   value.Get(i);
 885   DALI_TEST_CHECK( 10 == i );
 886
 887   unsigned int ui = 5;
 888   value = Property::Value(10U);
 889   value.Get(ui);
 890   DALI_TEST_CHECK( 10 == ui );
 891
 892   Vector2 v2 = Vector2(0,0);
 893   value = Property::Value( Vector2(1,1) );
 894   value.Get(v2);
 895   DALI_TEST_CHECK( Vector2(1,1) == v2 );
 896
 897   Vector3 v3 = Vector3(0.f,0.f,0.f);
 898   value = Property::Value( Vector3(1.f,1.f,1.f) );
 899   value.Get(v3);
 900   DALI_TEST_CHECK( Vector3(1.f,1.f,1.f) == v3 );
 901
 902   Vector4 v4 = Vector4(0,0,0,0);
 903   value = Property::Value( Vector4(1,1,1,1) );
 904   value.Get(v4);
 905   DALI_TEST_CHECK( Vector4(1,1,1,1) == v4 );
 906
 907   Matrix3 m3 = Matrix3(0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f,0.f);
 908   value = Property::Value( Matrix3::IDENTITY );
 909   value.Get(m3);
 910   DALI_TEST_CHECK( Matrix3::IDENTITY == m3 );
 911
 912   Matrix m = Matrix(true);
 913   value = Property::Value( Matrix::IDENTITY );
 914   value.Get(m);
 915   DALI_TEST_CHECK( Matrix::IDENTITY == m );
 916
 917   typedef Dali::Rect<int> Rectangle;
 918   Rectangle r = Rectangle(0,0,0,0);
 919   value = Property::Value( Rectangle(1,1,1,1) );
 920   value.Get(r);
 921   DALI_TEST_CHECK( Rectangle(1,1,1,1) == r );
 922
 923   Quaternion q = Quaternion(0,0,0,0);
 924   value = Property::Value( Quaternion(1,1,1,1) );
 925   value.Get(q);
 926   DALI_TEST_CHECK( Quaternion(1,1,1,1) == q );
 927
 928   AngleAxis aa = AngleAxis( Degree(0), Vector3(0.f,0.f,0.f) );
 929   value = Property::Value( AngleAxis( Radian(Math::PI_2), Vector3::XAXIS  ));
 930   value.Get(aa);
 931   Quaternion r8(Radian(Degree(aa.angle)), aa.axis);
 932   DALI_TEST_EQUALS(r8, Quaternion(Math::PI_2, Vector3::XAXIS), 0.001, TEST_LOCATION);
 933
 934   std::string s = "no";
 935   value = Property::Value("yes");
 936   value.Get(s);
 937   DALI_TEST_CHECK( "yes" == s );
 938
 939   Property::Array array;
 940   value = Property::Value(Property::ARRAY);
 941   value.AppendItem(10);
 942   value.Get(array);
 943   int getItem = 0;
 944   array[0].Get(getItem);
 945   DALI_TEST_CHECK( getItem == 10 );
 946
 947   Property::Map map;
 948   value = Property::Value(Property::MAP);
 949   value.SetValue("key", "value");
 950   value.Get(map);
 951   DALI_TEST_CHECK( map.GetKey(0) == "key" );
 952
 953   END_TEST;
 954 }
 955
 956 int UtcDaliHandleGetPropertyIndices(void)
 957 {
 958   TestApplication application;
 959   Property::IndexContainer indices;
 960
 961   // Actor
 962   Actor actor = Actor::New();
 963   actor.GetPropertyIndices( indices );
 964   DALI_TEST_CHECK( ! indices.empty() );
 965   DALI_TEST_EQUALS( indices.size(), actor.GetPropertyCount(), TEST_LOCATION );
 966   END_TEST;
 967 }
 968
 969 int UtcDaliHandleRegisterPropertyTypes(void)
 970 {
 971   TestApplication application;
 972
 973   struct PropertyTypeAnimatable
 974   {
 975     const char * name;
 976     Property::Value value;
 977     bool animatable;
 978   };
 979
 980   Property::Array array;
 981   Property::Map map;
 982
 983   PropertyTypeAnimatable properties[] =
 984   {
 985     { "Property::BOOLEAN",          true,              true  },
 986     { "Property::FLOAT",            1.0f,              true  },
 987     { "Property::INTEGER",          1,                 true  },
 988     { "Property::UNSIGNED_INTEGER", 1u,                false },
 989     { "Property::VECTOR2",          Vector2::ONE,      true  },
 990     { "Property::VECTOR3",          Vector3::ONE,      true  },
 991     { "Property::VECTOR4",          Vector4::ONE,      true  },
 992     { "Property::MATRIX3",          Matrix3::IDENTITY, true  },
 993     { "Property::MATRIX",           Matrix::IDENTITY,  true  },
 994     { "Property::RECTANGLE",        Rect<int>(),       false },
 995     { "Property::ROTATION",         AngleAxis(),       true  },
 996     { "Property::STRING",           std::string("Me"), false },
 997     { "Property::ARRAY",            array,             false },
 998     { "Property::MAP",              map,               false },
 999   };
1000   unsigned int numOfProperties( sizeof( properties ) / sizeof( properties[0] ) );
1001
1002   for ( unsigned int i = 0; i < numOfProperties; ++i )
1003   {
1004     tet_printf( "Testing: %s\n", properties[i].name );
1005
1006     bool exception = false;
1007     try
1008     {
1009       Actor actor = Actor::New();
1010       actor.RegisterProperty( "man-from-delmonte", properties[i].value );
1011     }
1012     catch (Dali::DaliException& e)
1013     {
1014       exception = true;
1015     }
1016
1017     DALI_TEST_CHECK( properties[i].animatable != exception );
1018   }
1019   END_TEST;
1020 }