automated-tests/src/dali/utc-Dali-PropertyValue.cpp

   1 /*
   2  * Copyright (c) 2015 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 #include <iomanip>
  20 #include <stdlib.h>
  21 #include <dali/public-api/dali-core.h>
  22 #include <dali-test-suite-utils.h>
  23
  24 using namespace Dali;
  25
  26 namespace
  27 {
  28
  29 void CheckTypeName(const Property::Type& type)
  30 {
  31   switch(type)
  32   {
  33     case Property::NONE:
  34     {
  35       DALI_TEST_CHECK( "NONE" == std::string(PropertyTypes::GetName( type ) ) );
  36       break;
  37     }
  38     case Property::BOOLEAN:
  39     {
  40       DALI_TEST_CHECK( "BOOLEAN" == std::string(PropertyTypes::GetName( type ) ) );
  41       break;
  42     }
  43     case Property::FLOAT:
  44     {
  45       DALI_TEST_CHECK( "FLOAT" == std::string(PropertyTypes::GetName( type ) ) );
  46       break;
  47     }
  48     case Property::INTEGER:
  49     {
  50       DALI_TEST_CHECK( "INTEGER" == std::string(PropertyTypes::GetName( type ) ) );
  51       break;
  52     }
  53     case Property::UNSIGNED_INTEGER:
  54     {
  55       DALI_TEST_CHECK( "UNSIGNED_INTEGER" == std::string(PropertyTypes::GetName( type ) ) );
  56       break;
  57     }
  58     case Property::VECTOR2:
  59     {
  60       DALI_TEST_CHECK( "VECTOR2" == std::string(PropertyTypes::GetName( type ) ) );
  61       break;
  62     }
  63     case Property::VECTOR3:
  64     {
  65       DALI_TEST_CHECK( "VECTOR3" == std::string(PropertyTypes::GetName( type ) ) );
  66       break;
  67     }
  68     case Property::VECTOR4:
  69     {
  70       DALI_TEST_CHECK( "VECTOR4" == std::string(PropertyTypes::GetName( type ) ) );
  71       break;
  72     }
  73     case Property::MATRIX3:
  74     {
  75       DALI_TEST_CHECK( "MATRIX3" == std::string(PropertyTypes::GetName( type  ) ) );
  76       break;
  77     }
  78     case Property::MATRIX:
  79     {
  80       DALI_TEST_CHECK( "MATRIX" == std::string(PropertyTypes::GetName( type ) ) );
  81       break;
  82     }
  83     case Property::RECTANGLE:
  84     {
  85       DALI_TEST_CHECK( "RECTANGLE" == std::string(PropertyTypes::GetName( type ) ) );
  86       break;
  87     }
  88     case Property::ROTATION:
  89     {
  90       DALI_TEST_CHECK( "ROTATION" == std::string(PropertyTypes::GetName( type ) ) );
  91       break;
  92     }
  93     case Property::STRING:
  94     {
  95       DALI_TEST_CHECK( "STRING" == std::string(PropertyTypes::GetName( type ) ) );
  96       break;
  97     }
  98     case Property::ARRAY:
  99     {
 100       DALI_TEST_CHECK( "ARRAY" == std::string(PropertyTypes::GetName( type ) ) );
 101       break;
 102     }
 103     case Property::MAP:
 104     {
 105       DALI_TEST_CHECK( "MAP" == std::string(PropertyTypes::GetName( type ) ) );
 106       break;
 107     }
 108   } // switch(type)
 109
 110 } // CheckTypeName
 111
 112 template <typename T>
 113 struct CheckCopyCtorP
 114 {
 115   CheckCopyCtorP(Property::Value value)
 116   {
 117     Property::Value copy( value );
 118     DALI_TEST_CHECK( value.Get<T>() == copy.Get<T>() );
 119   }
 120 };
 121
 122 } // unnamed namespace
 123
 124 void utc_dali_property_value_startup(void)
 125 {
 126   test_return_value = TET_UNDEF;
 127 }
 128
 129 void utc_dali_property_value_cleanup(void)
 130 {
 131   test_return_value = TET_PASS;
 132 }
 133
 134
 135 int UtcDaliPropertyValueConstructorsNoneP(void)
 136 {
 137   Property::Value value;
 138
 139   DALI_TEST_CHECK( value.GetType() == Property::NONE );
 140
 141   END_TEST;
 142 }
 143
 144 int UtcDaliPropertyValueConstructorsNoneTypeP(void)
 145 {
 146   Property::Value value( Property::NONE );
 147
 148   DALI_TEST_CHECK( value.GetType() == Property::NONE );
 149
 150   END_TEST;
 151 }
 152
 153 int UtcDaliPropertyValueConstructorsBoolP(void)
 154 {
 155   Property::Value value(true);
 156
 157   DALI_TEST_CHECK( value.GetType() == Property::BOOLEAN );
 158   DALI_TEST_CHECK( value.Get<bool>() == true );
 159
 160   END_TEST;
 161 }
 162
 163 int UtcDaliPropertyValueConstructorBoolTypeP(void)
 164 {
 165   Property::Value value(Property::BOOLEAN);
 166
 167   DALI_TEST_CHECK( value.GetType() == Property::BOOLEAN );
 168   DALI_TEST_CHECK( value.Get<bool>() == false );
 169
 170   END_TEST;
 171 }
 172
 173 int UtcDaliPropertyValueConstructorsFloatP(void)
 174 {
 175   Property::Value value(2.f);
 176
 177   DALI_TEST_CHECK( value.GetType() == Property::FLOAT );
 178   DALI_TEST_CHECK( value.Get<float>() == 2.f );
 179
 180   END_TEST;
 181 }
 182
 183 int UtcDaliPropertyValueConstructorsFloatTypeP(void)
 184 {
 185   Property::Value value(Property::FLOAT);
 186
 187   DALI_TEST_CHECK( value.GetType() == Property::FLOAT );
 188   DALI_TEST_CHECK( value.Get<float>() == 0.f );
 189
 190   END_TEST;
 191 }
 192
 193 int UtcDaliPropertyValueConstructorsIntP(void)
 194 {
 195   Property::Value value(1);
 196
 197   DALI_TEST_CHECK( value.GetType() == Property::INTEGER );
 198   DALI_TEST_CHECK( value.Get<int>() == 1 );
 199
 200   END_TEST;
 201 }
 202
 203 int UtcDaliPropertyValueConstructorsIntTypeP(void)
 204 {
 205   Property::Value value(Property::INTEGER);
 206
 207   DALI_TEST_CHECK( value.GetType() == Property::INTEGER );
 208   DALI_TEST_CHECK( value.Get<int>() == 0 );
 209
 210   END_TEST;
 211 }
 212
 213 int UtcDaliPropertyValueConstructorsUnsignedIntP(void)
 214 {
 215   Property::Value value(1u);
 216
 217   DALI_TEST_CHECK( value.GetType() == Property::UNSIGNED_INTEGER );
 218   DALI_TEST_CHECK( value.Get<unsigned int>() == 1u );
 219
 220   END_TEST;
 221 }
 222
 223 int UtcDaliPropertyValueConstructorsUnsignedIntTypeP(void)
 224 {
 225   Property::Value value( Property::UNSIGNED_INTEGER );
 226
 227   DALI_TEST_CHECK( value.GetType() == Property::UNSIGNED_INTEGER );
 228   DALI_TEST_CHECK( value.Get<unsigned int>() == 0u );
 229
 230   END_TEST;
 231 }
 232
 233 int UtcDaliPropertyValueConstructorsVector2P(void)
 234 {
 235   Vector2 v(1,1);
 236   Property::Value value(v);
 237
 238   DALI_TEST_CHECK( value.GetType() == Property::VECTOR2 );
 239   DALI_TEST_CHECK( value.Get<Vector2>() == v );
 240
 241   END_TEST;
 242 }
 243
 244 int UtcDaliPropertyValueConstructorsVector2TypeP(void)
 245 {
 246   Property::Value value( Property::VECTOR2 );
 247
 248   DALI_TEST_CHECK( value.GetType() == Property::VECTOR2 );
 249   DALI_TEST_CHECK( value.Get<Vector2>() == Vector2::ZERO );
 250
 251   END_TEST;
 252 }
 253
 254 int UtcDaliPropertyValueConstructorsVector3P(void)
 255 {
 256   Vector3 v(1.f,2.f,3.f);
 257   Property::Value value(v);
 258
 259   DALI_TEST_CHECK( value.GetType() == Property::VECTOR3 );
 260   DALI_TEST_CHECK( value.Get<Vector3>() == v );
 261
 262   END_TEST;
 263 }
 264
 265 int UtcDaliPropertyValueConstructorsVector3TypeP(void)
 266 {
 267   Property::Value value( Property::VECTOR3 );
 268
 269   DALI_TEST_CHECK( value.GetType() == Property::VECTOR3 );
 270   DALI_TEST_CHECK( value.Get<Vector3>() == Vector3() );
 271
 272   END_TEST;
 273 }
 274
 275 int UtcDaliPropertyValueConstructorsVector4P(void)
 276 {
 277   Vector4 v(1.f,1.f,1.f,0.9f);
 278   Property::Value value(v);
 279
 280   DALI_TEST_CHECK( value.GetType() == Property::VECTOR4 );
 281   DALI_TEST_CHECK( value.Get<Vector4>() == v );
 282
 283   END_TEST;
 284 }
 285
 286 int UtcDaliPropertyValueConstructorsVector4TypeP(void)
 287 {
 288   Property::Value value( Property::VECTOR4 );
 289
 290   DALI_TEST_CHECK( value.GetType() == Property::VECTOR4 );
 291   DALI_TEST_CHECK( value.Get<Vector4>() == Vector4() );
 292
 293   END_TEST;
 294 }
 295
 296 int UtcDaliPropertyValueConstructorsMatrix3P(void)
 297 {
 298   Matrix3 v(1.0,1.0,1.0, 1.0,1.0,1.0, 1.0,1.0,1.0);
 299   Property::Value value(v);
 300
 301   DALI_TEST_CHECK( value.GetType() == Property::MATRIX3 );
 302   DALI_TEST_CHECK( value.Get<Matrix3>() == v );
 303
 304   END_TEST;
 305 }
 306
 307 int UtcDaliPropertyValueConstructorsMatrix3TypeP(void)
 308 {
 309   Property::Value value( Property::MATRIX3 );
 310
 311   DALI_TEST_CHECK( value.GetType() == Property::MATRIX3 );
 312   DALI_TEST_CHECK( value.Get<Matrix3>() == Matrix3() );
 313
 314   END_TEST;
 315 }
 316
 317 int UtcDaliPropertyValueConstructorsMatrixP(void)
 318 {
 319   float a[] = {1.0,1.0,1.0,1.0, 1.0,1.0,1.0,1.0, 1.0,1.0,1.0,1.0, 1.0,1.0,1.0,1.0};
 320   Matrix v(a);
 321   Property::Value value(v);
 322
 323   DALI_TEST_CHECK( value.GetType() == Property::MATRIX );
 324   DALI_TEST_CHECK( value.Get<Matrix>() == v );
 325
 326   END_TEST;
 327 }
 328
 329 int UtcDaliPropertyValueConstructorsMatrixTypeP(void)
 330 {
 331   Property::Value value( Property::MATRIX );
 332
 333   DALI_TEST_CHECK( value.GetType() == Property::MATRIX );
 334   DALI_TEST_CHECK( value.Get<Matrix>() == Matrix() );
 335
 336   END_TEST;
 337 }
 338
 339 int UtcDaliPropertyValueConstructorsRectP(void)
 340 {
 341   Rect<int> v(1.0,1.0,1.0,1.0);
 342   Property::Value value(v);
 343
 344   DALI_TEST_EQUALS( value.GetType(), Property::RECTANGLE, TEST_LOCATION );
 345   DALI_TEST_CHECK( value.Get<Rect<int> >() == v );
 346
 347   END_TEST;
 348 }
 349
 350 int UtcDaliPropertyValueConstructorsRectTypeP(void)
 351 {
 352   Property::Value value( Property::RECTANGLE );
 353
 354   DALI_TEST_CHECK( value.GetType() == Property::RECTANGLE );
 355   DALI_TEST_CHECK( value.Get<Rect<int> >() == Rect<int>(0,0,0,0) );
 356
 357   END_TEST;
 358 }
 359
 360 int UtcDaliPropertyValueConstructorsAngleAxisP(void)
 361 {
 362   AngleAxis input( Dali::ANGLE_90, Vector3::XAXIS );
 363   Property::Value value( input );
 364
 365   DALI_TEST_CHECK( value.GetType() == Property::ROTATION );
 366   AngleAxis result = value.Get<AngleAxis>();
 367   DALI_TEST_EQUALS( result.angle, input.angle, TEST_LOCATION );
 368   DALI_TEST_EQUALS( result.axis, input.axis, TEST_LOCATION );
 369
 370   END_TEST;
 371 }
 372
 373 int UtcDaliPropertyValueConstructorsQuaternionP(void)
 374 {
 375   Quaternion v( Vector4(1.0,1.0,1.0,1.0) );
 376   Property::Value value(v);
 377
 378   DALI_TEST_CHECK( value.GetType() == Property::ROTATION );
 379   DALI_TEST_CHECK( value.Get<Quaternion>() == v );
 380
 381   END_TEST;
 382 }
 383
 384 int UtcDaliPropertyValueConstructorsRotationTypeP(void)
 385 {
 386   Property::Value value( Property::ROTATION );
 387
 388   DALI_TEST_CHECK( value.GetType() == Property::ROTATION );
 389   AngleAxis result = value.Get<AngleAxis>();
 390   DALI_TEST_EQUALS( result.angle, Radian(0.f), TEST_LOCATION );
 391   DALI_TEST_EQUALS( result.axis, Vector3::ZERO, TEST_LOCATION ); // identity quaternion returns a zero angle-axis
 392
 393   END_TEST;
 394 }
 395
 396 int UtcDaliPropertyValueConstructorsStringP(void)
 397 {
 398   std::string v("1");
 399   Property::Value value(v);
 400
 401   DALI_TEST_CHECK( value.GetType() == Property::STRING );
 402   DALI_TEST_CHECK( value.Get<std::string>() == v );
 403
 404   END_TEST;
 405 }
 406
 407 int UtcDaliPropertyValueConstructorsStringTypeP(void)
 408 {
 409   Property::Value value( Property::STRING );
 410
 411   DALI_TEST_CHECK( value.GetType() == Property::STRING );
 412   DALI_TEST_CHECK( value.Get<std::string>() == std::string() );
 413
 414   END_TEST;
 415 }
 416
 417 int UtcDaliPropertyValueConstructorsArrayP(void)
 418 {
 419   Property::Array foo;
 420   Property::Value value( foo );
 421
 422   DALI_TEST_CHECK( value.GetType() == Property::ARRAY );
 423   DALI_TEST_CHECK( value.Get<Property::Array>().Count() == 0 );
 424
 425   END_TEST;
 426 }
 427
 428 int UtcDaliPropertyValueConstructorsArray2P(void)
 429 {
 430   Property::Array foo;
 431   foo.PushBack( Property::Value() );
 432   Property::Value value( foo );
 433
 434   DALI_TEST_CHECK( value.GetType() == Property::ARRAY );
 435   DALI_TEST_CHECK( value.Get<Property::Array>().Count() == 1 );
 436
 437   END_TEST;
 438 }
 439
 440 int UtcDaliPropertyValueConstructorsArrayTypeP(void)
 441 {
 442   Property::Value value(Property::ARRAY);
 443
 444   DALI_TEST_CHECK( value.GetType() == Property::ARRAY );
 445   DALI_TEST_CHECK( value.Get<Property::Array>().Count() == 0 );
 446
 447   END_TEST;
 448 }
 449
 450 int UtcDaliPropertyValueConstructorsMapP(void)
 451 {
 452   Property::Map map;
 453   Property::Value value( map );
 454
 455   DALI_TEST_CHECK( value.GetType() == Property::MAP );
 456   DALI_TEST_CHECK( value.Get<Property::Map>().Count() == 0 );
 457
 458   END_TEST;
 459 }
 460
 461 int UtcDaliPropertyValueConstructorsMap2P(void)
 462 {
 463   Property::Map map;
 464   map.Insert( "", "" );
 465   Property::Value value( map );
 466
 467   DALI_TEST_CHECK( value.GetType() == Property::MAP );
 468   DALI_TEST_CHECK( value.Get<Property::Map>().Count() == 1 );
 469
 470   END_TEST;
 471 }
 472
 473 int UtcDaliPropertyValueConstructorsMapTypeP(void)
 474 {
 475   Property::Value value(Property::MAP);
 476
 477   DALI_TEST_CHECK( value.GetType() == Property::MAP );
 478   DALI_TEST_CHECK( value.Get<Property::Map>().Count() == 0 );
 479
 480   END_TEST;
 481 }
 482
 483 int UtcDaliPropertyValueCopyConstructorP(void)
 484 {
 485   Property::Value value;
 486   Property::Value value2( value );
 487   DALI_TEST_EQUALS( value.GetType(), value2.GetType(), TEST_LOCATION );
 488   DALI_TEST_EQUALS( value.GetMap(), value2.GetMap(), TEST_LOCATION );
 489   DALI_TEST_EQUALS( value.GetArray(), value2.GetArray(), TEST_LOCATION );
 490   END_TEST;
 491 }
 492
 493 int UtcDaliPropertyValueCopyConstructorBoolP(void)
 494 {
 495   CheckCopyCtorP<bool> check(true);
 496   END_TEST;
 497 }
 498
 499 int UtcDaliPropertyValueCopyConstructorFloatP(void)
 500 {
 501   CheckCopyCtorP<float> check(1.f);
 502   END_TEST;
 503 }
 504
 505 int UtcDaliPropertyValueCopyConstructorIntP(void)
 506 {
 507   CheckCopyCtorP<int> check(1);
 508   END_TEST;
 509 }
 510
 511 int UtcDaliPropertyValueCopyConstructorUnsignedIntP(void)
 512 {
 513   CheckCopyCtorP<unsigned int> check(1u);
 514   END_TEST;
 515 }
 516
 517 int UtcDaliPropertyValueCopyConstructoVector2P(void)
 518 {
 519   CheckCopyCtorP<Vector2> check( Vector2(2,1) );
 520   END_TEST;
 521 }
 522
 523 int UtcDaliPropertyValueCopyConstructorVector3P(void)
 524 {
 525   CheckCopyCtorP<Vector3> check( Vector3(3.f,2.f,1.f) );
 526   END_TEST;
 527 }
 528
 529 int UtcDaliPropertyValueCopyConstructorVector4P(void)
 530 {
 531   CheckCopyCtorP<Vector3> check( Vector4(4.f,3.f,2.f,1.f) );
 532   END_TEST;
 533 }
 534
 535 int UtcDaliPropertyValueCopyConstructorMatrix3P(void)
 536 {
 537   CheckCopyCtorP<Matrix3> check( Matrix3::IDENTITY );
 538   END_TEST;
 539 }
 540
 541 int UtcDaliPropertyValueCopyConstructorMatrixP(void)
 542 {
 543   CheckCopyCtorP<Matrix> check(Matrix::IDENTITY);
 544   END_TEST;
 545 }
 546
 547 int UtcDaliPropertyValueCopyConstructorRectP(void)
 548 {
 549   CheckCopyCtorP<Rect<int> > check( Rect<int>(1.0,1.0,1.0,1.0) );
 550   END_TEST;
 551 }
 552
 553 int UtcDaliPropertyValueCopyConstructorAngleAxisP(void)
 554 {
 555   CheckCopyCtorP<AngleAxis> check( AngleAxis(Degree(1.0), Vector3(1.0,1.0,1.0)) );
 556   END_TEST;
 557 }
 558
 559 int UtcDaliPropertyValueCopyConstructorQuaternionP(void)
 560 {
 561   CheckCopyCtorP<Quaternion> check( Quaternion( Vector4(1.0, 1.0, 1.0, 1.0) ) );
 562   END_TEST;
 563 }
 564
 565 int UtcDaliPropertyValueCopyConstructorStringP(void)
 566 {
 567   CheckCopyCtorP<std::string> check( std::string("1") );
 568   END_TEST;
 569 }
 570
 571 int UtcDaliPropertyValueCopyConstructorArrayP(void)
 572 {
 573   Property::Value value1(Property::ARRAY);
 574   Property::Array* array= value1.GetArray();
 575   array->PushBack(Property::Value(1));
 576
 577   Property::Value value2( value1 );
 578   DALI_TEST_EQUALS( value1.GetType(), value2.GetType(), TEST_LOCATION );
 579   DALI_TEST_EQUALS( value1.GetArray()->Count(), value2.GetArray()->Count(), TEST_LOCATION );
 580
 581   END_TEST;
 582 }
 583
 584 int UtcDaliPropertyValueCopyConstructorMapP(void)
 585 {
 586   Property::Value value1(Property::MAP);
 587   Property::Map* map = value1.GetMap();
 588   (*map)["1"] = Property::Value(1);
 589
 590   Property::Value value2( value1 );
 591   DALI_TEST_EQUALS( value1.GetType(), value2.GetType(), TEST_LOCATION );
 592   DALI_TEST_EQUALS( value1.GetMap()->Count(), value2.GetMap()->Count(), TEST_LOCATION );
 593   DALI_TEST_EQUALS( value1.GetMap()->GetKey( 0 ), value2.GetMap()->GetKey( 0 ), TEST_LOCATION );
 594
 595   END_TEST;
 596 }
 597
 598 int UtcDaliPropertyValueAssignmentSelfP(void)
 599 {
 600   Property::Value value;
 601   Property::Value* self = &value;
 602   value = *self;
 603   DALI_TEST_EQUALS( value.GetType(), Property::NONE, TEST_LOCATION );
 604   DALI_TEST_CHECK( value.GetMap() == NULL );
 605   DALI_TEST_CHECK( value.GetArray() == NULL );
 606   END_TEST;
 607 }
 608
 609 int UtcDaliPropertyValueAssignmentOperatorNoneP(void)
 610 {
 611   Property::Value value;
 612   value = Property::Value(); // type match
 613   DALI_TEST_EQUALS( value.GetType(), Property::NONE, TEST_LOCATION );
 614   Property::Value copy( false );
 615   copy = value; // type mismatch
 616   DALI_TEST_EQUALS( value.GetType(), Property::NONE, TEST_LOCATION );
 617   END_TEST;
 618 }
 619
 620 int UtcDaliPropertyValueAssignmentOperatorBoolP(void)
 621 {
 622   Property::Value value;
 623   value = Property::Value(true); // type mismatch
 624   DALI_TEST_CHECK( true == value.Get<bool>() );
 625   Property::Value copy( false );
 626   copy = value; // type match
 627   DALI_TEST_CHECK( true == copy.Get<bool>() );
 628   END_TEST;
 629 }
 630
 631 int UtcDaliPropertyValueAssignmentOperatorIntP(void)
 632 {
 633   Property::Value value;
 634   value = Property::Value(10); // type mismatch
 635   DALI_TEST_CHECK( 10 == value.Get<int>() );
 636   Property::Value copy( 99 );
 637   copy = value; // type match
 638   DALI_TEST_CHECK( 10 == copy.Get<int>() );
 639   END_TEST;
 640 }
 641
 642 int UtcDaliPropertyValueAssignmentOperatorUnsignedIntP(void)
 643 {
 644   Property::Value value;
 645   value = Property::Value(10U); // type mismatch
 646   DALI_TEST_CHECK( 10U == value.Get<unsigned int>() );
 647   Property::Value copy( 123U);
 648   copy = value; // type match
 649   DALI_TEST_CHECK( 10U == copy.Get<unsigned int>() );
 650   END_TEST;
 651 }
 652
 653 int UtcDaliPropertyValueAssignmentOperatorFloatP(void)
 654 {
 655   Property::Value value;
 656   value = Property::Value(10.f); // mismatch
 657   DALI_TEST_CHECK( Dali::Equals(10.f, value.Get<float>() ) );
 658   Property::Value copy(321.f);
 659   copy = value; // match
 660   DALI_TEST_CHECK( Dali::Equals(10.f, copy.Get<float>() ) );
 661   END_TEST;
 662 }
 663
 664 int UtcDaliPropertyValueAssignmentOperatorVector2P(void)
 665 {
 666   Property::Value value;
 667   value = Property::Value( Vector2(1,2) ); // mismatch
 668   DALI_TEST_CHECK( Vector2(1,2) == value.Get<Vector2>() );
 669   Property::Value copy( Property::VECTOR2 );
 670   copy = value; // match
 671   DALI_TEST_CHECK( Vector2(1,2) == copy.Get<Vector2>() );
 672   END_TEST;
 673 }
 674
 675 int UtcDaliPropertyValueAssignmentOperatorVector3P(void)
 676 {
 677   Property::Value value;
 678   value = Property::Value( Vector3(1.f,2.f,3.f) ); // mismatch
 679   DALI_TEST_CHECK( Vector3(1.f,2.f,3.f) == value.Get<Vector3>() );
 680   Property::Value copy( Property::VECTOR3 );
 681   copy = value; // match
 682   DALI_TEST_CHECK( Vector3(1.f,2.f,3.f) == copy.Get<Vector3>() );
 683   END_TEST;
 684 }
 685
 686 int UtcDaliPropertyValueAssignmentOperatorVector4P(void)
 687 {
 688   Property::Value value;
 689   value = Property::Value( Vector4(1,2,3,4) ); // mismatch
 690   DALI_TEST_CHECK( Vector4(1,2,3,4) == value.Get<Vector4>() );
 691   Property::Value copy( Vector4(0,1,2,3) );
 692   copy = value; // match
 693   DALI_TEST_CHECK( Vector4(1,2,3,4) == copy.Get<Vector4>() );
 694   END_TEST;
 695 }
 696
 697 int UtcDaliPropertyValueAssignmentOperatorMatrix3P(void)
 698 {
 699   Property::Value value;
 700   value = Property::Value( Matrix3::IDENTITY ); // mismatch
 701   DALI_TEST_CHECK( Matrix3::IDENTITY == value.Get<Matrix3>() );
 702   Property::Value copy( Property::MATRIX3 );
 703   copy = value; // match
 704   DALI_TEST_CHECK( Matrix3::IDENTITY == copy.Get<Matrix3>() );
 705   END_TEST;
 706 }
 707
 708 int UtcDaliPropertyValueAssignmentOperatorMatrixP(void)
 709 {
 710   Property::Value value;
 711   value = Property::Value( Matrix::IDENTITY ); // mismatch
 712   DALI_TEST_CHECK( Matrix::IDENTITY == value.Get<Matrix>()  );
 713   Matrix foo;
 714   Property::Value copy( foo );
 715   copy = value; // match
 716   DALI_TEST_CHECK( Matrix::IDENTITY == copy.Get<Matrix>()  );
 717   END_TEST;
 718 }
 719
 720 int UtcDaliPropertyValueAssignmentOperatorRectP(void)
 721 {
 722   Property::Value value;
 723   typedef Dali::Rect<int> Rectangle;
 724   value = Property::Value( Rectangle(4,3,2,1) ); // mismatch
 725   DALI_TEST_CHECK( Rectangle(4,3,2,1) == value.Get<Rectangle>() );
 726   Property::Value copy( Property::RECTANGLE );
 727   copy = value; // match
 728   Rectangle copyRect;
 729   copy.Get(copyRect);
 730   DALI_TEST_CHECK( Rectangle(4,3,2,1) == copyRect );
 731   END_TEST;
 732 }
 733
 734 int UtcDaliPropertyValueAssignmentOperatorQuaternionP(void)
 735 {
 736   Property::Value value;
 737   value = Property::Value( Quaternion(1,1,1,1) ); // mismatch
 738   DALI_TEST_CHECK( Quaternion(1,1,1,1) == value.Get<Quaternion>() );
 739   Property::Value copy( Property::ROTATION );
 740   copy = value; // match
 741   DALI_TEST_CHECK( Quaternion(1,1,1,1) == copy.Get<Quaternion>() );
 742   END_TEST;
 743 }
 744
 745
 746 int UtcDaliPropertyValueAssignmentOperatorAngleAxisP(void)
 747 {
 748   Property::Value value;
 749   value = Property::Value( AngleAxis( Radian(Math::PI_2), Vector3::XAXIS ) ); // mismatch
 750   DALI_TEST_EQUALS( value.Get<AngleAxis>().axis, Vector3::XAXIS, TEST_LOCATION );
 751   DALI_TEST_EQUALS( value.Get<AngleAxis>().angle, Radian(Math::PI_2), TEST_LOCATION );
 752   Property::Value copy( Property::ROTATION );
 753   copy = value; // match
 754   DALI_TEST_EQUALS( value.Get<AngleAxis>().axis, copy.Get<AngleAxis>().axis, TEST_LOCATION );
 755   DALI_TEST_EQUALS( value.Get<AngleAxis>().angle, copy.Get<AngleAxis>().angle, TEST_LOCATION );
 756   END_TEST;
 757 }
 758
 759 int UtcDaliPropertyValueAssignmentOperatorStringP(void)
 760 {
 761   Property::Value value;
 762   value = Property::Value("yes"); // mismatch
 763   DALI_TEST_CHECK( "yes" == value.Get<std::string>() );
 764   Property::Value copy("no");
 765   copy = value; // match
 766   DALI_TEST_CHECK( "yes" == copy.Get<std::string>() );
 767   END_TEST;
 768 }
 769
 770 int UtcDaliPropertyValueAssignmentOperatorArrayP(void)
 771 {
 772   Property::Value value;
 773   value = Property::Value(Property::ARRAY); // mismatch
 774   value.GetArray()->PushBack(10);
 775   DALI_TEST_CHECK( value.GetArray() );
 776   Property::Value copy(Property::ARRAY);
 777   copy = value; // match
 778   Property::Array array;
 779   copy.Get( array );
 780   int getItem = 0;
 781   array[0].Get( getItem );
 782   DALI_TEST_CHECK( getItem == 10 );
 783   END_TEST;
 784 }
 785
 786 int UtcDaliPropertyValueAssignmentOperatorMapP(void)
 787 {
 788   Property::Value value;
 789   value = Property::Value(Property::MAP); // mismatch
 790   value.GetMap()->Insert("key", "value");
 791   Property::Value copy( Property::MAP ); // match
 792   copy = value;
 793   Property::Map map;
 794   copy.Get( map );
 795   DALI_TEST_CHECK( map.GetKey(0) == "key" );
 796   END_TEST;
 797 }
 798
 799 int UtcDaliPropertyValueGetTypeP(void)
 800 {
 801   Property::Value value;
 802   DALI_TEST_CHECK( value.GetType() == Property::NONE );
 803   END_TEST;
 804 }
 805
 806 int UtcDaliPropertyValueGetBoolP(void)
 807 {
 808   Property::Value value(true);
 809   bool boolean( false );
 810   DALI_TEST_CHECK( value.Get( boolean ) == true );
 811   DALI_TEST_CHECK( value.Get<bool>() == true );
 812   std::string string;
 813   DALI_TEST_CHECK( value.Get( string ) == false );
 814   value = Property::Value(1.f);
 815   DALI_TEST_CHECK( value.Get<float>() == 1.f );
 816   END_TEST;
 817 }
 818
 819 int UtcDaliPropertyValueGetBoolN(void)
 820 {
 821   Property::Value value;
 822   DALI_TEST_CHECK( value.Get<bool>() == false );
 823   bool boolean( false );
 824   DALI_TEST_CHECK( value.Get( boolean ) == false );
 825   END_TEST;
 826 }
 827
 828 int UtcDaliPropertyValueGetFloatP(void)
 829 {
 830   Property::Value value(1.1f);
 831   float flow( 0.0f );
 832   DALI_TEST_EQUALS( 1.1f, value.Get<float>(), TEST_LOCATION );
 833   DALI_TEST_EQUALS( true, value.Get( flow ), TEST_LOCATION );
 834   DALI_TEST_EQUALS( 1.1f, flow, TEST_LOCATION );
 835
 836   Property::Value intValue(100);
 837   DALI_TEST_EQUALS( 100.f, intValue.Get<float>(), TEST_LOCATION );
 838   DALI_TEST_EQUALS( true, intValue.Get( flow ), TEST_LOCATION );
 839   DALI_TEST_EQUALS( 100.f, flow, TEST_LOCATION );
 840
 841   END_TEST;
 842 }
 843
 844 int UtcDaliPropertyValueGetFloatN(void)
 845 {
 846   Property::Value value;
 847   float result( 1.0f );
 848   DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
 849   DALI_TEST_EQUALS( 1.0f, result, TEST_LOCATION ); // result is not modified
 850   Property::Value value2( "" );
 851   DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
 852   DALI_TEST_EQUALS( 1.0f, result, TEST_LOCATION ); // result is not modified
 853   END_TEST;
 854 }
 855
 856 int UtcDaliPropertyValueGetIntP(void)
 857 {
 858   Property::Value value(123);
 859   int result( 10 );
 860   DALI_TEST_EQUALS( 123, value.Get<int>(), TEST_LOCATION );
 861   DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
 862   DALI_TEST_EQUALS( 123, result, TEST_LOCATION );
 863
 864   Property::Value floatValue(21.f);
 865   DALI_TEST_EQUALS( 21, floatValue.Get<int>(), TEST_LOCATION );
 866   DALI_TEST_EQUALS( true, floatValue.Get( result ), TEST_LOCATION );
 867   DALI_TEST_EQUALS( 21, result, TEST_LOCATION );
 868
 869   END_TEST;
 870 }
 871
 872 int UtcDaliPropertyValueGetIntN(void)
 873 {
 874   Property::Value value;
 875   int result( 10 );
 876   DALI_TEST_EQUALS( 0, value.Get<int>(), TEST_LOCATION );
 877   DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
 878   DALI_TEST_EQUALS( 10, result, TEST_LOCATION ); // result is not modified
 879   Property::Value value2("");
 880   DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
 881   DALI_TEST_EQUALS( 10, result, TEST_LOCATION ); // result is not modified
 882   END_TEST;
 883 }
 884
 885 int UtcDaliPropertyValueGetUnsignedIntP(void)
 886 {
 887   Property::Value value(123u);
 888   unsigned int result( 10u );
 889   DALI_TEST_EQUALS( 123u, value.Get<unsigned int>(), TEST_LOCATION );
 890   DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
 891   DALI_TEST_EQUALS( 123u, result, TEST_LOCATION );
 892   END_TEST;
 893 }
 894
 895 int UtcDaliPropertyValueGetUnsignedIntN(void)
 896 {
 897   Property::Value value;
 898   unsigned int result( 10u );
 899   DALI_TEST_EQUALS( 0u, value.Get<unsigned int>(), TEST_LOCATION );
 900   DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
 901   DALI_TEST_EQUALS( 10u, result, TEST_LOCATION );
 902   Property::Value value2("");
 903   DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
 904   DALI_TEST_EQUALS( 10u, result, TEST_LOCATION ); // result is not modified
 905   END_TEST;
 906 }
 907
 908 int UtcDaliPropertyValueGetRectP(void)
 909 {
 910   Property::Value value( Rect<int>(1,2,3,4) );
 911   Rect<int> result(4,3,2,1);
 912   DALI_TEST_EQUALS( Rect<int>(1,2,3,4), value.Get< Rect<int> >(), TEST_LOCATION );
 913   DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
 914   DALI_TEST_EQUALS( Rect<int>(1,2,3,4), result, TEST_LOCATION );
 915   END_TEST;
 916 }
 917
 918 int UtcDaliPropertyValueGetRectN(void)
 919 {
 920   Property::Value value;
 921   Rect<int> result(4,3,2,1);
 922   DALI_TEST_EQUALS( Rect<int>(0,0,0,0), value.Get< Rect<int> >(), TEST_LOCATION );
 923   DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
 924   DALI_TEST_EQUALS( Rect<int>(4,3,2,1), result, TEST_LOCATION );
 925   Property::Value value2("");
 926   DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
 927   DALI_TEST_EQUALS( Rect<int>(4,3,2,1), result, TEST_LOCATION );
 928   END_TEST;
 929 }
 930
 931 int UtcDaliPropertyValueGetVector2P(void)
 932 {
 933   Property::Value value( Vector2(1.0f,2.0f) );
 934   Vector2 result;
 935   DALI_TEST_EQUALS( Vector2(1.0f,2.0f), value.Get< Vector2 >(), TEST_LOCATION );
 936   DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
 937   DALI_TEST_EQUALS( Vector2(1.0f,2.0f), result, TEST_LOCATION );
 938   END_TEST;
 939 }
 940
 941 int UtcDaliPropertyValueGetVector2N(void)
 942 {
 943   Property::Value value;
 944   Vector2 result;
 945   DALI_TEST_EQUALS( Vector2(0.f,0.f), value.Get< Vector2 >(), TEST_LOCATION );
 946   DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
 947   DALI_TEST_EQUALS( Vector2(), result, TEST_LOCATION );
 948   Property::Value value2("");
 949   DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
 950   DALI_TEST_EQUALS( Vector2(), result, TEST_LOCATION );
 951   END_TEST;
 952 }
 953
 954 int UtcDaliPropertyValueGetVector3P(void)
 955 {
 956   Property::Value value( Vector3(1.0f,2.0f,-1.f) );
 957   Vector3 result;
 958   DALI_TEST_EQUALS( Vector3(1.0f,2.0f,-1.f), value.Get< Vector3 >(), TEST_LOCATION );
 959   DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
 960   DALI_TEST_EQUALS( Vector3(1.0f,2.0f,-1.f), result, TEST_LOCATION );
 961   END_TEST;
 962 }
 963
 964 int UtcDaliPropertyValueGetVector3N(void)
 965 {
 966   Property::Value value;
 967   Vector3 result;
 968   DALI_TEST_EQUALS( Vector3(0.f,0.f,0.f), value.Get< Vector3 >(), TEST_LOCATION );
 969   DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
 970   DALI_TEST_EQUALS( Vector3(), result, TEST_LOCATION );
 971   Property::Value value2("");
 972   DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
 973   DALI_TEST_EQUALS( Vector3(), result, TEST_LOCATION );
 974   END_TEST;
 975 }
 976
 977 int UtcDaliPropertyValueGetVector4P(void)
 978 {
 979   Property::Value value( Vector4(1.f,2.f,-1.f,-3.f) );
 980   Vector4 result;
 981   DALI_TEST_EQUALS( Vector4(1.f,2.f,-1.f,-3.f), value.Get< Vector4 >(), TEST_LOCATION );
 982   DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
 983   DALI_TEST_EQUALS( Vector4(1.f,2.f,-1.f,-3.f), result, TEST_LOCATION );
 984   END_TEST;
 985 }
 986
 987 int UtcDaliPropertyValueGetVector4N(void)
 988 {
 989   Property::Value value;
 990   Vector4 result;
 991   DALI_TEST_EQUALS( Vector4(0.f,0.f,0.f,0.f), value.Get< Vector4 >(), TEST_LOCATION );
 992   DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
 993   DALI_TEST_EQUALS( Vector4(), result, TEST_LOCATION );
 994   Property::Value value2("");
 995   DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
 996   DALI_TEST_EQUALS( Vector4(), result, TEST_LOCATION );
 997   END_TEST;
 998 }
 999
1000 int UtcDaliPropertyValueGetMatrix3P(void)
1001 {
1002   Property::Value value( Matrix3(1.f,2.f,3.f,4.f,5.f,6.f,7.f,8.f,9.f) );
1003   Matrix3 result;
1004   DALI_TEST_EQUALS( Matrix3(1.f,2.f,3.f,4.f,5.f,6.f,7.f,8.f,9.f), value.Get< Matrix3 >(), TEST_LOCATION );
1005   DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
1006   DALI_TEST_EQUALS( Matrix3(1.f,2.f,3.f,4.f,5.f,6.f,7.f,8.f,9.f), result, TEST_LOCATION );
1007   END_TEST;
1008 }
1009
1010 int UtcDaliPropertyValueGetMatrix3N(void)
1011 {
1012   Property::Value value;
1013   Matrix3 result(1.f,2.f,3.f,4.f,5.f,6.f,7.f,8.f,9.f);
1014   DALI_TEST_EQUALS( Matrix3(), value.Get< Matrix3 >(), TEST_LOCATION );
1015   DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
1016   DALI_TEST_EQUALS( Matrix3(1.f,2.f,3.f,4.f,5.f,6.f,7.f,8.f,9.f), result, TEST_LOCATION );
1017   Property::Value value2("");
1018   DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
1019   DALI_TEST_EQUALS( Matrix3(1.f,2.f,3.f,4.f,5.f,6.f,7.f,8.f,9.f), result, TEST_LOCATION );
1020   END_TEST;
1021 }
1022
1023 int UtcDaliPropertyValueGetMatrixP(void)
1024 {
1025   float matrixValues[16] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 };
1026   Matrix input( matrixValues );
1027   Property::Value value( input );
1028   Matrix result;
1029   DALI_TEST_EQUALS( input, value.Get< Matrix >(), TEST_LOCATION );
1030   DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
1031   DALI_TEST_EQUALS( input, result, TEST_LOCATION );
1032   END_TEST;
1033 }
1034
1035 int UtcDaliPropertyValueGetMatrixN(void)
1036 {
1037   Property::Value value;
1038   Matrix result( Matrix::IDENTITY );
1039   DALI_TEST_EQUALS( Matrix(), value.Get< Matrix >(), TEST_LOCATION );
1040   DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
1041   DALI_TEST_EQUALS( Matrix::IDENTITY, result, TEST_LOCATION );
1042
1043   Property::Value value2("");
1044   DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
1045   DALI_TEST_EQUALS( Matrix::IDENTITY, result, TEST_LOCATION );
1046   END_TEST;
1047 }
1048
1049 int UtcDaliPropertyValueGetAngleAxisP(void)
1050 {
1051   AngleAxis input( Dali::ANGLE_90, Vector3::XAXIS );
1052   Property::Value value( input );
1053   AngleAxis result = value.Get<AngleAxis>();
1054   DALI_TEST_EQUALS( input.angle, result.angle, TEST_LOCATION );
1055   DALI_TEST_EQUALS( input.axis, result.axis, TEST_LOCATION );
1056
1057   DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
1058   DALI_TEST_EQUALS( input, result, TEST_LOCATION );
1059   END_TEST;
1060 }
1061
1062 int UtcDaliPropertyValueGetAngleAxisN(void)
1063 {
1064   Property::Value value;
1065   AngleAxis b = value.Get<AngleAxis>();
1066   AngleAxis result;
1067   DALI_TEST_EQUALS( 0.f, b.angle, TEST_LOCATION );
1068   DALI_TEST_EQUALS( Vector3::ZERO, b.axis, TEST_LOCATION );
1069   DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
1070   DALI_TEST_EQUALS( AngleAxis(), result, TEST_LOCATION );
1071
1072   Property::Value value2("");
1073   DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
1074   DALI_TEST_EQUALS( AngleAxis(), result, TEST_LOCATION );
1075   END_TEST;
1076 }
1077
1078 int UtcDaliPropertyValueGetQuaternionP(void)
1079 {
1080   Property::Value value( Quaternion(1.f,2.f,3.f,4.f) );
1081   Quaternion result;
1082   DALI_TEST_EQUALS( Quaternion(1.f,2.f,3.f,4.f), value.Get< Quaternion >(), TEST_LOCATION );
1083   DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
1084   DALI_TEST_EQUALS( Quaternion(1.f,2.f,3.f,4.f), result, TEST_LOCATION );
1085   END_TEST;
1086 }
1087
1088 int UtcDaliPropertyValueGetQuaternionN(void)
1089 {
1090   Property::Value value;
1091   Quaternion result(1.f,2.f,3.f,4.f);
1092   DALI_TEST_EQUALS( Quaternion(), value.Get< Quaternion >(), TEST_LOCATION );
1093   DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
1094   DALI_TEST_EQUALS( Quaternion(1.f,2.f,3.f,4.f), result, TEST_LOCATION );
1095
1096   Property::Value value2("");
1097   DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
1098   DALI_TEST_EQUALS( Quaternion(1.f,2.f,3.f,4.f), result, TEST_LOCATION );
1099   END_TEST;
1100 }
1101
1102 int UtcDaliPropertyValueGetStringP(void)
1103 {
1104   Property::Value value( std::string("hello") );
1105   std::string result;
1106   DALI_TEST_EQUALS( std::string("hello"), value.Get< std::string >(), TEST_LOCATION );
1107   DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
1108   DALI_TEST_EQUALS( std::string("hello"), result, TEST_LOCATION );
1109
1110   Property::Value value2( "C hi!" );
1111   DALI_TEST_EQUALS( "C hi!", value2.Get< std::string >(), TEST_LOCATION );
1112   DALI_TEST_EQUALS( true, value2.Get( result ), TEST_LOCATION );
1113   DALI_TEST_EQUALS( "C hi!", result, TEST_LOCATION );
1114   END_TEST;
1115 }
1116
1117 int UtcDaliPropertyValueGetStringN(void)
1118 {
1119   Property::Value value;
1120   std::string result("doesn't change");
1121   DALI_TEST_EQUALS( std::string(), value.Get< std::string >(), TEST_LOCATION );
1122   DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
1123   DALI_TEST_EQUALS( "doesn't change", result, TEST_LOCATION );
1124
1125   Property::Value value2(10);
1126   DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
1127   DALI_TEST_EQUALS( "doesn't change", result, TEST_LOCATION );
1128
1129   Property::Value value3((char*)NULL);
1130   DALI_TEST_EQUALS( true, value3.Get( result ), TEST_LOCATION );
1131   DALI_TEST_EQUALS( std::string(), result, TEST_LOCATION );
1132   END_TEST;
1133 }
1134
1135 int UtcDaliPropertyValueGetArrayP(void)
1136 {
1137   Property::Value value( Property::ARRAY );
1138   DALI_TEST_CHECK( NULL != value.GetArray() );
1139   value.GetArray()->PushBack( Property::Value(1) );
1140   Property::Array got = value.Get<Property::Array>();
1141   DALI_TEST_CHECK( got[0].Get<int>() == 1);
1142   Property::Array result;
1143   DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
1144   DALI_TEST_CHECK( result[0].Get<int>() == 1);
1145   END_TEST;
1146 }
1147
1148 int UtcDaliPropertyValueGetArrayN(void)
1149 {
1150   Property::Value value;
1151   DALI_TEST_CHECK( NULL == value.GetArray() );
1152   Property::Array result;
1153   result.PushBack( Property::Value( 10 ) );
1154   DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
1155   DALI_TEST_EQUALS( 1, result.Count(), TEST_LOCATION  ); // array is not modified
1156
1157   Property::Value value2("");
1158   DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
1159   DALI_TEST_EQUALS( 1, result.Count(), TEST_LOCATION  ); // array is not modified
1160   END_TEST;
1161 }
1162
1163 int UtcDaliPropertyValueGetMapP(void)
1164 {
1165   Property::Value value(Property::MAP);
1166   DALI_TEST_CHECK( NULL == value.GetArray() );
1167   DALI_TEST_CHECK( NULL != value.GetMap() );
1168   value.GetMap()->Insert("key", Property::Value(1));
1169   Property::Map result = value.Get<Property::Map>();
1170   DALI_TEST_CHECK(result.Find("key")->Get<int>() == 1);
1171   DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
1172   DALI_TEST_CHECK(result.Find("key")->Get<int>() == 1);
1173   END_TEST;
1174 }
1175
1176 int UtcDaliPropertyValueGetMapN(void)
1177 {
1178   Property::Value value;
1179   DALI_TEST_CHECK( NULL == value.GetMap() );
1180   DALI_TEST_EQUALS( 0, value.Get<Property::Map>().Count(), TEST_LOCATION );
1181   Property::Map result;
1182   result.Insert("key", "value" );
1183   DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
1184   DALI_TEST_EQUALS( 1, result.Count(), TEST_LOCATION );
1185
1186   Property::Value value2("");
1187   DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
1188   DALI_TEST_EQUALS( 1, result.Count(), TEST_LOCATION  ); // array is not modified
1189   END_TEST;
1190 }
1191
1192 int UtcDaliPropertyValueOutputStream(void)
1193 {
1194   TestApplication application;
1195   tet_infoline("Testing Property::Value output stream");
1196   typedef Dali::Rect<int> Rectangle;
1197
1198   Property::Value value(true);
1199   {
1200     std::ostringstream stream;
1201     stream << value;
1202     DALI_TEST_CHECK( stream.str() == "1" )
1203   }
1204
1205   {
1206     Property::Value empty;
1207     std::ostringstream stream;
1208     stream << empty;
1209     DALI_TEST_EQUALS( stream.str(), "empty type", TEST_LOCATION );
1210   }
1211
1212   {
1213     Property::Value empty( Property::NONE );
1214     std::ostringstream stream;
1215     stream << empty;
1216     DALI_TEST_CHECK( stream.str() == "undefined type" )
1217   }
1218
1219   {
1220     value = Property::Value(20.2f);
1221     std::ostringstream stream;
1222     stream <<  value;
1223     DALI_TEST_CHECK( stream.str() == "20.2" )
1224   }
1225
1226   {
1227     value = Property::Value(-25);
1228     std::ostringstream stream;
1229     stream <<  value;
1230     DALI_TEST_CHECK( stream.str() == "-25" )
1231   }
1232
1233   {
1234     value = Property::Value(25U);
1235     std::ostringstream stream;
1236     stream <<  value;
1237     DALI_TEST_CHECK( stream.str() == "25" )
1238   }
1239
1240   {
1241     value = Property::Value( Vector2(1.f,1.f) );
1242     std::ostringstream stream;
1243     stream <<  value;
1244     DALI_TEST_CHECK( stream.str() == "[1, 1]" );
1245   }
1246
1247   {
1248     value = Property::Value( Vector3(1.f,1.f,1.f) );
1249     std::ostringstream stream;
1250     stream <<  value;
1251     DALI_TEST_CHECK( stream.str() == "[1, 1, 1]" );
1252   }
1253
1254   {
1255     value = Property::Value( Vector4(-4.f,-3.f,-2.f,-1.f) );
1256     std::ostringstream stream;
1257     stream <<  value;
1258     DALI_TEST_EQUALS( stream.str(), "[-4, -3, -2, -1]", TEST_LOCATION );
1259   }
1260
1261   {
1262     value = Property::Value( Matrix3::IDENTITY );
1263     std::ostringstream stream;
1264     stream <<  value;
1265     DALI_TEST_CHECK( stream.str() == "[ [1, 0, 0], [0, 1, 0], [0, 0, 1] ]" );
1266   }
1267
1268   {
1269     value = Property::Value( Matrix::IDENTITY );
1270     std::ostringstream stream;
1271     stream <<  value;
1272     DALI_TEST_CHECK( stream.str() == "[ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1] ]" );
1273   }
1274
1275   {
1276     value = Property::Value( Rectangle(1,2,3,4) );
1277     std::ostringstream stream;
1278     stream <<  value;
1279     DALI_TEST_CHECK( stream.str() == "[1, 2, 3, 4]" );
1280   }
1281
1282   {
1283     value = Property::Value( AngleAxis( Dali::ANGLE_120, Vector3::XAXIS ) );
1284     std::ostringstream stream;
1285     stream <<  value;
1286     tet_printf("angle axis = %s \n", stream.str().c_str() );
1287     DALI_TEST_EQUALS( stream.str(), "[ Axis: [1, 0, 0], Angle: 120 degrees ]", TEST_LOCATION );
1288   }
1289
1290   {
1291     value = Property::Value( std::string( "Foo" ) );
1292     std::ostringstream stream;
1293     stream <<  value;
1294     DALI_TEST_CHECK( stream.str() == "Foo" );
1295   }
1296
1297   // Maps and arrays currently not supported, we just check a message is output
1298   {
1299     Property::Map map;
1300     value = Property::Value( map );
1301     std::ostringstream stream;
1302     stream <<  value;
1303     DALI_TEST_CHECK( !stream.str().empty() );
1304   }
1305   {
1306     Property::Array array;
1307     value = Property::Value( array );
1308     std::ostringstream stream;
1309     stream <<  value;
1310     DALI_TEST_CHECK( !stream.str().empty() );
1311   }
1312
1313   END_TEST;
1314 }