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

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