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

   1 /*
   2  * Copyright (c) 2022 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   // Ensure self assignment doesn't do anything silly
 816   value2 = std::move(value2);
 817   DALI_TEST_EQUALS(true, value2.Get(valueFloat), TEST_LOCATION);
 818   DALI_TEST_EQUALS(valueFloat, 1.0f, TEST_LOCATION);
 819
 820   END_TEST;
 821 }
 822
 823 int UtcDaliPropertyValueGetTypeP(void)
 824 {
 825   Property::Value value;
 826   DALI_TEST_CHECK(value.GetType() == Property::NONE);
 827   END_TEST;
 828 }
 829
 830 int UtcDaliPropertyValueGetBoolP(void)
 831 {
 832   Property::Value value(true);
 833   bool            boolean(false);
 834   DALI_TEST_CHECK(value.Get(boolean) == true);
 835   DALI_TEST_CHECK(value.Get<bool>() == true);
 836   std::string string;
 837   DALI_TEST_CHECK(value.Get(string) == false);
 838   value = Property::Value(1.f);
 839   DALI_TEST_CHECK(value.Get<float>() == 1.f);
 840   END_TEST;
 841 }
 842
 843 int UtcDaliPropertyValueGetBoolN(void)
 844 {
 845   Property::Value value;
 846   DALI_TEST_CHECK(value.Get<bool>() == false);
 847   bool boolean(false);
 848   DALI_TEST_CHECK(value.Get(boolean) == false);
 849   END_TEST;
 850 }
 851
 852 int UtcDaliPropertyValueGetFloatP(void)
 853 {
 854   Property::Value value(1.1f);
 855   float           flow(0.0f);
 856   DALI_TEST_EQUALS(1.1f, value.Get<float>(), TEST_LOCATION);
 857   DALI_TEST_EQUALS(true, value.Get(flow), TEST_LOCATION);
 858   DALI_TEST_EQUALS(1.1f, flow, TEST_LOCATION);
 859
 860   Property::Value intValue(100);
 861   DALI_TEST_EQUALS(100.f, intValue.Get<float>(), TEST_LOCATION);
 862   DALI_TEST_EQUALS(true, intValue.Get(flow), TEST_LOCATION);
 863   DALI_TEST_EQUALS(100.f, flow, TEST_LOCATION);
 864
 865   END_TEST;
 866 }
 867
 868 int UtcDaliPropertyValueGetFloatN(void)
 869 {
 870   Property::Value value;
 871   float           result(1.0f);
 872   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
 873   DALI_TEST_EQUALS(1.0f, result, TEST_LOCATION); // result is not modified
 874   Property::Value value2("");
 875   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
 876   DALI_TEST_EQUALS(1.0f, result, TEST_LOCATION); // result is not modified
 877   END_TEST;
 878 }
 879
 880 int UtcDaliPropertyValueGetIntP(void)
 881 {
 882   Property::Value value(123);
 883   int             result(10);
 884   DALI_TEST_EQUALS(123, value.Get<int>(), TEST_LOCATION);
 885   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 886   DALI_TEST_EQUALS(123, result, TEST_LOCATION);
 887
 888   Property::Value floatValue(21.f);
 889   DALI_TEST_EQUALS(21, floatValue.Get<int>(), TEST_LOCATION);
 890   DALI_TEST_EQUALS(true, floatValue.Get(result), TEST_LOCATION);
 891   DALI_TEST_EQUALS(21, result, TEST_LOCATION);
 892
 893   END_TEST;
 894 }
 895
 896 int UtcDaliPropertyValueGetIntN(void)
 897 {
 898   Property::Value value;
 899   int             result(10);
 900   DALI_TEST_EQUALS(0, value.Get<int>(), TEST_LOCATION);
 901   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
 902   DALI_TEST_EQUALS(10, result, TEST_LOCATION); // result is not modified
 903   Property::Value value2("");
 904   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
 905   DALI_TEST_EQUALS(10, result, TEST_LOCATION); // result is not modified
 906   END_TEST;
 907 }
 908
 909 int UtcDaliPropertyValueGetRectP(void)
 910 {
 911   Property::Value value(Rect<int>(1, 2, 3, 4));
 912   Rect<int>       result(4, 3, 2, 1);
 913   DALI_TEST_EQUALS(Rect<int>(1, 2, 3, 4), value.Get<Rect<int> >(), TEST_LOCATION);
 914   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 915   DALI_TEST_EQUALS(Rect<int>(1, 2, 3, 4), result, TEST_LOCATION);
 916   END_TEST;
 917 }
 918
 919 int UtcDaliPropertyValueGetRectN(void)
 920 {
 921   Property::Value value;
 922   Rect<int>       result(4, 3, 2, 1);
 923   DALI_TEST_EQUALS(Rect<int>(0, 0, 0, 0), value.Get<Rect<int> >(), TEST_LOCATION);
 924   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
 925   DALI_TEST_EQUALS(Rect<int>(4, 3, 2, 1), result, TEST_LOCATION);
 926   Property::Value value2("");
 927   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
 928   DALI_TEST_EQUALS(Rect<int>(4, 3, 2, 1), result, TEST_LOCATION);
 929   END_TEST;
 930 }
 931
 932 int UtcDaliPropertyValueGetVector2P(void)
 933 {
 934   Property::Value value(Vector2(1.0f, 2.0f));
 935   Vector2         result;
 936   DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), value.Get<Vector2>(), TEST_LOCATION);
 937   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 938   DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), result, TEST_LOCATION);
 939   END_TEST;
 940 }
 941
 942 int UtcDaliPropertyValueGetVector2fromVector3P(void)
 943 {
 944   Property::Value value(Vector3(1.f, 2.f, 3.f));
 945   Vector2         result;
 946   DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), value.Get<Vector2>(), TEST_LOCATION);
 947   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 948   DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), result, TEST_LOCATION);
 949   END_TEST;
 950 }
 951
 952 int UtcDaliPropertyValueGetVector2fromVector4P(void)
 953 {
 954   Property::Value value(Vector4(1.f, 2.f, 3.f, 4.f));
 955   Vector2         result;
 956   DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), value.Get<Vector2>(), TEST_LOCATION);
 957   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 958   DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), result, TEST_LOCATION);
 959   END_TEST;
 960 }
 961
 962 int UtcDaliPropertyValueGetVector2N(void)
 963 {
 964   Property::Value value;
 965   Vector2         result;
 966   DALI_TEST_EQUALS(Vector2(0.f, 0.f), value.Get<Vector2>(), TEST_LOCATION);
 967   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
 968   DALI_TEST_EQUALS(Vector2(), result, TEST_LOCATION);
 969   Property::Value value2("");
 970   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
 971   DALI_TEST_EQUALS(Vector2(), result, TEST_LOCATION);
 972   END_TEST;
 973 }
 974
 975 int UtcDaliPropertyValueGetVector3P(void)
 976 {
 977   Property::Value value(Vector3(1.0f, 2.0f, -1.f));
 978   Vector3         result;
 979   DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, -1.f), value.Get<Vector3>(), TEST_LOCATION);
 980   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 981   DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, -1.f), result, TEST_LOCATION);
 982   END_TEST;
 983 }
 984
 985 int UtcDaliPropertyValueGetVector3FromVector2P(void)
 986 {
 987   Property::Value value(Vector2(1.0f, 2.0f));
 988   Vector3         result(99.f, 88.f, 77.f);
 989   DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, 0.f), value.Get<Vector3>(), TEST_LOCATION);
 990   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 991   DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, 0.f), result, TEST_LOCATION);
 992   END_TEST;
 993 }
 994
 995 int UtcDaliPropertyValueGetVector3FromVector4P(void)
 996 {
 997   Property::Value value(Vector4(4.f, 3.f, 2.f, 1.f));
 998   Vector3         result;
 999   DALI_TEST_EQUALS(Vector3(4.f, 3.f, 2.f), value.Get<Vector3>(), TEST_LOCATION);
1000   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1001   DALI_TEST_EQUALS(Vector3(4.f, 3.f, 2.f), result, TEST_LOCATION);
1002   END_TEST;
1003 }
1004
1005 int UtcDaliPropertyValueGetVector3N(void)
1006 {
1007   Property::Value value;
1008   Vector3         result;
1009   DALI_TEST_EQUALS(Vector3(0.f, 0.f, 0.f), value.Get<Vector3>(), TEST_LOCATION);
1010   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1011   DALI_TEST_EQUALS(Vector3(), result, TEST_LOCATION);
1012   Property::Value value2("");
1013   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1014   DALI_TEST_EQUALS(Vector3(), result, TEST_LOCATION);
1015   END_TEST;
1016 }
1017
1018 int UtcDaliPropertyValueGetVector4P(void)
1019 {
1020   Property::Value value(Vector4(1.f, 2.f, -1.f, -3.f));
1021   Vector4         result;
1022   DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, -3.f), value.Get<Vector4>(), TEST_LOCATION);
1023   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1024   DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, -3.f), result, TEST_LOCATION);
1025   END_TEST;
1026 }
1027
1028 int UtcDaliPropertyValueGetVector4FromVector2P(void)
1029 {
1030   Property::Value value(Vector2(-1.f, -3.f));
1031   Vector4         result(99.f, 88.f, 77.f, 66.f);
1032   DALI_TEST_EQUALS(Vector4(-1.f, -3.f, 0.f, 0.f), value.Get<Vector4>(), TEST_LOCATION);
1033   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1034   DALI_TEST_EQUALS(Vector4(-1.f, -3.f, 0.f, 0.f), result, TEST_LOCATION);
1035   END_TEST;
1036 }
1037
1038 int UtcDaliPropertyValueGetVector4FromVector3P(void)
1039 {
1040   Property::Value value(Vector3(1.f, 2.f, -1.f));
1041   Vector4         result(99.f, 88.f, 77.f, 66.f);
1042   DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, 0.f), value.Get<Vector4>(), TEST_LOCATION);
1043   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1044   DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, 0.f), result, TEST_LOCATION);
1045   END_TEST;
1046 }
1047
1048 int UtcDaliPropertyValueGetVector4N(void)
1049 {
1050   Property::Value value;
1051   Vector4         result;
1052   DALI_TEST_EQUALS(Vector4(0.f, 0.f, 0.f, 0.f), value.Get<Vector4>(), TEST_LOCATION);
1053   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1054   DALI_TEST_EQUALS(Vector4(), result, TEST_LOCATION);
1055   Property::Value value2("");
1056   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1057   DALI_TEST_EQUALS(Vector4(), result, TEST_LOCATION);
1058   END_TEST;
1059 }
1060
1061 int UtcDaliPropertyValueGetMatrix3P(void)
1062 {
1063   Property::Value value(Matrix3(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f));
1064   Matrix3         result;
1065   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);
1066   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1067   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);
1068   END_TEST;
1069 }
1070
1071 int UtcDaliPropertyValueGetMatrix3N(void)
1072 {
1073   Property::Value value;
1074   Matrix3         result(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f);
1075   DALI_TEST_EQUALS(Matrix3(), value.Get<Matrix3>(), TEST_LOCATION);
1076   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1077   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);
1078   Property::Value value2("");
1079   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1080   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);
1081   END_TEST;
1082 }
1083
1084 int UtcDaliPropertyValueGetMatrixP(void)
1085 {
1086   float           matrixValues[16] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
1087   Matrix          input(matrixValues);
1088   Property::Value value(input);
1089   Matrix          result;
1090   DALI_TEST_EQUALS(input, value.Get<Matrix>(), TEST_LOCATION);
1091   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1092   DALI_TEST_EQUALS(input, result, TEST_LOCATION);
1093   END_TEST;
1094 }
1095
1096 int UtcDaliPropertyValueGetMatrixN(void)
1097 {
1098   Property::Value value;
1099   Matrix          result(Matrix::IDENTITY);
1100   DALI_TEST_EQUALS(Matrix(), value.Get<Matrix>(), TEST_LOCATION);
1101   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1102   DALI_TEST_EQUALS(Matrix::IDENTITY, result, TEST_LOCATION);
1103
1104   Property::Value value2("");
1105   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1106   DALI_TEST_EQUALS(Matrix::IDENTITY, result, TEST_LOCATION);
1107   END_TEST;
1108 }
1109
1110 int UtcDaliPropertyValueGetAngleAxisP(void)
1111 {
1112   AngleAxis       input(Dali::ANGLE_90, Vector3::XAXIS);
1113   Property::Value value(input);
1114   AngleAxis       result = value.Get<AngleAxis>();
1115   DALI_TEST_EQUALS(input.angle, result.angle, TEST_LOCATION);
1116   DALI_TEST_EQUALS(input.axis, result.axis, TEST_LOCATION);
1117
1118   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1119   DALI_TEST_EQUALS(input, result, TEST_LOCATION);
1120   END_TEST;
1121 }
1122
1123 int UtcDaliPropertyValueGetAngleAxisN(void)
1124 {
1125   Property::Value value;
1126   AngleAxis       b = value.Get<AngleAxis>();
1127   AngleAxis       result;
1128   DALI_TEST_EQUALS((Radian)0.f, b.angle, TEST_LOCATION);
1129   DALI_TEST_EQUALS(Vector3::ZERO, b.axis, TEST_LOCATION);
1130   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1131   DALI_TEST_EQUALS(AngleAxis(), result, TEST_LOCATION);
1132
1133   Property::Value value2("");
1134   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1135   DALI_TEST_EQUALS(AngleAxis(), result, TEST_LOCATION);
1136   END_TEST;
1137 }
1138
1139 int UtcDaliPropertyValueGetQuaternionP(void)
1140 {
1141   Vector3 axis(1, 1, 0);
1142   axis.Normalize();
1143
1144   Quaternion      result(Radian(1.f), axis);
1145   Property::Value value(result);
1146
1147   DALI_TEST_EQUALS(result, value.Get<Quaternion>(), TEST_LOCATION);
1148   Quaternion test2;
1149   DALI_TEST_EQUALS(true, value.Get(test2), TEST_LOCATION);
1150   END_TEST;
1151 }
1152
1153 int UtcDaliPropertyValueGetQuaternionN(void)
1154 {
1155   Property::Value value;
1156   Vector3         axis(1, 1, 0);
1157   axis.Normalize();
1158   Quaternion result(Radian(1.f), axis);
1159   Quaternion test(result);
1160
1161   DALI_TEST_EQUALS(Quaternion(), value.Get<Quaternion>(), TEST_LOCATION);
1162   DALI_TEST_EQUALS(false, value.Get(test), TEST_LOCATION);
1163   DALI_TEST_EQUALS(test, result, TEST_LOCATION);
1164
1165   Property::Value value2("");
1166   DALI_TEST_EQUALS(false, value2.Get(test), TEST_LOCATION);
1167   DALI_TEST_EQUALS(test, result, TEST_LOCATION);
1168   END_TEST;
1169 }
1170
1171 int UtcDaliPropertyValueGetStringP(void)
1172 {
1173   Property::Value value(std::string("hello"));
1174   std::string     result;
1175   DALI_TEST_EQUALS(std::string("hello"), value.Get<std::string>(), TEST_LOCATION);
1176   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1177   DALI_TEST_EQUALS(std::string("hello"), result, TEST_LOCATION);
1178
1179   Property::Value value2("C hi!");
1180   DALI_TEST_EQUALS("C hi!", value2.Get<std::string>(), TEST_LOCATION);
1181   DALI_TEST_EQUALS(true, value2.Get(result), TEST_LOCATION);
1182   DALI_TEST_EQUALS("C hi!", result, TEST_LOCATION);
1183   END_TEST;
1184 }
1185
1186 int UtcDaliPropertyValueGetStringN(void)
1187 {
1188   Property::Value value;
1189   std::string     result("doesn't change");
1190   DALI_TEST_EQUALS(std::string(), value.Get<std::string>(), TEST_LOCATION);
1191   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1192   DALI_TEST_EQUALS("doesn't change", result, TEST_LOCATION);
1193
1194   Property::Value value2(10);
1195   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1196   DALI_TEST_EQUALS("doesn't change", result, TEST_LOCATION);
1197
1198   Property::Value value3((char*)NULL);
1199   DALI_TEST_EQUALS(true, value3.Get(result), TEST_LOCATION);
1200   DALI_TEST_EQUALS(std::string(), result, TEST_LOCATION);
1201   END_TEST;
1202 }
1203
1204 int UtcDaliPropertyValueGetArrayP(void)
1205 {
1206   Property::Value value(Property::ARRAY);
1207   DALI_TEST_CHECK(NULL != value.GetArray());
1208   value.GetArray()->PushBack(Property::Value(1));
1209   Property::Array got = value.Get<Property::Array>();
1210   DALI_TEST_CHECK(got[0].Get<int>() == 1);
1211   Property::Array result;
1212   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1213   DALI_TEST_CHECK(result[0].Get<int>() == 1);
1214   END_TEST;
1215 }
1216
1217 int UtcDaliPropertyValueGetArrayN(void)
1218 {
1219   Property::Value value;
1220   DALI_TEST_CHECK(NULL == value.GetArray());
1221   Property::Array result;
1222   result.PushBack(Property::Value(10));
1223   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1224   DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION); // array is not modified
1225
1226   Property::Value value2("");
1227   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1228   DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION); // array is not modified
1229   END_TEST;
1230 }
1231
1232 int UtcDaliPropertyValueGetMapP(void)
1233 {
1234   Property::Value value(Property::MAP);
1235   DALI_TEST_CHECK(NULL == value.GetArray());
1236   DALI_TEST_CHECK(NULL != value.GetMap());
1237   value.GetMap()->Insert("key", Property::Value(1));
1238   Property::Map result = value.Get<Property::Map>();
1239   DALI_TEST_CHECK(result.Find("key")->Get<int>() == 1);
1240   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1241   DALI_TEST_CHECK(result.Find("key")->Get<int>() == 1);
1242   END_TEST;
1243 }
1244
1245 int UtcDaliPropertyValueGetMapN(void)
1246 {
1247   Property::Value value;
1248   DALI_TEST_CHECK(NULL == value.GetMap());
1249   DALI_TEST_EQUALS(0u, value.Get<Property::Map>().Count(), TEST_LOCATION);
1250   Property::Map result;
1251   result.Insert("key", "value");
1252   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1253   DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION);
1254
1255   Property::Value value2("");
1256   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1257   DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION); // array is not modified
1258   END_TEST;
1259 }
1260
1261 int UtcDaliPropertyValueGetExtentsP(void)
1262 {
1263   Property::Value value(Extents(1u, 2u, 3u, 4u));
1264   Extents         result(4u, 3u, 2u, 1u);
1265   DALI_TEST_EQUALS(Extents(1u, 2u, 3u, 4u), value.Get<Extents>(), TEST_LOCATION);
1266   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1267   DALI_TEST_EQUALS(Extents(1u, 2u, 3u, 4u), result, TEST_LOCATION);
1268   END_TEST;
1269 }
1270
1271 int UtcDaliPropertyValueEnum(void)
1272 {
1273   enum class E
1274   {
1275     zero,
1276     e
1277   };
1278   Property::Value value(E::e);
1279   DALI_TEST_EQUALS(static_cast<int>(E::e), static_cast<int>(value.Get<E>()), TEST_LOCATION);
1280   DALI_TEST_EQUALS(static_cast<int>(E::e), value.Get<int>(), TEST_LOCATION);
1281   E result;
1282   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1283   DALI_TEST_EQUALS(static_cast<int>(E::e), static_cast<int>(result), TEST_LOCATION);
1284   int result2;
1285   DALI_TEST_EQUALS(true, value.Get(result2), TEST_LOCATION);
1286   DALI_TEST_EQUALS(static_cast<int>(E::e), result2, TEST_LOCATION);
1287   END_TEST;
1288 }
1289
1290 int UtcDaliPropertyValueEqualSameType(void)
1291 {
1292   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};
1293   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};
1294   Property::Value valueList[] =
1295     {
1296       Property::Value(static_cast<bool>(true)),
1297       Property::Value(static_cast<float>(7.0f)),
1298       Property::Value(static_cast<int32_t>(32)),
1299       Property::Value(Vector2(1.0f, 2.0f)),
1300       Property::Value(Vector3(1.1f, 2.2f, 3.3f)),
1301       Property::Value(Vector4(1.2f, 2.1f, 3.4f, 4.3f)),
1302       Property::Value(Matrix3(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)),
1303       Property::Value(Matrix(a)),
1304       Property::Value(Rect<int32_t>(3, 2, 5, 4)),
1305       Property::Value(AngleAxis(Radian(2.0f), Vector3(0.0f, 1.0f, 0.0f))),
1306       Property::Value(std::string("Hello, World!")),
1307       Property::Value(Extents(8, 4, 2, 5)),
1308     };
1309   Property::Value otherValueList[] =
1310     {
1311       Property::Value(static_cast<bool>(false)),
1312       Property::Value(static_cast<float>(1.0f)),
1313       Property::Value(static_cast<int32_t>(4)),
1314       Property::Value(Vector2(2.0f, 1.0f)),
1315       Property::Value(Vector3(2.2f, 1.1f, 3.3f)),
1316       Property::Value(Vector4(2.1f, 1.2f, 3.4f, 4.3f)),
1317       Property::Value(Matrix3(7.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)),
1318       Property::Value(Matrix(b)),
1319       Property::Value(Rect<int32_t>(2, 3, 4, 5)),
1320       Property::Value(AngleAxis(Radian(20.0f), Vector3(0.0f, 1.0f, 0.0f))),
1321       Property::Value(std::string("Hell, o, World!")),
1322       Property::Value(Extents(4, 8, 5, 2)),
1323     };
1324   const int valueCount = sizeof(valueList) / sizeof(valueList[0]);
1325
1326   // Compare
1327   for(int i = 0; i < valueCount; ++i)
1328   {
1329     // Check self comparision
1330     DALI_TEST_EQUALS(valueList[i], valueList[i], TEST_LOCATION);
1331     // Check same value comparision
1332     Property::Value copiedValue = valueList[i];
1333     DALI_TEST_EQUALS(valueList[i], copiedValue, TEST_LOCATION);
1334     // Check not equal value comparision
1335     DALI_TEST_NOT_EQUALS(valueList[i], otherValueList[i], Math::MACHINE_EPSILON_100, TEST_LOCATION);
1336     // Check empty type value
1337     DALI_TEST_NOT_EQUALS(valueList[i], Property::Value(), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1338   }
1339
1340   // Compare with empty type.
1341   DALI_TEST_EQUALS(Property::Value(), Property::Value(), TEST_LOCATION);
1342
1343   END_TEST;
1344 }
1345
1346 int UtcDaliPropertyValueEqualArrayType(void)
1347 {
1348   tet_infoline("Check Property::Array type equality.");
1349   Property::Array array1;
1350   Property::Array array2;
1351   Property::Array array3;
1352   Property::Array array4;
1353   Property::Array array5;
1354   Property::Array array6;
1355
1356   array1.PushBack(Property::Value(30));
1357   array1.PushBack(Property::Value(20.0f));
1358   array1.PushBack(Property::Value("string"));
1359
1360   // Construct same array
1361   array2.PushBack(Property::Value(30));
1362   array2.PushBack(Property::Value(20.0f));
1363   array2.PushBack(Property::Value("string"));
1364
1365   // Construct same value, but different order
1366   array3.PushBack(Property::Value(20.0f));
1367   array3.PushBack(Property::Value(30));
1368   array3.PushBack(Property::Value("string"));
1369
1370   // Construct same type, but different value
1371   array4.PushBack(Property::Value(30));
1372   array4.PushBack(Property::Value(20.0f));
1373   array4.PushBack(Property::Value("not equal string"));
1374
1375   // Construct same prefix value, but different length
1376   array5.PushBack(Property::Value(30));
1377   array5.PushBack(Property::Value(20.0f));
1378   array5.PushBack(Property::Value("string"));
1379   array5.PushBack(Property::Value("string2"));
1380
1381   // Construct same length, but different type
1382   array6.PushBack(Property::Value(static_cast<bool>(true)));
1383   array6.PushBack(Property::Value("string"));
1384   array6.PushBack(Property::Value(22));
1385
1386   Property::Value value1(array1);
1387   Property::Value value2(array2);
1388   Property::Value value3(array3);
1389   Property::Value value4(array4);
1390   Property::Value value5(array5);
1391   Property::Value value6(array6);
1392
1393   DALI_TEST_NOT_EQUALS(value1, value3, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1394   DALI_TEST_NOT_EQUALS(value1, value4, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1395   DALI_TEST_NOT_EQUALS(value1, value5, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1396   DALI_TEST_NOT_EQUALS(value1, value6, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1397   DALI_TEST_NOT_EQUALS(value3, value4, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1398   DALI_TEST_NOT_EQUALS(value3, value5, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1399   DALI_TEST_NOT_EQUALS(value3, value6, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1400   DALI_TEST_NOT_EQUALS(value4, value5, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1401   DALI_TEST_NOT_EQUALS(value4, value6, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1402   DALI_TEST_NOT_EQUALS(value5, value6, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1403
1404   // TODO : Currently array comparision not implemented.
1405   // If we impelemnt array comparision, replace below line.
1406   // DALI_TEST_EQUALS(value1, value2, TEST_LOCATION);
1407   DALI_TEST_NOT_EQUALS(value1, value2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1408
1409   END_TEST;
1410 }
1411
1412 int UtcDaliPropertyValueEqualMapType(void)
1413 {
1414   tet_infoline("Check Property::Map type equality.");
1415   Property::Map map1;
1416   Property::Map map2;
1417   Property::Map map3;
1418   Property::Map map4;
1419   Property::Map map5;
1420   Property::Map map6;
1421
1422   map1.Insert(10, Property::Value(30));
1423   map1.Insert("20", Property::Value(20.0f));
1424   map1.Insert(30, Property::Value("string"));
1425
1426   // Construct same map
1427   map2.Insert(30, Property::Value("string"));
1428   map2.Insert(10, Property::Value(30));
1429   map2.Insert("20", Property::Value(20.0f));
1430
1431   // Construct same type, but different value
1432   map3.Insert(10, Property::Value(30));
1433   map3.Insert("20", Property::Value(20.0f));
1434   map3.Insert(30, Property::Value("not equal string"));
1435
1436   // Construct same value, but different key
1437   map4.Insert(10, Property::Value(30));
1438   map4.Insert(20, Property::Value(20.0f));
1439   map4.Insert("30", Property::Value("string"));
1440
1441   // Construct same prefix value, but different length
1442   map5.Insert(10, Property::Value(30));
1443   map5.Insert("20", Property::Value(20.0f));
1444   map5.Insert(30, Property::Value("string"));
1445   map5.Insert(40, Property::Value("string2"));
1446
1447   // Construct same length, same key, but different type
1448   map6.Insert(10, Property::Value(static_cast<bool>(true)));
1449   map6.Insert("20", Property::Value("string"));
1450   map6.Insert(30, Property::Value(22));
1451
1452   Property::Value value1(map1);
1453   Property::Value value2(map2);
1454   Property::Value value3(map3);
1455   Property::Value value4(map4);
1456   Property::Value value5(map5);
1457   Property::Value value6(map6);
1458
1459   DALI_TEST_NOT_EQUALS(value1, value3, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1460   DALI_TEST_NOT_EQUALS(value1, value4, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1461   DALI_TEST_NOT_EQUALS(value1, value5, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1462   DALI_TEST_NOT_EQUALS(value1, value6, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1463   DALI_TEST_NOT_EQUALS(value3, value4, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1464   DALI_TEST_NOT_EQUALS(value3, value5, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1465   DALI_TEST_NOT_EQUALS(value3, value6, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1466   DALI_TEST_NOT_EQUALS(value4, value5, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1467   DALI_TEST_NOT_EQUALS(value4, value6, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1468   DALI_TEST_NOT_EQUALS(value5, value6, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1469
1470   // TODO : Currently map comparision not implemented.
1471   // If we impelemnt map comparision, replace below line.
1472   // DALI_TEST_EQUALS(value1, value2, TEST_LOCATION);
1473   DALI_TEST_NOT_EQUALS(value1, value2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1474
1475   END_TEST;
1476 }
1477
1478 int UtcDaliPropertyValueOutputStream(void)
1479 {
1480   TestApplication application;
1481   tet_infoline("Testing Property::Value output stream");
1482   typedef Dali::Rect<int> Rectangle;
1483
1484   Property::Value value(true);
1485   {
1486     std::ostringstream stream;
1487     stream << value;
1488     DALI_TEST_CHECK(stream.str() == "1")
1489   }
1490
1491   {
1492     Property::Value    empty;
1493     std::ostringstream stream;
1494     stream << empty;
1495     DALI_TEST_EQUALS(stream.str(), "undefined type", TEST_LOCATION);
1496   }
1497
1498   {
1499     Property::Value    empty(Property::NONE);
1500     std::ostringstream stream;
1501     stream << empty;
1502     DALI_TEST_CHECK(stream.str() == "undefined type")
1503   }
1504
1505   {
1506     value = Property::Value(20.2f);
1507     std::ostringstream stream;
1508     stream << value;
1509     DALI_TEST_CHECK(stream.str() == "20.2")
1510   }
1511
1512   {
1513     value = Property::Value(-25);
1514     std::ostringstream stream;
1515     stream << value;
1516     DALI_TEST_CHECK(stream.str() == "-25")
1517   }
1518
1519   {
1520     value = Property::Value(Vector2(1.f, 1.f));
1521     std::ostringstream stream;
1522     stream << value;
1523     DALI_TEST_CHECK(stream.str() == "[1, 1]");
1524   }
1525
1526   {
1527     value = Property::Value(Vector3(1.f, 1.f, 1.f));
1528     std::ostringstream stream;
1529     stream << value;
1530     DALI_TEST_CHECK(stream.str() == "[1, 1, 1]");
1531   }
1532
1533   {
1534     value = Property::Value(Vector4(-4.f, -3.f, -2.f, -1.f));
1535     std::ostringstream stream;
1536     stream << value;
1537     DALI_TEST_EQUALS(stream.str(), "[-4, -3, -2, -1]", TEST_LOCATION);
1538   }
1539
1540   {
1541     value = Property::Value(Matrix3::IDENTITY);
1542     std::ostringstream stream;
1543     stream << value;
1544     DALI_TEST_CHECK(stream.str() == "[ 1, 0, 0, 0, 1, 0, 0, 0, 1 ]");
1545   }
1546
1547   {
1548     value = Property::Value(Matrix::IDENTITY);
1549     std::ostringstream stream;
1550     stream << value;
1551     DALI_TEST_CHECK(stream.str() == "[ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ]");
1552   }
1553
1554   {
1555     value = Property::Value(Rectangle(1, 2, 3, 4));
1556     std::ostringstream stream;
1557     stream << value;
1558     DALI_TEST_CHECK(stream.str() == "[1, 2, 3, 4]");
1559   }
1560
1561   {
1562     value = Property::Value(AngleAxis(Dali::ANGLE_120, Vector3::XAXIS));
1563     std::ostringstream stream;
1564     stream << value;
1565     tet_printf("angle axis = %s \n", stream.str().c_str());
1566     DALI_TEST_EQUALS(stream.str(), "[ Axis: [1, 0, 0], Angle: 120 degrees ]", TEST_LOCATION);
1567   }
1568
1569   {
1570     value = Property::Value(std::string("Foo"));
1571     std::ostringstream stream;
1572     stream << value;
1573     DALI_TEST_CHECK(stream.str() == "Foo");
1574   }
1575
1576   {
1577     Property::Map map;
1578     map.Insert("key", "value");
1579     map.Insert("duration", 10);
1580     map.Insert("color", Vector4(1.0, 0.5, 1.0, 1.0));
1581
1582     value = Property::Value(map);
1583     std::ostringstream stream;
1584     stream << value;
1585     tet_printf("Checking Property::Value is %s", stream.str().c_str());
1586     DALI_TEST_CHECK(!stream.str().compare("Map(3) = {key:value, duration:10, color:[1, 0.5, 1, 1]}"));
1587   }
1588   {
1589     Property::Array array;
1590     array.PushBack(0);
1591     array.PushBack(2);
1592     array.PushBack(3);
1593     value = Property::Value(array);
1594     std::ostringstream stream;
1595     stream << value;
1596     tet_printf("Checking Property::Value is %s", stream.str().c_str());
1597     DALI_TEST_CHECK(!stream.str().compare("Array(3) = [0, 2, 3]"));
1598   }
1599
1600   {
1601     Property::Map   map;
1602     Property::Map   map2;
1603     Property::Array array;
1604
1605     map2.Insert("key", "value");
1606     map2.Insert("duration", 10);
1607     map.Insert("color", Vector4(1.0, 0.5, 1.0, 1.0));
1608     map.Insert("timePeriod", map2);
1609     array.PushBack(Vector2(1, 0));
1610     array.PushBack(Vector2(0, 1));
1611     array.PushBack(Vector2(1, 0));
1612     array.PushBack(Vector2(0, 0.5));
1613     map.Insert("texCoords", array);
1614     value = Property::Value(map);
1615
1616     std::ostringstream stream;
1617     stream << value;
1618
1619     tet_printf("Checking Property::Value is %s", stream.str().c_str());
1620
1621     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]]}"));
1622   }
1623
1624   {
1625     value = Property::Value(Extents(1u, 2u, 3u, 4u));
1626     std::ostringstream stream;
1627     stream << value;
1628     DALI_TEST_CHECK(stream.str() == "[1, 2, 3, 4]");
1629   }
1630
1631   END_TEST;
1632 }