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

   1 /*
   2  * Copyright (c) 2023 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 <dali-test-suite-utils.h>
  19 #include <dali/public-api/dali-core.h>
  20 #include <stdlib.h>
  21
  22 #include <iomanip>
  23 #include <iostream>
  24
  25 using namespace Dali;
  26
  27 namespace
  28 {
  29 template<typename T>
  30 struct CheckCopyCtorP
  31 {
  32   CheckCopyCtorP(Property::Value value)
  33   {
  34     Property::Value copy(value);
  35     DALI_TEST_CHECK(value.Get<T>() == copy.Get<T>());
  36   }
  37 };
  38
  39 } // unnamed namespace
  40
  41 void utc_dali_property_value_startup(void)
  42 {
  43   test_return_value = TET_UNDEF;
  44 }
  45
  46 void utc_dali_property_value_cleanup(void)
  47 {
  48   test_return_value = TET_PASS;
  49 }
  50
  51 int UtcDaliPropertyValueConstructorsNoneP(void)
  52 {
  53   Property::Value value;
  54
  55   DALI_TEST_CHECK(value.GetType() == Property::NONE);
  56
  57   END_TEST;
  58 }
  59
  60 int UtcDaliPropertyValueConstructorsNoneTypeP(void)
  61 {
  62   Property::Value value(Property::NONE);
  63
  64   DALI_TEST_CHECK(value.GetType() == Property::NONE);
  65
  66   END_TEST;
  67 }
  68
  69 int UtcDaliPropertyValueConstructorsBoolP(void)
  70 {
  71   Property::Value value(true);
  72
  73   DALI_TEST_CHECK(value.GetType() == Property::BOOLEAN);
  74   DALI_TEST_CHECK(value.Get<bool>() == true);
  75
  76   END_TEST;
  77 }
  78
  79 int UtcDaliPropertyValueConstructorBoolTypeP(void)
  80 {
  81   Property::Value value(Property::BOOLEAN);
  82
  83   DALI_TEST_CHECK(value.GetType() == Property::BOOLEAN);
  84   DALI_TEST_CHECK(value.Get<bool>() == false);
  85
  86   END_TEST;
  87 }
  88
  89 int UtcDaliPropertyValueConstructorsFloatP(void)
  90 {
  91   Property::Value value(2.f);
  92
  93   DALI_TEST_CHECK(value.GetType() == Property::FLOAT);
  94   DALI_TEST_CHECK(value.Get<float>() == 2.f);
  95
  96   END_TEST;
  97 }
  98
  99 int UtcDaliPropertyValueConstructorsFloatTypeP(void)
 100 {
 101   Property::Value value(Property::FLOAT);
 102
 103   DALI_TEST_CHECK(value.GetType() == Property::FLOAT);
 104   DALI_TEST_CHECK(value.Get<float>() == 0.f);
 105
 106   END_TEST;
 107 }
 108
 109 int UtcDaliPropertyValueConstructorsIntP(void)
 110 {
 111   Property::Value value(1);
 112
 113   DALI_TEST_CHECK(value.GetType() == Property::INTEGER);
 114   DALI_TEST_CHECK(value.Get<int>() == 1);
 115
 116   END_TEST;
 117 }
 118
 119 int UtcDaliPropertyValueConstructorsIntTypeP(void)
 120 {
 121   Property::Value value(Property::INTEGER);
 122
 123   DALI_TEST_CHECK(value.GetType() == Property::INTEGER);
 124   DALI_TEST_CHECK(value.Get<int>() == 0);
 125
 126   END_TEST;
 127 }
 128
 129 int UtcDaliPropertyValueConstructorsVector2P(void)
 130 {
 131   Vector2         v(1, 1);
 132   Property::Value value(v);
 133
 134   DALI_TEST_CHECK(value.GetType() == Property::VECTOR2);
 135   DALI_TEST_CHECK(value.Get<Vector2>() == v);
 136
 137   END_TEST;
 138 }
 139
 140 int UtcDaliPropertyValueConstructorsVector2TypeP(void)
 141 {
 142   Property::Value value(Property::VECTOR2);
 143
 144   DALI_TEST_CHECK(value.GetType() == Property::VECTOR2);
 145   DALI_TEST_CHECK(value.Get<Vector2>() == Vector2::ZERO);
 146
 147   END_TEST;
 148 }
 149
 150 int UtcDaliPropertyValueConstructorsVector3P(void)
 151 {
 152   Vector3         v(1.f, 2.f, 3.f);
 153   Property::Value value(v);
 154
 155   DALI_TEST_CHECK(value.GetType() == Property::VECTOR3);
 156   DALI_TEST_CHECK(value.Get<Vector3>() == v);
 157
 158   END_TEST;
 159 }
 160
 161 int UtcDaliPropertyValueConstructorsVector3TypeP(void)
 162 {
 163   Property::Value value(Property::VECTOR3);
 164
 165   DALI_TEST_CHECK(value.GetType() == Property::VECTOR3);
 166   DALI_TEST_CHECK(value.Get<Vector3>() == Vector3());
 167
 168   END_TEST;
 169 }
 170
 171 int UtcDaliPropertyValueConstructorsVector4P(void)
 172 {
 173   Vector4         v(1.f, 1.f, 1.f, 0.9f);
 174   Property::Value value(v);
 175
 176   DALI_TEST_CHECK(value.GetType() == Property::VECTOR4);
 177   DALI_TEST_CHECK(value.Get<Vector4>() == v);
 178
 179   END_TEST;
 180 }
 181
 182 int UtcDaliPropertyValueConstructorsVector4TypeP(void)
 183 {
 184   Property::Value value(Property::VECTOR4);
 185
 186   DALI_TEST_CHECK(value.GetType() == Property::VECTOR4);
 187   DALI_TEST_CHECK(value.Get<Vector4>() == Vector4());
 188
 189   END_TEST;
 190 }
 191
 192 int UtcDaliPropertyValueConstructorsMatrix3P(void)
 193 {
 194   Matrix3         v(1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0);
 195   Property::Value value(v);
 196
 197   DALI_TEST_CHECK(value.GetType() == Property::MATRIX3);
 198   DALI_TEST_CHECK(value.Get<Matrix3>() == v);
 199
 200   END_TEST;
 201 }
 202
 203 int UtcDaliPropertyValueConstructorsMatrix3TypeP(void)
 204 {
 205   Property::Value value(Property::MATRIX3);
 206
 207   DALI_TEST_CHECK(value.GetType() == Property::MATRIX3);
 208   DALI_TEST_CHECK(value.Get<Matrix3>() == Matrix3());
 209
 210   END_TEST;
 211 }
 212
 213 int UtcDaliPropertyValueConstructorsMatrixP(void)
 214 {
 215   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};
 216   Matrix          v(a);
 217   Property::Value value(v);
 218
 219   DALI_TEST_CHECK(value.GetType() == Property::MATRIX);
 220   DALI_TEST_CHECK(value.Get<Matrix>() == v);
 221
 222   END_TEST;
 223 }
 224
 225 int UtcDaliPropertyValueConstructorsMatrixTypeP(void)
 226 {
 227   Property::Value value(Property::MATRIX);
 228
 229   DALI_TEST_CHECK(value.GetType() == Property::MATRIX);
 230   DALI_TEST_CHECK(value.Get<Matrix>() == Matrix());
 231
 232   END_TEST;
 233 }
 234
 235 int UtcDaliPropertyValueConstructorsRectP(void)
 236 {
 237   Rect<int>       v(1.0, 1.0, 1.0, 1.0);
 238   Property::Value value(v);
 239
 240   DALI_TEST_EQUALS(value.GetType(), Property::RECTANGLE, TEST_LOCATION);
 241   DALI_TEST_CHECK(value.Get<Rect<int> >() == v);
 242
 243   END_TEST;
 244 }
 245
 246 int UtcDaliPropertyValueConstructorsRectTypeP(void)
 247 {
 248   Property::Value value(Property::RECTANGLE);
 249
 250   DALI_TEST_CHECK(value.GetType() == Property::RECTANGLE);
 251   DALI_TEST_CHECK(value.Get<Rect<int> >() == Rect<int>(0, 0, 0, 0));
 252
 253   END_TEST;
 254 }
 255
 256 int UtcDaliPropertyValueConstructorsAngleAxisP(void)
 257 {
 258   AngleAxis       input(Dali::ANGLE_90, Vector3::XAXIS);
 259   Property::Value value(input);
 260
 261   DALI_TEST_CHECK(value.GetType() == Property::ROTATION);
 262   AngleAxis result = value.Get<AngleAxis>();
 263   DALI_TEST_EQUALS(result.angle, input.angle, TEST_LOCATION);
 264   DALI_TEST_EQUALS(result.axis, input.axis, TEST_LOCATION);
 265
 266   END_TEST;
 267 }
 268
 269 int UtcDaliPropertyValueConstructorsQuaternionP(void)
 270 {
 271   Quaternion      v(Radian(Math::PI), Vector3::ZAXIS);
 272   Property::Value value(v);
 273
 274   DALI_TEST_CHECK(value.GetType() == Property::ROTATION);
 275   DALI_TEST_EQUALS(v, value.Get<Quaternion>(), 0.001, TEST_LOCATION);
 276
 277   END_TEST;
 278 }
 279
 280 int UtcDaliPropertyValueConstructorsRotationTypeP(void)
 281 {
 282   Property::Value value(Property::ROTATION);
 283
 284   DALI_TEST_CHECK(value.GetType() == Property::ROTATION);
 285   AngleAxis result = value.Get<AngleAxis>();
 286   DALI_TEST_EQUALS(result.angle, Radian(0.f), TEST_LOCATION);
 287   DALI_TEST_EQUALS(result.axis, Vector3::ZERO, TEST_LOCATION); // identity quaternion returns a zero angle-axis
 288
 289   END_TEST;
 290 }
 291
 292 int UtcDaliPropertyValueConstructorsStringP(void)
 293 {
 294   std::string     v("1");
 295   Property::Value value(v);
 296
 297   DALI_TEST_CHECK(value.GetType() == Property::STRING);
 298   DALI_TEST_CHECK(value.Get<std::string>() == v);
 299
 300   END_TEST;
 301 }
 302
 303 int UtcDaliPropertyValueConstructorsStringTypeP(void)
 304 {
 305   Property::Value value(Property::STRING);
 306
 307   DALI_TEST_CHECK(value.GetType() == Property::STRING);
 308   DALI_TEST_CHECK(value.Get<std::string>() == std::string());
 309
 310   END_TEST;
 311 }
 312
 313 int UtcDaliPropertyValueConstructorsArrayP(void)
 314 {
 315   Property::Array foo;
 316   Property::Value value(foo);
 317
 318   DALI_TEST_CHECK(value.GetType() == Property::ARRAY);
 319   DALI_TEST_CHECK(value.Get<Property::Array>().Count() == 0);
 320
 321   END_TEST;
 322 }
 323
 324 int UtcDaliPropertyValueConstructorsArray2P(void)
 325 {
 326   Property::Array foo;
 327   foo.PushBack(Property::Value());
 328   Property::Value value(foo);
 329
 330   DALI_TEST_CHECK(value.GetType() == Property::ARRAY);
 331   DALI_TEST_CHECK(value.Get<Property::Array>().Count() == 1);
 332
 333   END_TEST;
 334 }
 335
 336 int UtcDaliPropertyValueConstructorsArrayTypeP(void)
 337 {
 338   Property::Value value(Property::ARRAY);
 339
 340   DALI_TEST_CHECK(value.GetType() == Property::ARRAY);
 341   DALI_TEST_CHECK(value.Get<Property::Array>().Count() == 0);
 342
 343   END_TEST;
 344 }
 345
 346 int UtcDaliPropertyValueConstructorsMapP(void)
 347 {
 348   Property::Map   map;
 349   Property::Value value(map);
 350
 351   DALI_TEST_CHECK(value.GetType() == Property::MAP);
 352   DALI_TEST_CHECK(value.Get<Property::Map>().Count() == 0);
 353
 354   END_TEST;
 355 }
 356
 357 int UtcDaliPropertyValueConstructorsMap2P(void)
 358 {
 359   Property::Map map;
 360   map.Insert("", "");
 361   Property::Value value(map);
 362
 363   DALI_TEST_CHECK(value.GetType() == Property::MAP);
 364   DALI_TEST_CHECK(value.Get<Property::Map>().Count() == 1);
 365
 366   END_TEST;
 367 }
 368
 369 int UtcDaliPropertyValueConstructorsMapTypeP(void)
 370 {
 371   Property::Value value(Property::MAP);
 372
 373   DALI_TEST_CHECK(value.GetType() == Property::MAP);
 374   DALI_TEST_CHECK(value.Get<Property::Map>().Count() == 0);
 375
 376   END_TEST;
 377 }
 378
 379 int UtcDaliPropertyValueConstructorsExtentsTypeP(void)
 380 {
 381   Property::Value value(Property::EXTENTS);
 382
 383   DALI_TEST_CHECK(value.GetType() == Property::EXTENTS);
 384   DALI_TEST_CHECK(value.Get<Extents>() == Extents(0u, 0u, 0u, 0u));
 385
 386   END_TEST;
 387 }
 388
 389 int UtcDaliPropertyValueConstructorsExtentsType2P(void)
 390 {
 391   Property::Value value(Property::VECTOR4);
 392
 393   DALI_TEST_CHECK(value.GetType() == Property::VECTOR4);
 394   DALI_TEST_CHECK(value.Get<Extents>() == Extents(0u, 0u, 0u, 0u));
 395
 396   END_TEST;
 397 }
 398
 399 int UtcDaliPropertyValueCopyConstructorP(void)
 400 {
 401   Property::Value value;
 402   Property::Value value2(value);
 403   DALI_TEST_EQUALS(value.GetType(), value2.GetType(), TEST_LOCATION);
 404   DALI_TEST_EQUALS(value.GetMap(), value2.GetMap(), TEST_LOCATION);
 405   DALI_TEST_EQUALS(value.GetArray(), value2.GetArray(), TEST_LOCATION);
 406   END_TEST;
 407 }
 408
 409 int UtcDaliPropertyValueCopyConstructorBoolP(void)
 410 {
 411   CheckCopyCtorP<bool> check(true);
 412   END_TEST;
 413 }
 414
 415 int UtcDaliPropertyValueCopyConstructorFloatP(void)
 416 {
 417   CheckCopyCtorP<float> check(1.f);
 418   END_TEST;
 419 }
 420
 421 int UtcDaliPropertyValueCopyConstructorIntP(void)
 422 {
 423   CheckCopyCtorP<int> check(1);
 424   END_TEST;
 425 }
 426
 427 int UtcDaliPropertyValueCopyConstructoVector2P(void)
 428 {
 429   CheckCopyCtorP<Vector2> check(Vector2(2, 1));
 430   END_TEST;
 431 }
 432
 433 int UtcDaliPropertyValueCopyConstructorVector3P(void)
 434 {
 435   CheckCopyCtorP<Vector3> check(Vector3(3.f, 2.f, 1.f));
 436   END_TEST;
 437 }
 438
 439 int UtcDaliPropertyValueCopyConstructorVector4P(void)
 440 {
 441   CheckCopyCtorP<Vector3> check(Vector4(4.f, 3.f, 2.f, 1.f));
 442   END_TEST;
 443 }
 444
 445 int UtcDaliPropertyValueCopyConstructorMatrix3P(void)
 446 {
 447   CheckCopyCtorP<Matrix3> check(Matrix3::IDENTITY);
 448   END_TEST;
 449 }
 450
 451 int UtcDaliPropertyValueCopyConstructorMatrixP(void)
 452 {
 453   CheckCopyCtorP<Matrix> check(Matrix::IDENTITY);
 454   END_TEST;
 455 }
 456
 457 int UtcDaliPropertyValueCopyConstructorRectP(void)
 458 {
 459   CheckCopyCtorP<Rect<int> > check(Rect<int>(1.0, 1.0, 1.0, 1.0));
 460   END_TEST;
 461 }
 462
 463 int UtcDaliPropertyValueCopyConstructorAngleAxisP(void)
 464 {
 465   CheckCopyCtorP<AngleAxis> check(AngleAxis(Degree(1.0), Vector3(1.0, 1.0, 1.0)));
 466   END_TEST;
 467 }
 468
 469 int UtcDaliPropertyValueCopyConstructorQuaternionP(void)
 470 {
 471   CheckCopyCtorP<Quaternion> check(Quaternion(Vector4(1.0, 1.0, 1.0, 1.0)));
 472   END_TEST;
 473 }
 474
 475 int UtcDaliPropertyValueCopyConstructorStringP(void)
 476 {
 477   CheckCopyCtorP<std::string> check(std::string("1"));
 478   END_TEST;
 479 }
 480
 481 int UtcDaliPropertyValueCopyAssignStringDifferentTypeP(void)
 482 {
 483   Property::Value value1{Vector4(3.f, 2.f, 1.f, 2.0f)};
 484   Property::Value value2{"very very long string ..................."};
 485   value2 = value1;
 486
 487   Vector4 vec1, vec2;
 488   value1.Get(vec1);
 489   value2.Get(vec2);
 490   DALI_TEST_EQUALS(value1.GetType(), value2.GetType(), TEST_LOCATION);
 491   DALI_TEST_EQUALS(vec1, vec2, TEST_LOCATION);
 492
 493   Property::Value value3{Vector4(3.f, 2.f, 1.f, 2.0f)};
 494   Property::Value value4{"very very long string ..................."};
 495
 496   value3 = value4;
 497
 498   DALI_TEST_EQUALS(value3.GetType(), value4.GetType(), TEST_LOCATION);
 499   DALI_TEST_EQUALS(value3.Get<std::string>(), "very very long string ...................", TEST_LOCATION);
 500   DALI_TEST_EQUALS(value3.Get<std::string>(), value4.Get<std::string>(), TEST_LOCATION);
 501   END_TEST;
 502 }
 503
 504 int UtcDaliPropertyValueCopyConstructorArrayP(void)
 505 {
 506   Property::Value  value1(Property::ARRAY);
 507   Property::Array* array = value1.GetArray();
 508   array->PushBack(Property::Value(1));
 509
 510   Property::Value value2(value1);
 511   DALI_TEST_EQUALS(value1.GetType(), value2.GetType(), TEST_LOCATION);
 512   DALI_TEST_EQUALS(value1.GetArray()->Count(), value2.GetArray()->Count(), TEST_LOCATION);
 513
 514   END_TEST;
 515 }
 516
 517 int UtcDaliPropertyValueCopyConstructorMapP(void)
 518 {
 519   Property::Value value1(Property::MAP);
 520   Property::Map*  map = value1.GetMap();
 521   (*map)["1"]         = Property::Value(1);
 522
 523   Property::Value value2(value1);
 524   DALI_TEST_EQUALS(value1.GetType(), value2.GetType(), TEST_LOCATION);
 525   DALI_TEST_EQUALS(value1.GetMap()->Count(), value2.GetMap()->Count(), TEST_LOCATION);
 526   DALI_TEST_EQUALS(value1.GetMap()->GetKey(0), value2.GetMap()->GetKey(0), TEST_LOCATION);
 527
 528   END_TEST;
 529 }
 530
 531 int UtcDaliPropertyValueMoveConstructor(void)
 532 {
 533   Property::Value value1(Vector4::ONE);
 534   DALI_TEST_EQUALS(Property::VECTOR4, value1.GetType(), TEST_LOCATION);
 535
 536   Vector4 valueVector;
 537   DALI_TEST_EQUALS(true, value1.Get(valueVector), TEST_LOCATION); // Able to convert
 538   DALI_TEST_EQUALS(valueVector, Vector4::ONE, TEST_LOCATION);
 539
 540   Property::Value value2(std::move(value1));
 541   DALI_TEST_EQUALS(Property::NONE, value1.GetType(), TEST_LOCATION);
 542   DALI_TEST_EQUALS(false, value1.Get(valueVector), TEST_LOCATION); // Unable to convert, but no crash either
 543   DALI_TEST_EQUALS(Property::VECTOR4, value2.GetType(), TEST_LOCATION);
 544   DALI_TEST_EQUALS(true, value2.Get(valueVector), TEST_LOCATION); // Able to convert
 545   DALI_TEST_EQUALS(valueVector, Vector4::ONE, TEST_LOCATION);
 546
 547   END_TEST;
 548 }
 549
 550 int UtcDaliPropertyValueMoveConstructorArray(void)
 551 {
 552   Property::Array array;
 553   array.PushBack(1);
 554   array.PushBack(2);
 555   array.PushBack(3);
 556   DALI_TEST_EQUALS(3u, array.Size(), TEST_LOCATION);
 557
 558   Property::Value value(std::move(array));
 559   DALI_TEST_ASSERTION(array.Size(), "Cannot use an object previously used as an r-value"); // Our local variable should become invalid
 560
 561   Property::Array* arrayPtr = value.GetArray();
 562   DALI_TEST_CHECK(arrayPtr);
 563   DALI_TEST_EQUALS(3u, arrayPtr->Size(), TEST_LOCATION);
 564
 565   END_TEST;
 566 }
 567
 568 int UtcDaliPropertyValueMoveConstructorMap(void)
 569 {
 570   Property::Map map;
 571   map[1] = 1;
 572   map[2] = 2;
 573   map[3] = 3;
 574   DALI_TEST_EQUALS(3u, map.Count(), TEST_LOCATION);
 575
 576   Property::Value value(std::move(map));
 577   DALI_TEST_ASSERTION(map.Count(), "Cannot use an object previously used as an r-value"); // Our local variable should become invalid
 578
 579   Property::Map* mapPtr = value.GetMap();
 580   DALI_TEST_CHECK(mapPtr);
 581   DALI_TEST_EQUALS(3u, mapPtr->Count(), TEST_LOCATION);
 582
 583   END_TEST;
 584 }
 585
 586 int UtcDaliPropertyValueAssignmentSelfP(void)
 587 {
 588   Property::Value  value;
 589   Property::Value* self = &value;
 590   value                 = *self;
 591   DALI_TEST_EQUALS(value.GetType(), Property::NONE, TEST_LOCATION);
 592   DALI_TEST_CHECK(value.GetMap() == NULL);
 593   DALI_TEST_CHECK(value.GetArray() == NULL);
 594   END_TEST;
 595 }
 596
 597 int UtcDaliPropertyValueAssignmentOperatorNoneP(void)
 598 {
 599   Property::Value value;
 600   value = Property::Value(); // type match
 601   DALI_TEST_EQUALS(value.GetType(), Property::NONE, TEST_LOCATION);
 602   Property::Value copy(false);
 603   copy = value; // type mismatch
 604   DALI_TEST_EQUALS(value.GetType(), Property::NONE, TEST_LOCATION);
 605   END_TEST;
 606 }
 607
 608 int UtcDaliPropertyValueAssignmentOperatorBoolP(void)
 609 {
 610   Property::Value value;
 611   value = Property::Value(true); // type mismatch
 612   DALI_TEST_CHECK(true == value.Get<bool>());
 613   Property::Value copy(false);
 614   copy = value; // type match
 615   DALI_TEST_CHECK(true == copy.Get<bool>());
 616   END_TEST;
 617 }
 618
 619 int UtcDaliPropertyValueAssignmentOperatorIntP(void)
 620 {
 621   Property::Value value;
 622   value = Property::Value(10); // type mismatch
 623   DALI_TEST_CHECK(10 == value.Get<int>());
 624   Property::Value copy(99);
 625   copy = value; // type match
 626   DALI_TEST_CHECK(10 == copy.Get<int>());
 627   END_TEST;
 628 }
 629
 630 int UtcDaliPropertyValueAssignmentOperatorFloatP(void)
 631 {
 632   Property::Value value;
 633   value = Property::Value(10.f); // mismatch
 634   DALI_TEST_CHECK(Dali::Equals(10.f, value.Get<float>()));
 635   Property::Value copy(321.f);
 636   copy = value; // match
 637   DALI_TEST_CHECK(Dali::Equals(10.f, copy.Get<float>()));
 638   END_TEST;
 639 }
 640
 641 int UtcDaliPropertyValueAssignmentOperatorVector2P(void)
 642 {
 643   Property::Value value;
 644   value = Property::Value(Vector2(1, 2)); // mismatch
 645   DALI_TEST_CHECK(Vector2(1, 2) == value.Get<Vector2>());
 646   Property::Value copy(Property::VECTOR2);
 647   copy = value; // match
 648   DALI_TEST_CHECK(Vector2(1, 2) == copy.Get<Vector2>());
 649   END_TEST;
 650 }
 651
 652 int UtcDaliPropertyValueAssignmentOperatorVector3P(void)
 653 {
 654   Property::Value value;
 655   value = Property::Value(Vector3(1.f, 2.f, 3.f)); // mismatch
 656   DALI_TEST_CHECK(Vector3(1.f, 2.f, 3.f) == value.Get<Vector3>());
 657   Property::Value copy(Property::VECTOR3);
 658   copy = value; // match
 659   DALI_TEST_CHECK(Vector3(1.f, 2.f, 3.f) == copy.Get<Vector3>());
 660   END_TEST;
 661 }
 662
 663 int UtcDaliPropertyValueAssignmentOperatorVector4P(void)
 664 {
 665   Property::Value value;
 666   value = Property::Value(Vector4(1, 2, 3, 4)); // mismatch
 667   DALI_TEST_CHECK(Vector4(1, 2, 3, 4) == value.Get<Vector4>());
 668   Property::Value copy(Vector4(0, 1, 2, 3));
 669   copy = value; // match
 670   DALI_TEST_CHECK(Vector4(1, 2, 3, 4) == copy.Get<Vector4>());
 671   END_TEST;
 672 }
 673
 674 int UtcDaliPropertyValueAssignmentOperatorMatrix3P(void)
 675 {
 676   Property::Value value;
 677   value = Property::Value(Matrix3::IDENTITY); // mismatch
 678   DALI_TEST_CHECK(Matrix3::IDENTITY == value.Get<Matrix3>());
 679   Property::Value copy(Property::MATRIX3);
 680   copy = value; // match
 681   DALI_TEST_CHECK(Matrix3::IDENTITY == copy.Get<Matrix3>());
 682   END_TEST;
 683 }
 684
 685 int UtcDaliPropertyValueAssignmentOperatorMatrixP(void)
 686 {
 687   Property::Value value;
 688   value = Property::Value(Matrix::IDENTITY); // mismatch
 689   DALI_TEST_CHECK(Matrix::IDENTITY == value.Get<Matrix>());
 690   Matrix          foo;
 691   Property::Value copy(foo);
 692   copy = value; // match
 693   DALI_TEST_CHECK(Matrix::IDENTITY == copy.Get<Matrix>());
 694   END_TEST;
 695 }
 696
 697 int UtcDaliPropertyValueAssignmentOperatorRectP(void)
 698 {
 699   Property::Value         value;
 700   typedef Dali::Rect<int> Rectangle;
 701   value = Property::Value(Rectangle(4, 3, 2, 1)); // mismatch
 702   DALI_TEST_CHECK(Rectangle(4, 3, 2, 1) == value.Get<Rectangle>());
 703   Property::Value copy(Property::RECTANGLE);
 704   copy = value; // match
 705   Rectangle copyRect;
 706   copy.Get(copyRect);
 707   DALI_TEST_CHECK(Rectangle(4, 3, 2, 1) == copyRect);
 708   END_TEST;
 709 }
 710
 711 int UtcDaliPropertyValueAssignmentOperatorQuaternionP(void)
 712 {
 713   Property::Value value;
 714   Quaternion      result(Radian(Math::PI_2), Vector3::YAXIS);
 715   value = Property::Value(result);
 716
 717   DALI_TEST_EQUALS(value.Get<Quaternion>(), result, 0.001, TEST_LOCATION);
 718
 719   Property::Value copy(Property::ROTATION);
 720   copy = value; // match
 721   DALI_TEST_EQUALS(copy.Get<Quaternion>(), result, 0.001, TEST_LOCATION);
 722   END_TEST;
 723 }
 724
 725 int UtcDaliPropertyValueAssignmentOperatorAngleAxisP(void)
 726 {
 727   Property::Value value;
 728   value = Property::Value(AngleAxis(Radian(Math::PI_2), Vector3::XAXIS)); // mismatch
 729   DALI_TEST_EQUALS(value.Get<AngleAxis>().axis, Vector3::XAXIS, TEST_LOCATION);
 730   DALI_TEST_EQUALS(value.Get<AngleAxis>().angle, Radian(Math::PI_2), TEST_LOCATION);
 731   Property::Value copy(Property::ROTATION);
 732   copy = value; // match
 733   DALI_TEST_EQUALS(value.Get<AngleAxis>().axis, copy.Get<AngleAxis>().axis, TEST_LOCATION);
 734   DALI_TEST_EQUALS(value.Get<AngleAxis>().angle, copy.Get<AngleAxis>().angle, TEST_LOCATION);
 735   END_TEST;
 736 }
 737
 738 int UtcDaliPropertyValueAssignmentOperatorStringP(void)
 739 {
 740   Property::Value value;
 741   value = Property::Value("yes"); // mismatch
 742   DALI_TEST_CHECK("yes" == value.Get<std::string>());
 743   Property::Value copy("no");
 744   copy = value; // match
 745   DALI_TEST_CHECK("yes" == copy.Get<std::string>());
 746   END_TEST;
 747 }
 748
 749 int UtcDaliPropertyValueAssignmentOperatorArrayP(void)
 750 {
 751   Property::Value value;
 752   value = Property::Value(Property::ARRAY); // mismatch
 753   value.GetArray()->PushBack(10);
 754   DALI_TEST_CHECK(value.GetArray());
 755   Property::Value copy(Property::ARRAY);
 756   copy = value; // match
 757   Property::Array array;
 758   copy.Get(array);
 759   int getItem = 0;
 760   array[0].Get(getItem);
 761   DALI_TEST_CHECK(getItem == 10);
 762   END_TEST;
 763 }
 764
 765 int UtcDaliPropertyValueAssignmentOperatorMapP(void)
 766 {
 767   Property::Value value;
 768   value = Property::Value(Property::MAP); // mismatch
 769   value.GetMap()->Insert("key", "value");
 770   Property::Value copy(Property::MAP); // match
 771   copy = value;
 772   Property::Map map;
 773   copy.Get(map);
 774   DALI_TEST_CHECK(map.GetKey(0) == "key");
 775   END_TEST;
 776 }
 777
 778 int UtcDaliPropertyValueAssignmentOperatorExtentsP(void)
 779 {
 780   Property::Value value;
 781   value = Property::Value(Extents(4, 3, 2, 1)); // mismatch
 782   DALI_TEST_CHECK(Extents(4, 3, 2, 1) == value.Get<Extents>());
 783   Property::Value copy(Property::EXTENTS);
 784   copy = value; // match
 785   Extents copyExtents;
 786   copy.Get(copyExtents);
 787   DALI_TEST_CHECK(Extents(4, 3, 2, 1) == copyExtents);
 788   END_TEST;
 789 }
 790
 791 int UtcDaliPropertyValueMoveAssignmentOperator(void)
 792 {
 793   Property::Value value1(Vector4::ONE);
 794   DALI_TEST_EQUALS(Property::VECTOR4, value1.GetType(), TEST_LOCATION);
 795
 796   Vector4 valueVector;
 797   DALI_TEST_EQUALS(true, value1.Get(valueVector), TEST_LOCATION); // Able to convert
 798   DALI_TEST_EQUALS(valueVector, Vector4::ONE, TEST_LOCATION);
 799
 800   Property::Value value2;
 801   value2 = std::move(value1);
 802   DALI_TEST_EQUALS(Property::NONE, value1.GetType(), TEST_LOCATION);
 803   DALI_TEST_EQUALS(false, value1.Get(valueVector), TEST_LOCATION); // Unable to convert, but no crash either
 804   DALI_TEST_EQUALS(Property::VECTOR4, value2.GetType(), TEST_LOCATION);
 805   DALI_TEST_EQUALS(true, value2.Get(valueVector), TEST_LOCATION); // Able to convert
 806   DALI_TEST_EQUALS(valueVector, Vector4::ONE, TEST_LOCATION);
 807
 808   // Change to another value type
 809   value2 = std::move(Property::Value(1.0f));
 810   DALI_TEST_EQUALS(false, value2.Get(valueVector), TEST_LOCATION); // Should not be able to convert to a Vector4 now
 811   float valueFloat;
 812   DALI_TEST_EQUALS(true, value2.Get(valueFloat), TEST_LOCATION); // Should be able to convert to a float now
 813   DALI_TEST_EQUALS(valueFloat, 1.0f, TEST_LOCATION);
 814
 815   // Self std::move assignment make compile warning over gcc-13. Let we ignore the warning.
 816 #if (__GNUC__ >= 13)
 817 #pragma GCC diagnostic push
 818 #pragma GCC diagnostic ignored "-Wself-move"
 819 #endif
 820   // Ensure self assignment doesn't do anything silly
 821   value2 = std::move(value2);
 822   DALI_TEST_EQUALS(true, value2.Get(valueFloat), TEST_LOCATION);
 823   DALI_TEST_EQUALS(valueFloat, 1.0f, TEST_LOCATION);
 824 #if (__GNUC__ >= 13)
 825 #pragma GCC diagnostic pop
 826 #endif
 827
 828   END_TEST;
 829 }
 830
 831 int UtcDaliPropertyValueGetTypeP(void)
 832 {
 833   Property::Value value;
 834   DALI_TEST_CHECK(value.GetType() == Property::NONE);
 835   END_TEST;
 836 }
 837
 838 int UtcDaliPropertyValueGetBoolP(void)
 839 {
 840   Property::Value value(true);
 841   bool            boolean(false);
 842   DALI_TEST_CHECK(value.Get(boolean) == true);
 843   DALI_TEST_CHECK(value.Get<bool>() == true);
 844   std::string string;
 845   DALI_TEST_CHECK(value.Get(string) == false);
 846   value = Property::Value(1.f);
 847   DALI_TEST_CHECK(value.Get<float>() == 1.f);
 848   END_TEST;
 849 }
 850
 851 int UtcDaliPropertyValueGetBoolN(void)
 852 {
 853   Property::Value value;
 854   DALI_TEST_CHECK(value.Get<bool>() == false);
 855   bool boolean(false);
 856   DALI_TEST_CHECK(value.Get(boolean) == false);
 857   END_TEST;
 858 }
 859
 860 int UtcDaliPropertyValueGetFloatP(void)
 861 {
 862   Property::Value value(1.1f);
 863   float           flow(0.0f);
 864   DALI_TEST_EQUALS(1.1f, value.Get<float>(), TEST_LOCATION);
 865   DALI_TEST_EQUALS(true, value.Get(flow), TEST_LOCATION);
 866   DALI_TEST_EQUALS(1.1f, flow, TEST_LOCATION);
 867
 868   Property::Value intValue(100);
 869   DALI_TEST_EQUALS(100.f, intValue.Get<float>(), TEST_LOCATION);
 870   DALI_TEST_EQUALS(true, intValue.Get(flow), TEST_LOCATION);
 871   DALI_TEST_EQUALS(100.f, flow, TEST_LOCATION);
 872
 873   END_TEST;
 874 }
 875
 876 int UtcDaliPropertyValueGetFloatN(void)
 877 {
 878   Property::Value value;
 879   float           result(1.0f);
 880   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
 881   DALI_TEST_EQUALS(1.0f, result, TEST_LOCATION); // result is not modified
 882   Property::Value value2("");
 883   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
 884   DALI_TEST_EQUALS(1.0f, result, TEST_LOCATION); // result is not modified
 885   END_TEST;
 886 }
 887
 888 int UtcDaliPropertyValueGetIntP(void)
 889 {
 890   Property::Value value(123);
 891   int             result(10);
 892   DALI_TEST_EQUALS(123, value.Get<int>(), TEST_LOCATION);
 893   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 894   DALI_TEST_EQUALS(123, result, TEST_LOCATION);
 895
 896   Property::Value floatValue(21.f);
 897   DALI_TEST_EQUALS(21, floatValue.Get<int>(), TEST_LOCATION);
 898   DALI_TEST_EQUALS(true, floatValue.Get(result), TEST_LOCATION);
 899   DALI_TEST_EQUALS(21, result, TEST_LOCATION);
 900
 901   END_TEST;
 902 }
 903
 904 int UtcDaliPropertyValueGetIntN(void)
 905 {
 906   Property::Value value;
 907   int             result(10);
 908   DALI_TEST_EQUALS(0, value.Get<int>(), TEST_LOCATION);
 909   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
 910   DALI_TEST_EQUALS(10, result, TEST_LOCATION); // result is not modified
 911   Property::Value value2("");
 912   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
 913   DALI_TEST_EQUALS(10, result, TEST_LOCATION); // result is not modified
 914   END_TEST;
 915 }
 916
 917 int UtcDaliPropertyValueGetRectP(void)
 918 {
 919   Property::Value value(Rect<int>(1, 2, 3, 4));
 920   Rect<int>       result(4, 3, 2, 1);
 921   DALI_TEST_EQUALS(Rect<int>(1, 2, 3, 4), value.Get<Rect<int> >(), TEST_LOCATION);
 922   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 923   DALI_TEST_EQUALS(Rect<int>(1, 2, 3, 4), result, TEST_LOCATION);
 924   END_TEST;
 925 }
 926
 927 int UtcDaliPropertyValueGetRectN(void)
 928 {
 929   Property::Value value;
 930   Rect<int>       result(4, 3, 2, 1);
 931   DALI_TEST_EQUALS(Rect<int>(0, 0, 0, 0), value.Get<Rect<int> >(), TEST_LOCATION);
 932   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
 933   DALI_TEST_EQUALS(Rect<int>(4, 3, 2, 1), result, TEST_LOCATION);
 934   Property::Value value2("");
 935   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
 936   DALI_TEST_EQUALS(Rect<int>(4, 3, 2, 1), result, TEST_LOCATION);
 937   END_TEST;
 938 }
 939
 940 int UtcDaliPropertyValueGetVector2P(void)
 941 {
 942   Property::Value value(Vector2(1.0f, 2.0f));
 943   Vector2         result;
 944   DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), value.Get<Vector2>(), TEST_LOCATION);
 945   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 946   DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), result, TEST_LOCATION);
 947   END_TEST;
 948 }
 949
 950 int UtcDaliPropertyValueGetVector2fromVector3P(void)
 951 {
 952   Property::Value value(Vector3(1.f, 2.f, 3.f));
 953   Vector2         result;
 954   DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), value.Get<Vector2>(), TEST_LOCATION);
 955   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 956   DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), result, TEST_LOCATION);
 957   END_TEST;
 958 }
 959
 960 int UtcDaliPropertyValueGetVector2fromVector4P(void)
 961 {
 962   Property::Value value(Vector4(1.f, 2.f, 3.f, 4.f));
 963   Vector2         result;
 964   DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), value.Get<Vector2>(), TEST_LOCATION);
 965   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 966   DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), result, TEST_LOCATION);
 967   END_TEST;
 968 }
 969
 970 int UtcDaliPropertyValueGetVector2N(void)
 971 {
 972   Property::Value value;
 973   Vector2         result;
 974   DALI_TEST_EQUALS(Vector2(0.f, 0.f), value.Get<Vector2>(), TEST_LOCATION);
 975   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
 976   DALI_TEST_EQUALS(Vector2(), result, TEST_LOCATION);
 977   Property::Value value2("");
 978   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
 979   DALI_TEST_EQUALS(Vector2(), result, TEST_LOCATION);
 980   END_TEST;
 981 }
 982
 983 int UtcDaliPropertyValueGetVector3P(void)
 984 {
 985   Property::Value value(Vector3(1.0f, 2.0f, -1.f));
 986   Vector3         result;
 987   DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, -1.f), value.Get<Vector3>(), TEST_LOCATION);
 988   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 989   DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, -1.f), result, TEST_LOCATION);
 990   END_TEST;
 991 }
 992
 993 int UtcDaliPropertyValueGetVector3FromVector2P(void)
 994 {
 995   Property::Value value(Vector2(1.0f, 2.0f));
 996   Vector3         result(99.f, 88.f, 77.f);
 997   DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, 0.f), value.Get<Vector3>(), TEST_LOCATION);
 998   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 999   DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, 0.f), result, TEST_LOCATION);
1000   END_TEST;
1001 }
1002
1003 int UtcDaliPropertyValueGetVector3FromVector4P(void)
1004 {
1005   Property::Value value(Vector4(4.f, 3.f, 2.f, 1.f));
1006   Vector3         result;
1007   DALI_TEST_EQUALS(Vector3(4.f, 3.f, 2.f), value.Get<Vector3>(), TEST_LOCATION);
1008   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1009   DALI_TEST_EQUALS(Vector3(4.f, 3.f, 2.f), result, TEST_LOCATION);
1010   END_TEST;
1011 }
1012
1013 int UtcDaliPropertyValueGetVector3N(void)
1014 {
1015   Property::Value value;
1016   Vector3         result;
1017   DALI_TEST_EQUALS(Vector3(0.f, 0.f, 0.f), value.Get<Vector3>(), TEST_LOCATION);
1018   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1019   DALI_TEST_EQUALS(Vector3(), result, TEST_LOCATION);
1020   Property::Value value2("");
1021   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1022   DALI_TEST_EQUALS(Vector3(), result, TEST_LOCATION);
1023   END_TEST;
1024 }
1025
1026 int UtcDaliPropertyValueGetVector4P(void)
1027 {
1028   Property::Value value(Vector4(1.f, 2.f, -1.f, -3.f));
1029   Vector4         result;
1030   DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, -3.f), value.Get<Vector4>(), TEST_LOCATION);
1031   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1032   DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, -3.f), result, TEST_LOCATION);
1033   END_TEST;
1034 }
1035
1036 int UtcDaliPropertyValueGetVector4FromVector2P(void)
1037 {
1038   Property::Value value(Vector2(-1.f, -3.f));
1039   Vector4         result(99.f, 88.f, 77.f, 66.f);
1040   DALI_TEST_EQUALS(Vector4(-1.f, -3.f, 0.f, 0.f), value.Get<Vector4>(), TEST_LOCATION);
1041   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1042   DALI_TEST_EQUALS(Vector4(-1.f, -3.f, 0.f, 0.f), result, TEST_LOCATION);
1043   END_TEST;
1044 }
1045
1046 int UtcDaliPropertyValueGetVector4FromVector3P(void)
1047 {
1048   Property::Value value(Vector3(1.f, 2.f, -1.f));
1049   Vector4         result(99.f, 88.f, 77.f, 66.f);
1050   DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, 0.f), value.Get<Vector4>(), TEST_LOCATION);
1051   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1052   DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, 0.f), result, TEST_LOCATION);
1053   END_TEST;
1054 }
1055
1056 int UtcDaliPropertyValueGetVector4N(void)
1057 {
1058   Property::Value value;
1059   Vector4         result;
1060   DALI_TEST_EQUALS(Vector4(0.f, 0.f, 0.f, 0.f), value.Get<Vector4>(), TEST_LOCATION);
1061   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1062   DALI_TEST_EQUALS(Vector4(), result, TEST_LOCATION);
1063   Property::Value value2("");
1064   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1065   DALI_TEST_EQUALS(Vector4(), result, TEST_LOCATION);
1066   END_TEST;
1067 }
1068
1069 int UtcDaliPropertyValueGetMatrix3P(void)
1070 {
1071   Property::Value value(Matrix3(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f));
1072   Matrix3         result;
1073   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);
1074   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1075   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);
1076   END_TEST;
1077 }
1078
1079 int UtcDaliPropertyValueGetMatrix3N(void)
1080 {
1081   Property::Value value;
1082   Matrix3         result(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f);
1083   DALI_TEST_EQUALS(Matrix3(), value.Get<Matrix3>(), TEST_LOCATION);
1084   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1085   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);
1086   Property::Value value2("");
1087   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1088   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);
1089   END_TEST;
1090 }
1091
1092 int UtcDaliPropertyValueGetMatrixP(void)
1093 {
1094   float           matrixValues[16] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
1095   Matrix          input(matrixValues);
1096   Property::Value value(input);
1097   Matrix          result;
1098   DALI_TEST_EQUALS(input, value.Get<Matrix>(), TEST_LOCATION);
1099   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1100   DALI_TEST_EQUALS(input, result, TEST_LOCATION);
1101   END_TEST;
1102 }
1103
1104 int UtcDaliPropertyValueGetMatrixN(void)
1105 {
1106   Property::Value value;
1107   Matrix          result(Matrix::IDENTITY);
1108   DALI_TEST_EQUALS(Matrix(), value.Get<Matrix>(), TEST_LOCATION);
1109   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1110   DALI_TEST_EQUALS(Matrix::IDENTITY, result, TEST_LOCATION);
1111
1112   Property::Value value2("");
1113   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1114   DALI_TEST_EQUALS(Matrix::IDENTITY, result, TEST_LOCATION);
1115   END_TEST;
1116 }
1117
1118 int UtcDaliPropertyValueGetAngleAxisP(void)
1119 {
1120   AngleAxis       input(Dali::ANGLE_90, Vector3::XAXIS);
1121   Property::Value value(input);
1122   AngleAxis       result = value.Get<AngleAxis>();
1123   DALI_TEST_EQUALS(input.angle, result.angle, TEST_LOCATION);
1124   DALI_TEST_EQUALS(input.axis, result.axis, TEST_LOCATION);
1125
1126   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1127   DALI_TEST_EQUALS(input, result, TEST_LOCATION);
1128   END_TEST;
1129 }
1130
1131 int UtcDaliPropertyValueGetAngleAxisN(void)
1132 {
1133   Property::Value value;
1134   AngleAxis       b = value.Get<AngleAxis>();
1135   AngleAxis       result;
1136   DALI_TEST_EQUALS((Radian)0.f, b.angle, TEST_LOCATION);
1137   DALI_TEST_EQUALS(Vector3::ZERO, b.axis, TEST_LOCATION);
1138   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1139   DALI_TEST_EQUALS(AngleAxis(), result, TEST_LOCATION);
1140
1141   Property::Value value2("");
1142   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1143   DALI_TEST_EQUALS(AngleAxis(), result, TEST_LOCATION);
1144   END_TEST;
1145 }
1146
1147 int UtcDaliPropertyValueGetQuaternionP(void)
1148 {
1149   Vector3 axis(1, 1, 0);
1150   axis.Normalize();
1151
1152   Quaternion      result(Radian(1.f), axis);
1153   Property::Value value(result);
1154
1155   DALI_TEST_EQUALS(result, value.Get<Quaternion>(), TEST_LOCATION);
1156   Quaternion test2;
1157   DALI_TEST_EQUALS(true, value.Get(test2), TEST_LOCATION);
1158   END_TEST;
1159 }
1160
1161 int UtcDaliPropertyValueGetQuaternionN(void)
1162 {
1163   Property::Value value;
1164   Vector3         axis(1, 1, 0);
1165   axis.Normalize();
1166   Quaternion result(Radian(1.f), axis);
1167   Quaternion test(result);
1168
1169   DALI_TEST_EQUALS(Quaternion(), value.Get<Quaternion>(), TEST_LOCATION);
1170   DALI_TEST_EQUALS(false, value.Get(test), TEST_LOCATION);
1171   DALI_TEST_EQUALS(test, result, TEST_LOCATION);
1172
1173   Property::Value value2("");
1174   DALI_TEST_EQUALS(false, value2.Get(test), TEST_LOCATION);
1175   DALI_TEST_EQUALS(test, result, TEST_LOCATION);
1176   END_TEST;
1177 }
1178
1179 int UtcDaliPropertyValueGetStringP(void)
1180 {
1181   Property::Value value(std::string("hello"));
1182   std::string     result;
1183   DALI_TEST_EQUALS(std::string("hello"), value.Get<std::string>(), TEST_LOCATION);
1184   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1185   DALI_TEST_EQUALS(std::string("hello"), result, TEST_LOCATION);
1186
1187   Property::Value value2("C hi!");
1188   DALI_TEST_EQUALS("C hi!", value2.Get<std::string>(), TEST_LOCATION);
1189   DALI_TEST_EQUALS(true, value2.Get(result), TEST_LOCATION);
1190   DALI_TEST_EQUALS("C hi!", result, TEST_LOCATION);
1191   END_TEST;
1192 }
1193
1194 int UtcDaliPropertyValueGetStringN(void)
1195 {
1196   Property::Value value;
1197   std::string     result("doesn't change");
1198   DALI_TEST_EQUALS(std::string(), value.Get<std::string>(), TEST_LOCATION);
1199   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1200   DALI_TEST_EQUALS("doesn't change", result, TEST_LOCATION);
1201
1202   Property::Value value2(10);
1203   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1204   DALI_TEST_EQUALS("doesn't change", result, TEST_LOCATION);
1205
1206   Property::Value value3((char*)NULL);
1207   DALI_TEST_EQUALS(true, value3.Get(result), TEST_LOCATION);
1208   DALI_TEST_EQUALS(std::string(), result, TEST_LOCATION);
1209   END_TEST;
1210 }
1211
1212 int UtcDaliPropertyValueGetArrayP(void)
1213 {
1214   Property::Value value(Property::ARRAY);
1215   DALI_TEST_CHECK(NULL != value.GetArray());
1216   value.GetArray()->PushBack(Property::Value(1));
1217   Property::Array got = value.Get<Property::Array>();
1218   DALI_TEST_CHECK(got[0].Get<int>() == 1);
1219   Property::Array result;
1220   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1221   DALI_TEST_CHECK(result[0].Get<int>() == 1);
1222   END_TEST;
1223 }
1224
1225 int UtcDaliPropertyValueGetArrayN(void)
1226 {
1227   Property::Value value;
1228   DALI_TEST_CHECK(NULL == value.GetArray());
1229   Property::Array result;
1230   result.PushBack(Property::Value(10));
1231   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1232   DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION); // array is not modified
1233
1234   Property::Value value2("");
1235   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1236   DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION); // array is not modified
1237   END_TEST;
1238 }
1239
1240 int UtcDaliPropertyValueGetMapP(void)
1241 {
1242   Property::Value value(Property::MAP);
1243   DALI_TEST_CHECK(NULL == value.GetArray());
1244   DALI_TEST_CHECK(NULL != value.GetMap());
1245   value.GetMap()->Insert("key", Property::Value(1));
1246   Property::Map result = value.Get<Property::Map>();
1247   DALI_TEST_CHECK(result.Find("key")->Get<int>() == 1);
1248   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1249   DALI_TEST_CHECK(result.Find("key")->Get<int>() == 1);
1250   END_TEST;
1251 }
1252
1253 int UtcDaliPropertyValueGetMapN(void)
1254 {
1255   Property::Value value;
1256   DALI_TEST_CHECK(NULL == value.GetMap());
1257   DALI_TEST_EQUALS(0u, value.Get<Property::Map>().Count(), TEST_LOCATION);
1258   Property::Map result;
1259   result.Insert("key", "value");
1260   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1261   DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION);
1262
1263   Property::Value value2("");
1264   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1265   DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION); // array is not modified
1266   END_TEST;
1267 }
1268
1269 int UtcDaliPropertyValueGetExtentsP(void)
1270 {
1271   Property::Value value(Extents(1u, 2u, 3u, 4u));
1272   Extents         result(4u, 3u, 2u, 1u);
1273   DALI_TEST_EQUALS(Extents(1u, 2u, 3u, 4u), value.Get<Extents>(), TEST_LOCATION);
1274   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1275   DALI_TEST_EQUALS(Extents(1u, 2u, 3u, 4u), result, TEST_LOCATION);
1276   END_TEST;
1277 }
1278
1279 int UtcDaliPropertyValueEnum(void)
1280 {
1281   enum class E
1282   {
1283     zero,
1284     e
1285   };
1286   Property::Value value(E::e);
1287   DALI_TEST_EQUALS(static_cast<int>(E::e), static_cast<int>(value.Get<E>()), TEST_LOCATION);
1288   DALI_TEST_EQUALS(static_cast<int>(E::e), value.Get<int>(), TEST_LOCATION);
1289   E result;
1290   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1291   DALI_TEST_EQUALS(static_cast<int>(E::e), static_cast<int>(result), TEST_LOCATION);
1292   int result2;
1293   DALI_TEST_EQUALS(true, value.Get(result2), TEST_LOCATION);
1294   DALI_TEST_EQUALS(static_cast<int>(E::e), result2, TEST_LOCATION);
1295   END_TEST;
1296 }
1297
1298 int UtcDaliPropertyValueEqualSameType(void)
1299 {
1300   float           a[] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f};
1301   float           b[] = {16.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 1.0f};
1302   Property::Value valueList[] =
1303     {
1304       Property::Value(static_cast<bool>(true)),
1305       Property::Value(static_cast<float>(7.0f)),
1306       Property::Value(static_cast<int32_t>(32)),
1307       Property::Value(Vector2(1.0f, 2.0f)),
1308       Property::Value(Vector3(1.1f, 2.2f, 3.3f)),
1309       Property::Value(Vector4(1.2f, 2.1f, 3.4f, 4.3f)),
1310       Property::Value(Matrix3(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)),
1311       Property::Value(Matrix(a)),
1312       Property::Value(Rect<int32_t>(3, 2, 5, 4)),
1313       Property::Value(AngleAxis(Radian(2.0f), Vector3(0.0f, 1.0f, 0.0f))),
1314       Property::Value(std::string("Hello, World!")),
1315       Property::Value(Extents(8, 4, 2, 5)),
1316     };
1317   Property::Value otherValueList[] =
1318     {
1319       Property::Value(static_cast<bool>(false)),
1320       Property::Value(static_cast<float>(1.0f)),
1321       Property::Value(static_cast<int32_t>(4)),
1322       Property::Value(Vector2(2.0f, 1.0f)),
1323       Property::Value(Vector3(2.2f, 1.1f, 3.3f)),
1324       Property::Value(Vector4(2.1f, 1.2f, 3.4f, 4.3f)),
1325       Property::Value(Matrix3(7.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)),
1326       Property::Value(Matrix(b)),
1327       Property::Value(Rect<int32_t>(2, 3, 4, 5)),
1328       Property::Value(AngleAxis(Radian(20.0f), Vector3(0.0f, 1.0f, 0.0f))),
1329       Property::Value(std::string("Hell, o, World!")),
1330       Property::Value(Extents(4, 8, 5, 2)),
1331     };
1332   const int valueCount = sizeof(valueList) / sizeof(valueList[0]);
1333
1334   // Compare
1335   for(int i = 0; i < valueCount; ++i)
1336   {
1337     // Check self comparision
1338     DALI_TEST_EQUALS(valueList[i], valueList[i], TEST_LOCATION);
1339     // Check same value comparision
1340     Property::Value copiedValue = valueList[i];
1341     DALI_TEST_EQUALS(valueList[i], copiedValue, TEST_LOCATION);
1342     // Check not equal value comparision
1343     DALI_TEST_NOT_EQUALS(valueList[i], otherValueList[i], Math::MACHINE_EPSILON_100, TEST_LOCATION);
1344     // Check empty type value
1345     DALI_TEST_NOT_EQUALS(valueList[i], Property::Value(), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1346   }
1347
1348   // Compare with empty type.
1349   DALI_TEST_EQUALS(Property::Value(), Property::Value(), TEST_LOCATION);
1350
1351   END_TEST;
1352 }
1353
1354 int UtcDaliPropertyValueEqualArrayType(void)
1355 {
1356   tet_infoline("Check Property::Array type equality.");
1357   Property::Array array1;
1358   Property::Array array2;
1359   Property::Array array3;
1360   Property::Array array4;
1361   Property::Array array5;
1362   Property::Array array6;
1363
1364   array1.PushBack(Property::Value(30));
1365   array1.PushBack(Property::Value(20.0f));
1366   array1.PushBack(Property::Value("string"));
1367
1368   // Construct same array
1369   array2.PushBack(Property::Value(30));
1370   array2.PushBack(Property::Value(20.0f));
1371   array2.PushBack(Property::Value("string"));
1372
1373   // Construct same value, but different order
1374   array3.PushBack(Property::Value(20.0f));
1375   array3.PushBack(Property::Value(30));
1376   array3.PushBack(Property::Value("string"));
1377
1378   // Construct same type, but different value
1379   array4.PushBack(Property::Value(30));
1380   array4.PushBack(Property::Value(20.0f));
1381   array4.PushBack(Property::Value("not equal string"));
1382
1383   // Construct same prefix value, but different length
1384   array5.PushBack(Property::Value(30));
1385   array5.PushBack(Property::Value(20.0f));
1386   array5.PushBack(Property::Value("string"));
1387   array5.PushBack(Property::Value("string2"));
1388
1389   // Construct same length, but different type
1390   array6.PushBack(Property::Value(static_cast<bool>(true)));
1391   array6.PushBack(Property::Value("string"));
1392   array6.PushBack(Property::Value(22));
1393
1394   Property::Value value1(array1);
1395   Property::Value value2(array2);
1396   Property::Value value3(array3);
1397   Property::Value value4(array4);
1398   Property::Value value5(array5);
1399   Property::Value value6(array6);
1400
1401   DALI_TEST_NOT_EQUALS(value1, value3, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1402   DALI_TEST_NOT_EQUALS(value1, value4, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1403   DALI_TEST_NOT_EQUALS(value1, value5, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1404   DALI_TEST_NOT_EQUALS(value1, value6, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1405   DALI_TEST_NOT_EQUALS(value3, value4, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1406   DALI_TEST_NOT_EQUALS(value3, value5, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1407   DALI_TEST_NOT_EQUALS(value3, value6, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1408   DALI_TEST_NOT_EQUALS(value4, value5, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1409   DALI_TEST_NOT_EQUALS(value4, value6, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1410   DALI_TEST_NOT_EQUALS(value5, value6, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1411
1412   // TODO : Currently array comparision not implemented.
1413   // If we impelemnt array comparision, replace below line.
1414   // DALI_TEST_EQUALS(value1, value2, TEST_LOCATION);
1415   DALI_TEST_NOT_EQUALS(value1, value2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1416
1417   END_TEST;
1418 }
1419
1420 int UtcDaliPropertyValueEqualMapType(void)
1421 {
1422   tet_infoline("Check Property::Map type equality.");
1423   Property::Map map1;
1424   Property::Map map2;
1425   Property::Map map3;
1426   Property::Map map4;
1427   Property::Map map5;
1428   Property::Map map6;
1429
1430   map1.Insert(10, Property::Value(30));
1431   map1.Insert("20", Property::Value(20.0f));
1432   map1.Insert(30, Property::Value("string"));
1433
1434   // Construct same map
1435   map2.Insert(30, Property::Value("string"));
1436   map2.Insert(10, Property::Value(30));
1437   map2.Insert("20", Property::Value(20.0f));
1438
1439   // Construct same type, but different value
1440   map3.Insert(10, Property::Value(30));
1441   map3.Insert("20", Property::Value(20.0f));
1442   map3.Insert(30, Property::Value("not equal string"));
1443
1444   // Construct same value, but different key
1445   map4.Insert(10, Property::Value(30));
1446   map4.Insert(20, Property::Value(20.0f));
1447   map4.Insert("30", Property::Value("string"));
1448
1449   // Construct same prefix value, but different length
1450   map5.Insert(10, Property::Value(30));
1451   map5.Insert("20", Property::Value(20.0f));
1452   map5.Insert(30, Property::Value("string"));
1453   map5.Insert(40, Property::Value("string2"));
1454
1455   // Construct same length, same key, but different type
1456   map6.Insert(10, Property::Value(static_cast<bool>(true)));
1457   map6.Insert("20", Property::Value("string"));
1458   map6.Insert(30, Property::Value(22));
1459
1460   Property::Value value1(map1);
1461   Property::Value value2(map2);
1462   Property::Value value3(map3);
1463   Property::Value value4(map4);
1464   Property::Value value5(map5);
1465   Property::Value value6(map6);
1466
1467   DALI_TEST_NOT_EQUALS(value1, value3, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1468   DALI_TEST_NOT_EQUALS(value1, value4, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1469   DALI_TEST_NOT_EQUALS(value1, value5, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1470   DALI_TEST_NOT_EQUALS(value1, value6, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1471   DALI_TEST_NOT_EQUALS(value3, value4, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1472   DALI_TEST_NOT_EQUALS(value3, value5, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1473   DALI_TEST_NOT_EQUALS(value3, value6, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1474   DALI_TEST_NOT_EQUALS(value4, value5, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1475   DALI_TEST_NOT_EQUALS(value4, value6, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1476   DALI_TEST_NOT_EQUALS(value5, value6, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1477
1478   // TODO : Currently map comparision not implemented.
1479   // If we impelemnt map comparision, replace below line.
1480   // DALI_TEST_EQUALS(value1, value2, TEST_LOCATION);
1481   DALI_TEST_NOT_EQUALS(value1, value2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1482
1483   END_TEST;
1484 }
1485
1486 int UtcDaliPropertyValueOutputStream(void)
1487 {
1488   TestApplication application;
1489   tet_infoline("Testing Property::Value output stream");
1490   typedef Dali::Rect<int> Rectangle;
1491
1492   Property::Value value(true);
1493   {
1494     std::ostringstream stream;
1495     stream << value;
1496     DALI_TEST_CHECK(stream.str() == "1")
1497   }
1498
1499   {
1500     Property::Value    empty;
1501     std::ostringstream stream;
1502     stream << empty;
1503     DALI_TEST_EQUALS(stream.str(), "undefined type", TEST_LOCATION);
1504   }
1505
1506   {
1507     Property::Value    empty(Property::NONE);
1508     std::ostringstream stream;
1509     stream << empty;
1510     DALI_TEST_CHECK(stream.str() == "undefined type")
1511   }
1512
1513   {
1514     value = Property::Value(20.2f);
1515     std::ostringstream stream;
1516     stream << value;
1517     DALI_TEST_CHECK(stream.str() == "20.2")
1518   }
1519
1520   {
1521     value = Property::Value(-25);
1522     std::ostringstream stream;
1523     stream << value;
1524     DALI_TEST_CHECK(stream.str() == "-25")
1525   }
1526
1527   {
1528     value = Property::Value(Vector2(1.f, 1.f));
1529     std::ostringstream stream;
1530     stream << value;
1531     DALI_TEST_CHECK(stream.str() == "[1, 1]");
1532   }
1533
1534   {
1535     value = Property::Value(Vector3(1.f, 1.f, 1.f));
1536     std::ostringstream stream;
1537     stream << value;
1538     DALI_TEST_CHECK(stream.str() == "[1, 1, 1]");
1539   }
1540
1541   {
1542     value = Property::Value(Vector4(-4.f, -3.f, -2.f, -1.f));
1543     std::ostringstream stream;
1544     stream << value;
1545     DALI_TEST_EQUALS(stream.str(), "[-4, -3, -2, -1]", TEST_LOCATION);
1546   }
1547
1548   {
1549     value = Property::Value(Matrix3::IDENTITY);
1550     std::ostringstream stream;
1551     stream << value;
1552     DALI_TEST_CHECK(stream.str() == "[ 1, 0, 0, 0, 1, 0, 0, 0, 1 ]");
1553   }
1554
1555   {
1556     value = Property::Value(Matrix::IDENTITY);
1557     std::ostringstream stream;
1558     stream << value;
1559     DALI_TEST_CHECK(stream.str() == "[ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ]");
1560   }
1561
1562   {
1563     value = Property::Value(Rectangle(1, 2, 3, 4));
1564     std::ostringstream stream;
1565     stream << value;
1566     DALI_TEST_CHECK(stream.str() == "[1, 2, 3, 4]");
1567   }
1568
1569   {
1570     value = Property::Value(AngleAxis(Dali::ANGLE_120, Vector3::XAXIS));
1571     std::ostringstream stream;
1572     stream << value;
1573     tet_printf("angle axis = %s \n", stream.str().c_str());
1574     DALI_TEST_EQUALS(stream.str(), "[ Axis: [1, 0, 0], Angle: 120 degrees ]", TEST_LOCATION);
1575   }
1576
1577   {
1578     value = Property::Value(std::string("Foo"));
1579     std::ostringstream stream;
1580     stream << value;
1581     DALI_TEST_CHECK(stream.str() == "Foo");
1582   }
1583
1584   {
1585     Property::Map map;
1586     map.Insert("key", "value");
1587     map.Insert("duration", 10);
1588     map.Insert("color", Vector4(1.0, 0.5, 1.0, 1.0));
1589
1590     value = Property::Value(map);
1591     std::ostringstream stream;
1592     stream << value;
1593     tet_printf("Checking Property::Value is %s", stream.str().c_str());
1594     DALI_TEST_CHECK(!stream.str().compare("Map(3) = {key:value, duration:10, color:[1, 0.5, 1, 1]}"));
1595   }
1596   {
1597     Property::Array array;
1598     array.PushBack(0);
1599     array.PushBack(2);
1600     array.PushBack(3);
1601     value = Property::Value(array);
1602     std::ostringstream stream;
1603     stream << value;
1604     tet_printf("Checking Property::Value is %s", stream.str().c_str());
1605     DALI_TEST_CHECK(!stream.str().compare("Array(3) = [0, 2, 3]"));
1606   }
1607
1608   {
1609     Property::Map   map;
1610     Property::Map   map2;
1611     Property::Array array;
1612
1613     map2.Insert("key", "value");
1614     map2.Insert("duration", 10);
1615     map.Insert("color", Vector4(1.0, 0.5, 1.0, 1.0));
1616     map.Insert("timePeriod", map2);
1617     array.PushBack(Vector2(1, 0));
1618     array.PushBack(Vector2(0, 1));
1619     array.PushBack(Vector2(1, 0));
1620     array.PushBack(Vector2(0, 0.5));
1621     map.Insert("texCoords", array);
1622     value = Property::Value(map);
1623
1624     std::ostringstream stream;
1625     stream << value;
1626
1627     tet_printf("Checking Property::Value is %s", stream.str().c_str());
1628
1629     DALI_TEST_CHECK(!stream.str().compare("Map(3) = {color:[1, 0.5, 1, 1], timePeriod:Map(2) = {key:value, duration:10}, texCoords:Array(4) = [[1, 0], [0, 1], [1, 0], [0, 0.5]]}"));
1630   }
1631
1632   {
1633     value = Property::Value(Extents(1u, 2u, 3u, 4u));
1634     std::ostringstream stream;
1635     stream << value;
1636     DALI_TEST_CHECK(stream.str() == "[1, 2, 3, 4]");
1637   }
1638
1639   END_TEST;
1640 }