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

   1 /*
   2  * Copyright (c) 2020 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 UtcDaliPropertyValueCopyConstructorArrayP(void)
 482 {
 483   Property::Value  value1(Property::ARRAY);
 484   Property::Array* array = value1.GetArray();
 485   array->PushBack(Property::Value(1));
 486
 487   Property::Value value2(value1);
 488   DALI_TEST_EQUALS(value1.GetType(), value2.GetType(), TEST_LOCATION);
 489   DALI_TEST_EQUALS(value1.GetArray()->Count(), value2.GetArray()->Count(), TEST_LOCATION);
 490
 491   END_TEST;
 492 }
 493
 494 int UtcDaliPropertyValueCopyConstructorMapP(void)
 495 {
 496   Property::Value value1(Property::MAP);
 497   Property::Map*  map = value1.GetMap();
 498   (*map)["1"]         = Property::Value(1);
 499
 500   Property::Value value2(value1);
 501   DALI_TEST_EQUALS(value1.GetType(), value2.GetType(), TEST_LOCATION);
 502   DALI_TEST_EQUALS(value1.GetMap()->Count(), value2.GetMap()->Count(), TEST_LOCATION);
 503   DALI_TEST_EQUALS(value1.GetMap()->GetKey(0), value2.GetMap()->GetKey(0), TEST_LOCATION);
 504
 505   END_TEST;
 506 }
 507
 508 int UtcDaliPropertyValueMoveConstructor(void)
 509 {
 510   Property::Value value1(Vector4::ONE);
 511   DALI_TEST_EQUALS(Property::VECTOR4, value1.GetType(), TEST_LOCATION);
 512
 513   Vector4 valueVector;
 514   DALI_TEST_EQUALS(true, value1.Get(valueVector), TEST_LOCATION); // Able to convert
 515   DALI_TEST_EQUALS(valueVector, Vector4::ONE, TEST_LOCATION);
 516
 517   Property::Value value2(std::move(value1));
 518   DALI_TEST_EQUALS(Property::NONE, value1.GetType(), TEST_LOCATION);
 519   DALI_TEST_EQUALS(false, value1.Get(valueVector), TEST_LOCATION); // Unable to convert, but no crash either
 520   DALI_TEST_EQUALS(Property::VECTOR4, value2.GetType(), TEST_LOCATION);
 521   DALI_TEST_EQUALS(true, value2.Get(valueVector), TEST_LOCATION); // Able to convert
 522   DALI_TEST_EQUALS(valueVector, Vector4::ONE, TEST_LOCATION);
 523
 524   END_TEST;
 525 }
 526
 527 int UtcDaliPropertyValueMoveConstructorArray(void)
 528 {
 529   Property::Array array;
 530   array.PushBack(1);
 531   array.PushBack(2);
 532   array.PushBack(3);
 533   DALI_TEST_EQUALS(3u, array.Size(), TEST_LOCATION);
 534
 535   Property::Value value(std::move(array));
 536   DALI_TEST_ASSERTION(array.Size(), "Cannot use an object previously used as an r-value"); // Our local variable should become invalid
 537
 538   Property::Array* arrayPtr = value.GetArray();
 539   DALI_TEST_CHECK(arrayPtr);
 540   DALI_TEST_EQUALS(3u, arrayPtr->Size(), TEST_LOCATION);
 541
 542   END_TEST;
 543 }
 544
 545 int UtcDaliPropertyValueMoveConstructorMap(void)
 546 {
 547   Property::Map map;
 548   map[1] = 1;
 549   map[2] = 2;
 550   map[3] = 3;
 551   DALI_TEST_EQUALS(3u, map.Count(), TEST_LOCATION);
 552
 553   Property::Value value(std::move(map));
 554   DALI_TEST_ASSERTION(map.Count(), "Cannot use an object previously used as an r-value"); // Our local variable should become invalid
 555
 556   Property::Map* mapPtr = value.GetMap();
 557   DALI_TEST_CHECK(mapPtr);
 558   DALI_TEST_EQUALS(3u, mapPtr->Count(), TEST_LOCATION);
 559
 560   END_TEST;
 561 }
 562
 563 int UtcDaliPropertyValueAssignmentSelfP(void)
 564 {
 565   Property::Value  value;
 566   Property::Value* self = &value;
 567   value                 = *self;
 568   DALI_TEST_EQUALS(value.GetType(), Property::NONE, TEST_LOCATION);
 569   DALI_TEST_CHECK(value.GetMap() == NULL);
 570   DALI_TEST_CHECK(value.GetArray() == NULL);
 571   END_TEST;
 572 }
 573
 574 int UtcDaliPropertyValueAssignmentOperatorNoneP(void)
 575 {
 576   Property::Value value;
 577   value = Property::Value(); // type match
 578   DALI_TEST_EQUALS(value.GetType(), Property::NONE, TEST_LOCATION);
 579   Property::Value copy(false);
 580   copy = value; // type mismatch
 581   DALI_TEST_EQUALS(value.GetType(), Property::NONE, TEST_LOCATION);
 582   END_TEST;
 583 }
 584
 585 int UtcDaliPropertyValueAssignmentOperatorBoolP(void)
 586 {
 587   Property::Value value;
 588   value = Property::Value(true); // type mismatch
 589   DALI_TEST_CHECK(true == value.Get<bool>());
 590   Property::Value copy(false);
 591   copy = value; // type match
 592   DALI_TEST_CHECK(true == copy.Get<bool>());
 593   END_TEST;
 594 }
 595
 596 int UtcDaliPropertyValueAssignmentOperatorIntP(void)
 597 {
 598   Property::Value value;
 599   value = Property::Value(10); // type mismatch
 600   DALI_TEST_CHECK(10 == value.Get<int>());
 601   Property::Value copy(99);
 602   copy = value; // type match
 603   DALI_TEST_CHECK(10 == copy.Get<int>());
 604   END_TEST;
 605 }
 606
 607 int UtcDaliPropertyValueAssignmentOperatorFloatP(void)
 608 {
 609   Property::Value value;
 610   value = Property::Value(10.f); // mismatch
 611   DALI_TEST_CHECK(Dali::Equals(10.f, value.Get<float>()));
 612   Property::Value copy(321.f);
 613   copy = value; // match
 614   DALI_TEST_CHECK(Dali::Equals(10.f, copy.Get<float>()));
 615   END_TEST;
 616 }
 617
 618 int UtcDaliPropertyValueAssignmentOperatorVector2P(void)
 619 {
 620   Property::Value value;
 621   value = Property::Value(Vector2(1, 2)); // mismatch
 622   DALI_TEST_CHECK(Vector2(1, 2) == value.Get<Vector2>());
 623   Property::Value copy(Property::VECTOR2);
 624   copy = value; // match
 625   DALI_TEST_CHECK(Vector2(1, 2) == copy.Get<Vector2>());
 626   END_TEST;
 627 }
 628
 629 int UtcDaliPropertyValueAssignmentOperatorVector3P(void)
 630 {
 631   Property::Value value;
 632   value = Property::Value(Vector3(1.f, 2.f, 3.f)); // mismatch
 633   DALI_TEST_CHECK(Vector3(1.f, 2.f, 3.f) == value.Get<Vector3>());
 634   Property::Value copy(Property::VECTOR3);
 635   copy = value; // match
 636   DALI_TEST_CHECK(Vector3(1.f, 2.f, 3.f) == copy.Get<Vector3>());
 637   END_TEST;
 638 }
 639
 640 int UtcDaliPropertyValueAssignmentOperatorVector4P(void)
 641 {
 642   Property::Value value;
 643   value = Property::Value(Vector4(1, 2, 3, 4)); // mismatch
 644   DALI_TEST_CHECK(Vector4(1, 2, 3, 4) == value.Get<Vector4>());
 645   Property::Value copy(Vector4(0, 1, 2, 3));
 646   copy = value; // match
 647   DALI_TEST_CHECK(Vector4(1, 2, 3, 4) == copy.Get<Vector4>());
 648   END_TEST;
 649 }
 650
 651 int UtcDaliPropertyValueAssignmentOperatorMatrix3P(void)
 652 {
 653   Property::Value value;
 654   value = Property::Value(Matrix3::IDENTITY); // mismatch
 655   DALI_TEST_CHECK(Matrix3::IDENTITY == value.Get<Matrix3>());
 656   Property::Value copy(Property::MATRIX3);
 657   copy = value; // match
 658   DALI_TEST_CHECK(Matrix3::IDENTITY == copy.Get<Matrix3>());
 659   END_TEST;
 660 }
 661
 662 int UtcDaliPropertyValueAssignmentOperatorMatrixP(void)
 663 {
 664   Property::Value value;
 665   value = Property::Value(Matrix::IDENTITY); // mismatch
 666   DALI_TEST_CHECK(Matrix::IDENTITY == value.Get<Matrix>());
 667   Matrix          foo;
 668   Property::Value copy(foo);
 669   copy = value; // match
 670   DALI_TEST_CHECK(Matrix::IDENTITY == copy.Get<Matrix>());
 671   END_TEST;
 672 }
 673
 674 int UtcDaliPropertyValueAssignmentOperatorRectP(void)
 675 {
 676   Property::Value         value;
 677   typedef Dali::Rect<int> Rectangle;
 678   value = Property::Value(Rectangle(4, 3, 2, 1)); // mismatch
 679   DALI_TEST_CHECK(Rectangle(4, 3, 2, 1) == value.Get<Rectangle>());
 680   Property::Value copy(Property::RECTANGLE);
 681   copy = value; // match
 682   Rectangle copyRect;
 683   copy.Get(copyRect);
 684   DALI_TEST_CHECK(Rectangle(4, 3, 2, 1) == copyRect);
 685   END_TEST;
 686 }
 687
 688 int UtcDaliPropertyValueAssignmentOperatorQuaternionP(void)
 689 {
 690   Property::Value value;
 691   Quaternion      result(Radian(Math::PI_2), Vector3::YAXIS);
 692   value = Property::Value(result);
 693
 694   DALI_TEST_EQUALS(value.Get<Quaternion>(), result, 0.001, TEST_LOCATION);
 695
 696   Property::Value copy(Property::ROTATION);
 697   copy = value; // match
 698   DALI_TEST_EQUALS(copy.Get<Quaternion>(), result, 0.001, TEST_LOCATION);
 699   END_TEST;
 700 }
 701
 702 int UtcDaliPropertyValueAssignmentOperatorAngleAxisP(void)
 703 {
 704   Property::Value value;
 705   value = Property::Value(AngleAxis(Radian(Math::PI_2), Vector3::XAXIS)); // mismatch
 706   DALI_TEST_EQUALS(value.Get<AngleAxis>().axis, Vector3::XAXIS, TEST_LOCATION);
 707   DALI_TEST_EQUALS(value.Get<AngleAxis>().angle, Radian(Math::PI_2), TEST_LOCATION);
 708   Property::Value copy(Property::ROTATION);
 709   copy = value; // match
 710   DALI_TEST_EQUALS(value.Get<AngleAxis>().axis, copy.Get<AngleAxis>().axis, TEST_LOCATION);
 711   DALI_TEST_EQUALS(value.Get<AngleAxis>().angle, copy.Get<AngleAxis>().angle, TEST_LOCATION);
 712   END_TEST;
 713 }
 714
 715 int UtcDaliPropertyValueAssignmentOperatorStringP(void)
 716 {
 717   Property::Value value;
 718   value = Property::Value("yes"); // mismatch
 719   DALI_TEST_CHECK("yes" == value.Get<std::string>());
 720   Property::Value copy("no");
 721   copy = value; // match
 722   DALI_TEST_CHECK("yes" == copy.Get<std::string>());
 723   END_TEST;
 724 }
 725
 726 int UtcDaliPropertyValueAssignmentOperatorArrayP(void)
 727 {
 728   Property::Value value;
 729   value = Property::Value(Property::ARRAY); // mismatch
 730   value.GetArray()->PushBack(10);
 731   DALI_TEST_CHECK(value.GetArray());
 732   Property::Value copy(Property::ARRAY);
 733   copy = value; // match
 734   Property::Array array;
 735   copy.Get(array);
 736   int getItem = 0;
 737   array[0].Get(getItem);
 738   DALI_TEST_CHECK(getItem == 10);
 739   END_TEST;
 740 }
 741
 742 int UtcDaliPropertyValueAssignmentOperatorMapP(void)
 743 {
 744   Property::Value value;
 745   value = Property::Value(Property::MAP); // mismatch
 746   value.GetMap()->Insert("key", "value");
 747   Property::Value copy(Property::MAP); // match
 748   copy = value;
 749   Property::Map map;
 750   copy.Get(map);
 751   DALI_TEST_CHECK(map.GetKey(0) == "key");
 752   END_TEST;
 753 }
 754
 755 int UtcDaliPropertyValueAssignmentOperatorExtentsP(void)
 756 {
 757   Property::Value value;
 758   value = Property::Value(Extents(4, 3, 2, 1)); // mismatch
 759   DALI_TEST_CHECK(Extents(4, 3, 2, 1) == value.Get<Extents>());
 760   Property::Value copy(Property::EXTENTS);
 761   copy = value; // match
 762   Extents copyExtents;
 763   copy.Get(copyExtents);
 764   DALI_TEST_CHECK(Extents(4, 3, 2, 1) == copyExtents);
 765   END_TEST;
 766 }
 767
 768 int UtcDaliPropertyValueMoveAssignmentOperator(void)
 769 {
 770   Property::Value value1(Vector4::ONE);
 771   DALI_TEST_EQUALS(Property::VECTOR4, value1.GetType(), TEST_LOCATION);
 772
 773   Vector4 valueVector;
 774   DALI_TEST_EQUALS(true, value1.Get(valueVector), TEST_LOCATION); // Able to convert
 775   DALI_TEST_EQUALS(valueVector, Vector4::ONE, TEST_LOCATION);
 776
 777   Property::Value value2;
 778   value2 = std::move(value1);
 779   DALI_TEST_EQUALS(Property::NONE, value1.GetType(), TEST_LOCATION);
 780   DALI_TEST_EQUALS(false, value1.Get(valueVector), TEST_LOCATION); // Unable to convert, but no crash either
 781   DALI_TEST_EQUALS(Property::VECTOR4, value2.GetType(), TEST_LOCATION);
 782   DALI_TEST_EQUALS(true, value2.Get(valueVector), TEST_LOCATION); // Able to convert
 783   DALI_TEST_EQUALS(valueVector, Vector4::ONE, TEST_LOCATION);
 784
 785   // Change to another value type
 786   value2 = std::move(Property::Value(1.0f));
 787   DALI_TEST_EQUALS(false, value2.Get(valueVector), TEST_LOCATION); // Should not be able to convert to a Vector4 now
 788   float valueFloat;
 789   DALI_TEST_EQUALS(true, value2.Get(valueFloat), TEST_LOCATION); // Should be able to convert to a float now
 790   DALI_TEST_EQUALS(valueFloat, 1.0f, TEST_LOCATION);
 791
 792   // Ensure self assignment doesn't do anything silly
 793   value2 = std::move(value2);
 794   DALI_TEST_EQUALS(true, value2.Get(valueFloat), TEST_LOCATION);
 795   DALI_TEST_EQUALS(valueFloat, 1.0f, TEST_LOCATION);
 796
 797   END_TEST;
 798 }
 799
 800 int UtcDaliPropertyValueGetTypeP(void)
 801 {
 802   Property::Value value;
 803   DALI_TEST_CHECK(value.GetType() == Property::NONE);
 804   END_TEST;
 805 }
 806
 807 int UtcDaliPropertyValueGetBoolP(void)
 808 {
 809   Property::Value value(true);
 810   bool            boolean(false);
 811   DALI_TEST_CHECK(value.Get(boolean) == true);
 812   DALI_TEST_CHECK(value.Get<bool>() == true);
 813   std::string string;
 814   DALI_TEST_CHECK(value.Get(string) == false);
 815   value = Property::Value(1.f);
 816   DALI_TEST_CHECK(value.Get<float>() == 1.f);
 817   END_TEST;
 818 }
 819
 820 int UtcDaliPropertyValueGetBoolN(void)
 821 {
 822   Property::Value value;
 823   DALI_TEST_CHECK(value.Get<bool>() == false);
 824   bool boolean(false);
 825   DALI_TEST_CHECK(value.Get(boolean) == false);
 826   END_TEST;
 827 }
 828
 829 int UtcDaliPropertyValueGetFloatP(void)
 830 {
 831   Property::Value value(1.1f);
 832   float           flow(0.0f);
 833   DALI_TEST_EQUALS(1.1f, value.Get<float>(), TEST_LOCATION);
 834   DALI_TEST_EQUALS(true, value.Get(flow), TEST_LOCATION);
 835   DALI_TEST_EQUALS(1.1f, flow, TEST_LOCATION);
 836
 837   Property::Value intValue(100);
 838   DALI_TEST_EQUALS(100.f, intValue.Get<float>(), TEST_LOCATION);
 839   DALI_TEST_EQUALS(true, intValue.Get(flow), TEST_LOCATION);
 840   DALI_TEST_EQUALS(100.f, flow, TEST_LOCATION);
 841
 842   END_TEST;
 843 }
 844
 845 int UtcDaliPropertyValueGetFloatN(void)
 846 {
 847   Property::Value value;
 848   float           result(1.0f);
 849   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
 850   DALI_TEST_EQUALS(1.0f, result, TEST_LOCATION); // result is not modified
 851   Property::Value value2("");
 852   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
 853   DALI_TEST_EQUALS(1.0f, result, TEST_LOCATION); // result is not modified
 854   END_TEST;
 855 }
 856
 857 int UtcDaliPropertyValueGetIntP(void)
 858 {
 859   Property::Value value(123);
 860   int             result(10);
 861   DALI_TEST_EQUALS(123, value.Get<int>(), TEST_LOCATION);
 862   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 863   DALI_TEST_EQUALS(123, result, TEST_LOCATION);
 864
 865   Property::Value floatValue(21.f);
 866   DALI_TEST_EQUALS(21, floatValue.Get<int>(), TEST_LOCATION);
 867   DALI_TEST_EQUALS(true, floatValue.Get(result), TEST_LOCATION);
 868   DALI_TEST_EQUALS(21, result, TEST_LOCATION);
 869
 870   END_TEST;
 871 }
 872
 873 int UtcDaliPropertyValueGetIntN(void)
 874 {
 875   Property::Value value;
 876   int             result(10);
 877   DALI_TEST_EQUALS(0, value.Get<int>(), TEST_LOCATION);
 878   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
 879   DALI_TEST_EQUALS(10, result, TEST_LOCATION); // result is not modified
 880   Property::Value value2("");
 881   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
 882   DALI_TEST_EQUALS(10, result, TEST_LOCATION); // result is not modified
 883   END_TEST;
 884 }
 885
 886 int UtcDaliPropertyValueGetRectP(void)
 887 {
 888   Property::Value value(Rect<int>(1, 2, 3, 4));
 889   Rect<int>       result(4, 3, 2, 1);
 890   DALI_TEST_EQUALS(Rect<int>(1, 2, 3, 4), value.Get<Rect<int> >(), TEST_LOCATION);
 891   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 892   DALI_TEST_EQUALS(Rect<int>(1, 2, 3, 4), result, TEST_LOCATION);
 893   END_TEST;
 894 }
 895
 896 int UtcDaliPropertyValueGetRectN(void)
 897 {
 898   Property::Value value;
 899   Rect<int>       result(4, 3, 2, 1);
 900   DALI_TEST_EQUALS(Rect<int>(0, 0, 0, 0), value.Get<Rect<int> >(), TEST_LOCATION);
 901   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
 902   DALI_TEST_EQUALS(Rect<int>(4, 3, 2, 1), result, TEST_LOCATION);
 903   Property::Value value2("");
 904   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
 905   DALI_TEST_EQUALS(Rect<int>(4, 3, 2, 1), result, TEST_LOCATION);
 906   END_TEST;
 907 }
 908
 909 int UtcDaliPropertyValueGetVector2P(void)
 910 {
 911   Property::Value value(Vector2(1.0f, 2.0f));
 912   Vector2         result;
 913   DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), value.Get<Vector2>(), TEST_LOCATION);
 914   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 915   DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), result, TEST_LOCATION);
 916   END_TEST;
 917 }
 918
 919 int UtcDaliPropertyValueGetVector2fromVector3P(void)
 920 {
 921   Property::Value value(Vector3(1.f, 2.f, 3.f));
 922   Vector2         result;
 923   DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), value.Get<Vector2>(), TEST_LOCATION);
 924   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 925   DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), result, TEST_LOCATION);
 926   END_TEST;
 927 }
 928
 929 int UtcDaliPropertyValueGetVector2fromVector4P(void)
 930 {
 931   Property::Value value(Vector4(1.f, 2.f, 3.f, 4.f));
 932   Vector2         result;
 933   DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), value.Get<Vector2>(), TEST_LOCATION);
 934   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 935   DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), result, TEST_LOCATION);
 936   END_TEST;
 937 }
 938
 939 int UtcDaliPropertyValueGetVector2N(void)
 940 {
 941   Property::Value value;
 942   Vector2         result;
 943   DALI_TEST_EQUALS(Vector2(0.f, 0.f), value.Get<Vector2>(), TEST_LOCATION);
 944   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
 945   DALI_TEST_EQUALS(Vector2(), result, TEST_LOCATION);
 946   Property::Value value2("");
 947   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
 948   DALI_TEST_EQUALS(Vector2(), result, TEST_LOCATION);
 949   END_TEST;
 950 }
 951
 952 int UtcDaliPropertyValueGetVector3P(void)
 953 {
 954   Property::Value value(Vector3(1.0f, 2.0f, -1.f));
 955   Vector3         result;
 956   DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, -1.f), value.Get<Vector3>(), TEST_LOCATION);
 957   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 958   DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, -1.f), result, TEST_LOCATION);
 959   END_TEST;
 960 }
 961
 962 int UtcDaliPropertyValueGetVector3FromVector2P(void)
 963 {
 964   Property::Value value(Vector2(1.0f, 2.0f));
 965   Vector3         result(99.f, 88.f, 77.f);
 966   DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, 0.f), value.Get<Vector3>(), TEST_LOCATION);
 967   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 968   DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, 0.f), result, TEST_LOCATION);
 969   END_TEST;
 970 }
 971
 972 int UtcDaliPropertyValueGetVector3FromVector4P(void)
 973 {
 974   Property::Value value(Vector4(4.f, 3.f, 2.f, 1.f));
 975   Vector3         result;
 976   DALI_TEST_EQUALS(Vector3(4.f, 3.f, 2.f), value.Get<Vector3>(), TEST_LOCATION);
 977   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
 978   DALI_TEST_EQUALS(Vector3(4.f, 3.f, 2.f), result, TEST_LOCATION);
 979   END_TEST;
 980 }
 981
 982 int UtcDaliPropertyValueGetVector3N(void)
 983 {
 984   Property::Value value;
 985   Vector3         result;
 986   DALI_TEST_EQUALS(Vector3(0.f, 0.f, 0.f), value.Get<Vector3>(), TEST_LOCATION);
 987   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
 988   DALI_TEST_EQUALS(Vector3(), result, TEST_LOCATION);
 989   Property::Value value2("");
 990   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
 991   DALI_TEST_EQUALS(Vector3(), result, TEST_LOCATION);
 992   END_TEST;
 993 }
 994
 995 int UtcDaliPropertyValueGetVector4P(void)
 996 {
 997   Property::Value value(Vector4(1.f, 2.f, -1.f, -3.f));
 998   Vector4         result;
 999   DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, -3.f), value.Get<Vector4>(), TEST_LOCATION);
1000   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1001   DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, -3.f), result, TEST_LOCATION);
1002   END_TEST;
1003 }
1004
1005 int UtcDaliPropertyValueGetVector4FromVector2P(void)
1006 {
1007   Property::Value value(Vector2(-1.f, -3.f));
1008   Vector4         result(99.f, 88.f, 77.f, 66.f);
1009   DALI_TEST_EQUALS(Vector4(-1.f, -3.f, 0.f, 0.f), value.Get<Vector4>(), TEST_LOCATION);
1010   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1011   DALI_TEST_EQUALS(Vector4(-1.f, -3.f, 0.f, 0.f), result, TEST_LOCATION);
1012   END_TEST;
1013 }
1014
1015 int UtcDaliPropertyValueGetVector4FromVector3P(void)
1016 {
1017   Property::Value value(Vector3(1.f, 2.f, -1.f));
1018   Vector4         result(99.f, 88.f, 77.f, 66.f);
1019   DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, 0.f), value.Get<Vector4>(), TEST_LOCATION);
1020   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1021   DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, 0.f), result, TEST_LOCATION);
1022   END_TEST;
1023 }
1024
1025 int UtcDaliPropertyValueGetVector4N(void)
1026 {
1027   Property::Value value;
1028   Vector4         result;
1029   DALI_TEST_EQUALS(Vector4(0.f, 0.f, 0.f, 0.f), value.Get<Vector4>(), TEST_LOCATION);
1030   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1031   DALI_TEST_EQUALS(Vector4(), result, TEST_LOCATION);
1032   Property::Value value2("");
1033   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1034   DALI_TEST_EQUALS(Vector4(), result, TEST_LOCATION);
1035   END_TEST;
1036 }
1037
1038 int UtcDaliPropertyValueGetMatrix3P(void)
1039 {
1040   Property::Value value(Matrix3(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f));
1041   Matrix3         result;
1042   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);
1043   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1044   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);
1045   END_TEST;
1046 }
1047
1048 int UtcDaliPropertyValueGetMatrix3N(void)
1049 {
1050   Property::Value value;
1051   Matrix3         result(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f);
1052   DALI_TEST_EQUALS(Matrix3(), value.Get<Matrix3>(), TEST_LOCATION);
1053   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1054   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);
1055   Property::Value value2("");
1056   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1057   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);
1058   END_TEST;
1059 }
1060
1061 int UtcDaliPropertyValueGetMatrixP(void)
1062 {
1063   float           matrixValues[16] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
1064   Matrix          input(matrixValues);
1065   Property::Value value(input);
1066   Matrix          result;
1067   DALI_TEST_EQUALS(input, value.Get<Matrix>(), TEST_LOCATION);
1068   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1069   DALI_TEST_EQUALS(input, result, TEST_LOCATION);
1070   END_TEST;
1071 }
1072
1073 int UtcDaliPropertyValueGetMatrixN(void)
1074 {
1075   Property::Value value;
1076   Matrix          result(Matrix::IDENTITY);
1077   DALI_TEST_EQUALS(Matrix(), value.Get<Matrix>(), TEST_LOCATION);
1078   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1079   DALI_TEST_EQUALS(Matrix::IDENTITY, result, TEST_LOCATION);
1080
1081   Property::Value value2("");
1082   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1083   DALI_TEST_EQUALS(Matrix::IDENTITY, result, TEST_LOCATION);
1084   END_TEST;
1085 }
1086
1087 int UtcDaliPropertyValueGetAngleAxisP(void)
1088 {
1089   AngleAxis       input(Dali::ANGLE_90, Vector3::XAXIS);
1090   Property::Value value(input);
1091   AngleAxis       result = value.Get<AngleAxis>();
1092   DALI_TEST_EQUALS(input.angle, result.angle, TEST_LOCATION);
1093   DALI_TEST_EQUALS(input.axis, result.axis, TEST_LOCATION);
1094
1095   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1096   DALI_TEST_EQUALS(input, result, TEST_LOCATION);
1097   END_TEST;
1098 }
1099
1100 int UtcDaliPropertyValueGetAngleAxisN(void)
1101 {
1102   Property::Value value;
1103   AngleAxis       b = value.Get<AngleAxis>();
1104   AngleAxis       result;
1105   DALI_TEST_EQUALS((Radian)0.f, b.angle, TEST_LOCATION);
1106   DALI_TEST_EQUALS(Vector3::ZERO, b.axis, TEST_LOCATION);
1107   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1108   DALI_TEST_EQUALS(AngleAxis(), result, TEST_LOCATION);
1109
1110   Property::Value value2("");
1111   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1112   DALI_TEST_EQUALS(AngleAxis(), result, TEST_LOCATION);
1113   END_TEST;
1114 }
1115
1116 int UtcDaliPropertyValueGetQuaternionP(void)
1117 {
1118   Vector3 axis(1, 1, 0);
1119   axis.Normalize();
1120
1121   Quaternion      result(Radian(1.f), axis);
1122   Property::Value value(result);
1123
1124   DALI_TEST_EQUALS(result, value.Get<Quaternion>(), TEST_LOCATION);
1125   Quaternion test2;
1126   DALI_TEST_EQUALS(true, value.Get(test2), TEST_LOCATION);
1127   END_TEST;
1128 }
1129
1130 int UtcDaliPropertyValueGetQuaternionN(void)
1131 {
1132   Property::Value value;
1133   Vector3         axis(1, 1, 0);
1134   axis.Normalize();
1135   Quaternion result(Radian(1.f), axis);
1136   Quaternion test(result);
1137
1138   DALI_TEST_EQUALS(Quaternion(), value.Get<Quaternion>(), TEST_LOCATION);
1139   DALI_TEST_EQUALS(false, value.Get(test), TEST_LOCATION);
1140   DALI_TEST_EQUALS(test, result, TEST_LOCATION);
1141
1142   Property::Value value2("");
1143   DALI_TEST_EQUALS(false, value2.Get(test), TEST_LOCATION);
1144   DALI_TEST_EQUALS(test, result, TEST_LOCATION);
1145   END_TEST;
1146 }
1147
1148 int UtcDaliPropertyValueGetStringP(void)
1149 {
1150   Property::Value value(std::string("hello"));
1151   std::string     result;
1152   DALI_TEST_EQUALS(std::string("hello"), value.Get<std::string>(), TEST_LOCATION);
1153   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1154   DALI_TEST_EQUALS(std::string("hello"), result, TEST_LOCATION);
1155
1156   Property::Value value2("C hi!");
1157   DALI_TEST_EQUALS("C hi!", value2.Get<std::string>(), TEST_LOCATION);
1158   DALI_TEST_EQUALS(true, value2.Get(result), TEST_LOCATION);
1159   DALI_TEST_EQUALS("C hi!", result, TEST_LOCATION);
1160   END_TEST;
1161 }
1162
1163 int UtcDaliPropertyValueGetStringN(void)
1164 {
1165   Property::Value value;
1166   std::string     result("doesn't change");
1167   DALI_TEST_EQUALS(std::string(), value.Get<std::string>(), TEST_LOCATION);
1168   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1169   DALI_TEST_EQUALS("doesn't change", result, TEST_LOCATION);
1170
1171   Property::Value value2(10);
1172   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1173   DALI_TEST_EQUALS("doesn't change", result, TEST_LOCATION);
1174
1175   Property::Value value3((char*)NULL);
1176   DALI_TEST_EQUALS(true, value3.Get(result), TEST_LOCATION);
1177   DALI_TEST_EQUALS(std::string(), result, TEST_LOCATION);
1178   END_TEST;
1179 }
1180
1181 int UtcDaliPropertyValueGetArrayP(void)
1182 {
1183   Property::Value value(Property::ARRAY);
1184   DALI_TEST_CHECK(NULL != value.GetArray());
1185   value.GetArray()->PushBack(Property::Value(1));
1186   Property::Array got = value.Get<Property::Array>();
1187   DALI_TEST_CHECK(got[0].Get<int>() == 1);
1188   Property::Array result;
1189   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1190   DALI_TEST_CHECK(result[0].Get<int>() == 1);
1191   END_TEST;
1192 }
1193
1194 int UtcDaliPropertyValueGetArrayN(void)
1195 {
1196   Property::Value value;
1197   DALI_TEST_CHECK(NULL == value.GetArray());
1198   Property::Array result;
1199   result.PushBack(Property::Value(10));
1200   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1201   DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION); // array is not modified
1202
1203   Property::Value value2("");
1204   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1205   DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION); // array is not modified
1206   END_TEST;
1207 }
1208
1209 int UtcDaliPropertyValueGetMapP(void)
1210 {
1211   Property::Value value(Property::MAP);
1212   DALI_TEST_CHECK(NULL == value.GetArray());
1213   DALI_TEST_CHECK(NULL != value.GetMap());
1214   value.GetMap()->Insert("key", Property::Value(1));
1215   Property::Map result = value.Get<Property::Map>();
1216   DALI_TEST_CHECK(result.Find("key")->Get<int>() == 1);
1217   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1218   DALI_TEST_CHECK(result.Find("key")->Get<int>() == 1);
1219   END_TEST;
1220 }
1221
1222 int UtcDaliPropertyValueGetMapN(void)
1223 {
1224   Property::Value value;
1225   DALI_TEST_CHECK(NULL == value.GetMap());
1226   DALI_TEST_EQUALS(0u, value.Get<Property::Map>().Count(), TEST_LOCATION);
1227   Property::Map result;
1228   result.Insert("key", "value");
1229   DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
1230   DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION);
1231
1232   Property::Value value2("");
1233   DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
1234   DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION); // array is not modified
1235   END_TEST;
1236 }
1237
1238 int UtcDaliPropertyValueGetExtentsP(void)
1239 {
1240   Property::Value value(Extents(1u, 2u, 3u, 4u));
1241   Extents         result(4u, 3u, 2u, 1u);
1242   DALI_TEST_EQUALS(Extents(1u, 2u, 3u, 4u), value.Get<Extents>(), TEST_LOCATION);
1243   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1244   DALI_TEST_EQUALS(Extents(1u, 2u, 3u, 4u), result, TEST_LOCATION);
1245   END_TEST;
1246 }
1247
1248 int UtcDaliPropertyValueEnum(void)
1249 {
1250   enum class E
1251   {
1252     zero,
1253     e
1254   };
1255   Property::Value value(E::e);
1256   DALI_TEST_EQUALS(static_cast<int>(E::e), static_cast<int>(value.Get<E>()), TEST_LOCATION);
1257   DALI_TEST_EQUALS(static_cast<int>(E::e), value.Get<int>(), TEST_LOCATION);
1258   E result;
1259   DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
1260   DALI_TEST_EQUALS(static_cast<int>(E::e), static_cast<int>(result), TEST_LOCATION);
1261   int result2;
1262   DALI_TEST_EQUALS(true, value.Get(result2), TEST_LOCATION);
1263   DALI_TEST_EQUALS(static_cast<int>(E::e), result2, TEST_LOCATION);
1264   END_TEST;
1265 }
1266
1267 int UtcDaliPropertyValueOutputStream(void)
1268 {
1269   TestApplication application;
1270   tet_infoline("Testing Property::Value output stream");
1271   typedef Dali::Rect<int> Rectangle;
1272
1273   Property::Value value(true);
1274   {
1275     std::ostringstream stream;
1276     stream << value;
1277     DALI_TEST_CHECK(stream.str() == "1")
1278   }
1279
1280   {
1281     Property::Value    empty;
1282     std::ostringstream stream;
1283     stream << empty;
1284     DALI_TEST_EQUALS(stream.str(), "undefined type", TEST_LOCATION);
1285   }
1286
1287   {
1288     Property::Value    empty(Property::NONE);
1289     std::ostringstream stream;
1290     stream << empty;
1291     DALI_TEST_CHECK(stream.str() == "undefined type")
1292   }
1293
1294   {
1295     value = Property::Value(20.2f);
1296     std::ostringstream stream;
1297     stream << value;
1298     DALI_TEST_CHECK(stream.str() == "20.2")
1299   }
1300
1301   {
1302     value = Property::Value(-25);
1303     std::ostringstream stream;
1304     stream << value;
1305     DALI_TEST_CHECK(stream.str() == "-25")
1306   }
1307
1308   {
1309     value = Property::Value(Vector2(1.f, 1.f));
1310     std::ostringstream stream;
1311     stream << value;
1312     DALI_TEST_CHECK(stream.str() == "[1, 1]");
1313   }
1314
1315   {
1316     value = Property::Value(Vector3(1.f, 1.f, 1.f));
1317     std::ostringstream stream;
1318     stream << value;
1319     DALI_TEST_CHECK(stream.str() == "[1, 1, 1]");
1320   }
1321
1322   {
1323     value = Property::Value(Vector4(-4.f, -3.f, -2.f, -1.f));
1324     std::ostringstream stream;
1325     stream << value;
1326     DALI_TEST_EQUALS(stream.str(), "[-4, -3, -2, -1]", TEST_LOCATION);
1327   }
1328
1329   {
1330     value = Property::Value(Matrix3::IDENTITY);
1331     std::ostringstream stream;
1332     stream << value;
1333     DALI_TEST_CHECK(stream.str() == "[ 1, 0, 0, 0, 1, 0, 0, 0, 1 ]");
1334   }
1335
1336   {
1337     value = Property::Value(Matrix::IDENTITY);
1338     std::ostringstream stream;
1339     stream << value;
1340     DALI_TEST_CHECK(stream.str() == "[ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ]");
1341   }
1342
1343   {
1344     value = Property::Value(Rectangle(1, 2, 3, 4));
1345     std::ostringstream stream;
1346     stream << value;
1347     DALI_TEST_CHECK(stream.str() == "[1, 2, 3, 4]");
1348   }
1349
1350   {
1351     value = Property::Value(AngleAxis(Dali::ANGLE_120, Vector3::XAXIS));
1352     std::ostringstream stream;
1353     stream << value;
1354     tet_printf("angle axis = %s \n", stream.str().c_str());
1355     DALI_TEST_EQUALS(stream.str(), "[ Axis: [1, 0, 0], Angle: 120 degrees ]", TEST_LOCATION);
1356   }
1357
1358   {
1359     value = Property::Value(std::string("Foo"));
1360     std::ostringstream stream;
1361     stream << value;
1362     DALI_TEST_CHECK(stream.str() == "Foo");
1363   }
1364
1365   {
1366     Property::Map map;
1367     map.Insert("key", "value");
1368     map.Insert("duration", 10);
1369     map.Insert("color", Vector4(1.0, 0.5, 1.0, 1.0));
1370
1371     value = Property::Value(map);
1372     std::ostringstream stream;
1373     stream << value;
1374     tet_printf("Checking Property::Value is %s", stream.str().c_str());
1375     DALI_TEST_CHECK(!stream.str().compare("Map(3) = {key:value, duration:10, color:[1, 0.5, 1, 1]}"));
1376   }
1377   {
1378     Property::Array array;
1379     array.PushBack(0);
1380     array.PushBack(2);
1381     array.PushBack(3);
1382     value = Property::Value(array);
1383     std::ostringstream stream;
1384     stream << value;
1385     tet_printf("Checking Property::Value is %s", stream.str().c_str());
1386     DALI_TEST_CHECK(!stream.str().compare("Array(3) = [0, 2, 3]"));
1387   }
1388
1389   {
1390     Property::Map   map;
1391     Property::Map   map2;
1392     Property::Array array;
1393
1394     map2.Insert("key", "value");
1395     map2.Insert("duration", 10);
1396     map.Insert("color", Vector4(1.0, 0.5, 1.0, 1.0));
1397     map.Insert("timePeriod", map2);
1398     array.PushBack(Vector2(1, 0));
1399     array.PushBack(Vector2(0, 1));
1400     array.PushBack(Vector2(1, 0));
1401     array.PushBack(Vector2(0, 0.5));
1402     map.Insert("texCoords", array);
1403     value = Property::Value(map);
1404
1405     std::ostringstream stream;
1406     stream << value;
1407
1408     tet_printf("Checking Property::Value is %s", stream.str().c_str());
1409
1410     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]]}"));
1411   }
1412
1413   {
1414     value = Property::Value(Extents(1u, 2u, 3u, 4u));
1415     std::ostringstream stream;
1416     stream << value;
1417     DALI_TEST_CHECK(stream.str() == "[1, 2, 3, 4]");
1418   }
1419
1420   END_TEST;
1421 }