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