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

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