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

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