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