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

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