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

   1 /*
   2  * Copyright (c) 2019 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 <string>
  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 void utc_dali_property_map_startup(void)
  27 {
  28   test_return_value = TET_UNDEF;
  29 }
  30
  31 void utc_dali_property_map_cleanup(void)
  32 {
  33   test_return_value = TET_PASS;
  34 }
  35
  36 int UtcDaliPropertyMapPopulate(void)
  37 {
  38   Property::Map map;
  39   DALI_TEST_CHECK( map.Empty() );
  40
  41   map[ "hello" ] = 1;
  42   map[ 10 ] = "DALi";
  43   map[ "world" ] = "world";
  44   map[ 100 ] = 9;
  45   map[ "world" ] = 3; // same item as line above
  46   DALI_TEST_CHECK( !map.Empty() ); // Should no longer be empty
  47   DALI_TEST_CHECK( map.Count() == 4 ); // Should only have four items, not five!!
  48   DALI_TEST_CHECK( map["hello"].Get<int>() == 1 );
  49   DALI_TEST_CHECK( map["world"].Get<int>() == 3 );
  50   DALI_TEST_EQUALS( "DALi", map[ 10 ].Get<std::string>(), TEST_LOCATION );
  51   DALI_TEST_CHECK( map[100].Get<int>() == 9 );
  52
  53   map.Clear();
  54   DALI_TEST_CHECK( map.Empty() );
  55   END_TEST;
  56 }
  57
  58 int UtcDaliPropertyMapCopyAndAssignment(void)
  59 {
  60   Property::Map map;
  61   map[ "hello" ] = 1;
  62   map[ "world" ] = 2;
  63   map[ 10 ] = "DALi";
  64
  65   Property::Map assignedMap;
  66   assignedMap[ "foo" ] = 3;
  67   assignedMap[ 100 ] = 9;
  68   DALI_TEST_CHECK( assignedMap.Count() == 2 );
  69   assignedMap = map;
  70   DALI_TEST_CHECK( assignedMap.Count() == 3 );
  71
  72   Property::Map copiedMap( map );
  73   DALI_TEST_CHECK( copiedMap.Count() == 3 );
  74
  75   // Self assignment
  76   DALI_TEST_CHECK( map.Count() == 3 );
  77   map = map;
  78   DALI_TEST_CHECK( map.Count() == 3 );
  79
  80   END_TEST;
  81 }
  82
  83 int UtcDaliPropertyMapMoveConstructor(void)
  84 {
  85   Property::Map map1;
  86   map1[ "hello" ] = 1;
  87   map1[ "world" ] = 2;
  88   map1[ 10 ] = "DALi";
  89   DALI_TEST_EQUALS( 3u, map1.Count(), TEST_LOCATION );
  90
  91   Property::Map map2( std::move( map1 ) );
  92   DALI_TEST_EQUALS( 3u, map2.Count(), TEST_LOCATION );
  93
  94   // Calling any methods on map1 will debug assert
  95   const char * exceptionMessage = "Cannot use an object previously used as an r-value";
  96   DALI_TEST_ASSERTION( map1.Count(),                                            exceptionMessage );
  97   DALI_TEST_ASSERTION( map1.Empty(),                                            exceptionMessage );
  98   DALI_TEST_ASSERTION( map1.Insert( (const char *)"key", Property::Value() ),   exceptionMessage );
  99   DALI_TEST_ASSERTION( map1.Insert( std::string( "key" ), Property::Value() ),  exceptionMessage );
 100   DALI_TEST_ASSERTION( map1.Insert( 0, Property::Value() ),                     exceptionMessage );
 101   DALI_TEST_ASSERTION( map1.GetValue( 0 ),                                      exceptionMessage );
 102   DALI_TEST_ASSERTION( map1.GetKey( 0 ),                                        exceptionMessage );
 103   DALI_TEST_ASSERTION( map1.GetKeyAt( 1 ),                                      exceptionMessage );
 104   DALI_TEST_ASSERTION( map1.GetPair( 0 ),                                       exceptionMessage );
 105   DALI_TEST_ASSERTION( map1.GetKeyValue( 0 ),                                   exceptionMessage );
 106   DALI_TEST_ASSERTION( map1.Find( (const char *)"key" ),                        exceptionMessage );
 107   DALI_TEST_ASSERTION( map1.Find( std::string( "key" ) ),                       exceptionMessage );
 108   DALI_TEST_ASSERTION( map1.Find( 0 ),                                          exceptionMessage );
 109   DALI_TEST_ASSERTION( map1.Find( 0, "key" ),                                   exceptionMessage );
 110   DALI_TEST_ASSERTION( map1.Find( "key", Property::INTEGER ),                   exceptionMessage );
 111   DALI_TEST_ASSERTION( map1.Find( 0, Property::INTEGER ),                       exceptionMessage );
 112   DALI_TEST_ASSERTION( map1.Clear(),                                            exceptionMessage );
 113   DALI_TEST_ASSERTION( map1.Merge( Property::Map() ),                           exceptionMessage );
 114   DALI_TEST_ASSERTION( map1[ "key" ],                                           exceptionMessage );
 115   DALI_TEST_ASSERTION( const_cast< const Property::Map& >( map1 )[ "key" ],     exceptionMessage );
 116   DALI_TEST_ASSERTION( map1[ 0 ],                                               exceptionMessage );
 117   DALI_TEST_ASSERTION( const_cast< const Property::Map& >( map1 )[ 0 ],         exceptionMessage );
 118   DALI_TEST_ASSERTION( Property::Map temp; map1 = temp,                         exceptionMessage );
 119
 120   END_TEST;
 121 }
 122
 123 int UtcDaliPropertyMapMoveAssignmentOperator(void)
 124 {
 125   Property::Map map1;
 126   map1[ "hello" ] = 1;
 127   map1[ "world" ] = 2;
 128   map1[ 10 ] = "DALi";
 129   DALI_TEST_EQUALS( 3u, map1.Count(), TEST_LOCATION );
 130
 131   Property::Map map2;
 132   map2[ 10 ] = "DALi again";
 133   DALI_TEST_EQUALS( 1u, map2.Count(), TEST_LOCATION );
 134
 135   map2 = std::move( map1 );
 136   DALI_TEST_EQUALS( 3u, map2.Count(), TEST_LOCATION );
 137
 138   // Calling any methods on map1 will debug assert
 139   const char * exceptionMessage = "Cannot use an object previously used as an r-value";
 140   DALI_TEST_ASSERTION( map1.Count(),                                            exceptionMessage );
 141   DALI_TEST_ASSERTION( map1.Empty(),                                            exceptionMessage );
 142   DALI_TEST_ASSERTION( map1.Insert( (const char *)"key", Property::Value() ),   exceptionMessage );
 143   DALI_TEST_ASSERTION( map1.Insert( std::string( "key" ), Property::Value() ),  exceptionMessage );
 144   DALI_TEST_ASSERTION( map1.Insert( 0, Property::Value() ),                     exceptionMessage );
 145   DALI_TEST_ASSERTION( map1.GetValue( 0 ),                                      exceptionMessage );
 146   DALI_TEST_ASSERTION( map1.GetKey( 0 ),                                        exceptionMessage );
 147   DALI_TEST_ASSERTION( map1.GetKeyAt( 1 ),                                      exceptionMessage );
 148   DALI_TEST_ASSERTION( map1.GetPair( 0 ),                                       exceptionMessage );
 149   DALI_TEST_ASSERTION( map1.GetKeyValue( 0 ),                                   exceptionMessage );
 150   DALI_TEST_ASSERTION( map1.Find( (const char *)"key" ),                        exceptionMessage );
 151   DALI_TEST_ASSERTION( map1.Find( std::string( "key" ) ),                       exceptionMessage );
 152   DALI_TEST_ASSERTION( map1.Find( 0 ),                                          exceptionMessage );
 153   DALI_TEST_ASSERTION( map1.Find( 0, "key" ),                                   exceptionMessage );
 154   DALI_TEST_ASSERTION( map1.Find( "key", Property::INTEGER ),                   exceptionMessage );
 155   DALI_TEST_ASSERTION( map1.Find( 0, Property::INTEGER ),                       exceptionMessage );
 156   DALI_TEST_ASSERTION( map1.Clear(),                                            exceptionMessage );
 157   DALI_TEST_ASSERTION( map1.Merge( Property::Map() ),                           exceptionMessage );
 158   DALI_TEST_ASSERTION( map1[ "key" ],                                           exceptionMessage );
 159   DALI_TEST_ASSERTION( const_cast< const Property::Map& >( map1 )[ "key" ],     exceptionMessage );
 160   DALI_TEST_ASSERTION( map1[ 0 ],                                               exceptionMessage );
 161   DALI_TEST_ASSERTION( const_cast< const Property::Map& >( map1 )[ 0 ],         exceptionMessage );
 162   DALI_TEST_ASSERTION( Property::Map temp; map1 = temp,                         exceptionMessage );
 163
 164   // Self assignment
 165   map2 = std::move( map2 );
 166   DALI_TEST_EQUALS( 3u, map2.Count(), TEST_LOCATION ); // No debug assert as nothing should happen
 167
 168   END_TEST;
 169 }
 170
 171 int UtcDaliPropertyMapConstOperator(void)
 172 {
 173   Property::Map map;
 174   map[ "hello" ] = 1;
 175   map[ 10 ] = "DALi";
 176   map[ "world" ] = 2;
 177   DALI_TEST_CHECK( map.Count() == 3 );
 178
 179   const Property::Map& constMap( map );
 180   DALI_TEST_CHECK( constMap[ "world" ].Get<int>() == 2 );
 181   DALI_TEST_CHECK( constMap.Count() == 3 ); // Ensure count hasn't gone up
 182
 183   DALI_TEST_EQUALS( "DALi", map[ 10 ].Get<std::string>(), TEST_LOCATION );
 184   DALI_TEST_CHECK( constMap.Count() == 3 ); // Ensure count hasn't gone up
 185
 186   // Invalid Key
 187   try
 188   {
 189     constMap[ "invalidKey" ];
 190     tet_result( TET_FAIL );
 191   }
 192   catch ( DaliException& e )
 193   {
 194     DALI_TEST_ASSERT( e, "! \"Invalid Key\"", TEST_LOCATION );
 195   }
 196
 197   END_TEST;
 198 }
 199
 200 int UtcDaliPropertyMapGetValue(void)
 201 {
 202   Property::Map map;
 203   map[ "hello" ] = 1;
 204   map[ "world" ] = 2;
 205   map[ Actor::Property::COLOR ] = Color::MAGENTA;
 206
 207   Property::Value& value = map.GetValue( 0 );
 208   DALI_TEST_CHECK( value.Get<int>() == 1 );
 209   value = 10; // Allows the actual changing of the value as we have a ref
 210   DALI_TEST_CHECK( map[ "hello" ].Get<int>() == 10 );
 211
 212   Property::Value& value2 = map.GetValue( 2 );
 213   DALI_TEST_CHECK( value2.Get<Vector4>() == Color::MAGENTA );
 214   value2 = Color::CYAN;
 215   DALI_TEST_EQUALS( map[ Actor::Property::COLOR].Get<Vector4>(), Color::CYAN, TEST_LOCATION);
 216
 217   // Out of bounds
 218   try
 219   {
 220     map.GetValue( 3 );
 221     tet_result( TET_FAIL );
 222   }
 223   catch ( DaliException& e )
 224   {
 225     DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
 226   }
 227
 228   END_TEST;
 229 }
 230
 231 // deprecated API, only retrieve the key from the string-value pairs
 232 int UtcDaliPropertyMapGetKey(void)
 233 {
 234   Property::Map map;
 235   map[ "hello" ] = 1;
 236   map[ "world" ] = 2;
 237   map[ Actor::Property::COLOR ] = Color::MAGENTA;
 238
 239   DALI_TEST_CHECK( map.GetKey( 0 ) == "hello" );
 240   DALI_TEST_CHECK( map.GetKey( 1 ) == "world" );
 241
 242   // Wrong type
 243   try
 244   {
 245     map.GetKey( 2 );
 246     tet_result( TET_FAIL );
 247   }
 248   catch ( DaliException& e )
 249   {
 250     DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
 251   }
 252
 253   // Out of bounds
 254   try
 255   {
 256     map.GetKey( 3 );
 257     tet_result( TET_FAIL );
 258   }
 259   catch ( DaliException& e )
 260   {
 261     DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
 262   }
 263
 264   END_TEST;
 265 }
 266
 267
 268 int UtcDaliPropertyMapGetKeyAt(void)
 269 {
 270   Property::Map map;
 271   map[ "hello" ] = 1;
 272   map[ "world" ] = 2;
 273   map[ Actor::Property::COLOR ] = Color::MAGENTA;
 274
 275   DALI_TEST_CHECK( map.GetKeyAt( 0 ) == "hello" );
 276   DALI_TEST_CHECK( map.GetKeyAt( 1 ) == "world" );
 277   DALI_TEST_CHECK( map.GetKeyAt( 2 ) == Actor::Property::COLOR );
 278
 279   // Out of bounds
 280   try
 281   {
 282     map.GetKey( 3 );
 283     tet_result( TET_FAIL );
 284   }
 285   catch ( DaliException& e )
 286   {
 287     DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
 288   }
 289
 290   END_TEST;
 291 }
 292
 293 int UtcDaliPropertyMapGetPair(void)
 294 {
 295   Property::Map map;
 296   map[ "hello" ] = 1;
 297   map[ "world" ] = 2;
 298   map[ Actor::Property::COLOR ] = Color::MAGENTA;
 299
 300   DALI_TEST_CHECK( map.GetPair( 0 ).first == "hello" );
 301   DALI_TEST_CHECK( map.GetPair( 0 ).second.Get< int >() == 1 );
 302   DALI_TEST_CHECK( map.GetPair( 1 ).first == "world" );
 303   DALI_TEST_CHECK( map.GetPair( 1 ).second.Get< int >() == 2 );
 304
 305   // Wrong Type
 306   try
 307   {
 308     map.GetPair( 2 );
 309     tet_result( TET_FAIL );
 310   }
 311   catch ( DaliException& e )
 312   {
 313     DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
 314   }
 315
 316   // Out of bounds
 317   try
 318   {
 319     map.GetPair( 3 );
 320     tet_result( TET_FAIL );
 321   }
 322   catch ( DaliException& e )
 323   {
 324     DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
 325   }
 326
 327   END_TEST;
 328 }
 329
 330 int UtcDaliPropertyMapGetKeyValue(void)
 331 {
 332   Property::Map map;
 333   map[ "hello" ] = 1;
 334   map[ "world" ] = 2;
 335   map[ Actor::Property::COLOR ] = Color::MAGENTA;
 336
 337   DALI_TEST_CHECK( map.GetKeyValue( 0 ).first == "hello" );
 338   DALI_TEST_CHECK( map.GetKeyValue( 0 ).second.Get< int >() == 1 );
 339   DALI_TEST_CHECK( map.GetKeyValue( 1 ).first == "world" );
 340   DALI_TEST_CHECK( map.GetKeyValue( 1 ).second.Get< int >() == 2 );
 341   DALI_TEST_CHECK( map.GetKeyValue( 2 ).first == Actor::Property::COLOR );
 342   DALI_TEST_CHECK( map.GetKeyValue( 2 ).second.Get< Vector4 >() == Color::MAGENTA );
 343
 344   // Out of bounds
 345   try
 346   {
 347     map.GetPair( 3 );
 348     tet_result( TET_FAIL );
 349   }
 350   catch ( DaliException& e )
 351   {
 352     DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
 353   }
 354
 355   END_TEST;
 356 }
 357
 358 int UtcDaliPropertyMapFind(void)
 359 {
 360   Property::Map map;
 361   map[ "hello" ] = 1;
 362   map[ 10 ] = "DALi";
 363   map[ "world" ] = 2;
 364   map[ 100 ] = 9;
 365
 366   Property::Value* value = NULL;
 367
 368   value = map.Find( "hello" );
 369   DALI_TEST_CHECK( value );
 370   DALI_TEST_CHECK( value->Get<int>() == 1 );
 371
 372   const std::string world("world");
 373   value = map.Find( world );
 374   DALI_TEST_CHECK( value );
 375   DALI_TEST_CHECK( value->Get<int>() == 2 );
 376
 377   value = map.Find( 100 );
 378   DALI_TEST_CHECK( value );
 379   DALI_TEST_CHECK( value->Get<int>() == 9 );
 380
 381   value = map.Find( 10, Property::STRING );
 382   DALI_TEST_CHECK( value );
 383   DALI_TEST_EQUALS( "DALi", value->Get<std::string>(), TEST_LOCATION );
 384
 385   value = map.Find( 10, Property::INTEGER );
 386   DALI_TEST_CHECK( value == NULL );
 387
 388   value = map.Find( "invalidKey" );
 389   DALI_TEST_CHECK( !value );
 390
 391   END_TEST;
 392 }
 393
 394 int UtcDaliPropertyMapFindIndexThenString(void)
 395 {
 396   // Define the valid keys and values to test with.
 397   std::string stringKeyValid = "bar";
 398   std::string stringKeyInvalid = "aardvark";
 399   int indexKeyValid = 100;
 400   int indexKeyInvalid = 101;
 401
 402   // Define invalid key and value to test with.
 403   std::string stringValueValid = "DALi";
 404   int indexValueValid = 3;
 405
 406   // Set up a property map containing the valid keys and values defined above.
 407   Property::Map map;
 408   map[ "foo" ] = 1;
 409   map[ 10 ] = "string";
 410   map[ stringKeyValid ] = stringValueValid;
 411   map[ indexKeyValid ] = indexValueValid;
 412
 413   Property::Value* value = NULL;
 414
 415   // TEST: If both index and string are valid, the Property::Value of the index is returned.
 416   value = map.Find( indexKeyValid, stringKeyValid );
 417
 418   DALI_TEST_EQUALS( value->Get<int>(), indexValueValid, TEST_LOCATION );
 419
 420
 421   // TEST: If only the index is valid, the Property::Value of the index is returned.
 422   value = map.Find( indexKeyValid, stringKeyInvalid );
 423
 424   DALI_TEST_EQUALS( value->Get<int>(), indexValueValid, TEST_LOCATION );
 425
 426
 427   // TEST: If only the string is valid, the Property::Value of the string is returned.
 428   value = map.Find( indexKeyInvalid, stringKeyValid );
 429
 430   DALI_TEST_EQUALS( value->Get<std::string>(), stringValueValid, TEST_LOCATION );
 431
 432
 433   // TEST: If neither the index or string are valid, then a NULL pointer is returned.
 434   value = map.Find( indexKeyInvalid, stringKeyInvalid );
 435
 436   DALI_TEST_CHECK( value == NULL );
 437
 438   END_TEST;
 439 }
 440
 441 int UtcDaliPropertyMapOperatorIndex(void)
 442 {
 443   Property::Map map;
 444   map[ "hello" ] = 1;
 445   map[ 10 ] = "DALi";
 446   map[ "world" ] = 2;
 447   map[ 100 ] = 9;
 448
 449   const Property::Map map2 = map;
 450   const Property::Value& value10 = map2[10];
 451   DALI_TEST_EQUALS( value10.Get<std::string>(), "DALi", TEST_LOCATION );
 452
 453   const Property::Value& value100 = map2[100];
 454   DALI_TEST_EQUALS( value100.Get<int>(), 9, TEST_LOCATION );
 455
 456   const Property::Value& valueHello = map2["hello"];
 457   DALI_TEST_EQUALS( valueHello.Get<int>(), 1, TEST_LOCATION );
 458
 459   END_TEST;
 460 }
 461
 462 int UtcDaliPropertyMapInsertP(void)
 463 {
 464   Property::Map map;
 465   DALI_TEST_EQUALS( 0u, map.Count(), TEST_LOCATION );
 466   map.Insert( "foo", "bar");
 467   DALI_TEST_EQUALS( 1u, map.Count(), TEST_LOCATION );
 468   Property::Value* value = map.Find( "foo" );
 469   DALI_TEST_CHECK( value );
 470   DALI_TEST_EQUALS( "bar", value->Get<std::string>(), TEST_LOCATION );
 471
 472   map.Insert( std::string("foo2"), "testing" );
 473   DALI_TEST_EQUALS( 2u, map.Count(), TEST_LOCATION );
 474   value = map.Find( "foo2" );
 475   DALI_TEST_CHECK( value );
 476   DALI_TEST_EQUALS( "testing", value->Get<std::string>(), TEST_LOCATION );
 477
 478   map.Insert( 10, "DALi" );
 479   DALI_TEST_EQUALS( 3u, map.Count(), TEST_LOCATION );
 480   value = map.Find( 10 );
 481   DALI_TEST_CHECK( value );
 482   DALI_TEST_EQUALS( "DALi", value->Get<std::string>(), TEST_LOCATION );
 483
 484   map.Insert( 100, 9 );
 485   DALI_TEST_EQUALS( 4u, map.Count(), TEST_LOCATION );
 486   value = map.Find( 100 );
 487   DALI_TEST_CHECK( value );
 488   DALI_TEST_CHECK( value->Get<int>() == 9 );
 489
 490   END_TEST;
 491 }
 492
 493
 494 int UtcDaliPropertyMapAddP(void)
 495 {
 496   Property::Map map;
 497   DALI_TEST_EQUALS( 0u, map.Count(), TEST_LOCATION );
 498   map.Add( "foo", "bar");
 499   DALI_TEST_EQUALS( 1u, map.Count(), TEST_LOCATION );
 500   Property::Value* value = map.Find( "foo" );
 501   DALI_TEST_CHECK( value );
 502   DALI_TEST_EQUALS( "bar", value->Get<std::string>(), TEST_LOCATION );
 503
 504   map.Add( std::string("foo2"), "testing" );
 505   DALI_TEST_EQUALS( 2u, map.Count(), TEST_LOCATION );
 506   value = map.Find( "foo2" );
 507   DALI_TEST_CHECK( value );
 508   DALI_TEST_EQUALS( "testing", value->Get<std::string>(), TEST_LOCATION );
 509
 510   map.Add( 10, "DALi" );
 511   DALI_TEST_EQUALS( 3u, map.Count(), TEST_LOCATION );
 512   value = map.Find( 10 );
 513   DALI_TEST_CHECK( value );
 514   DALI_TEST_EQUALS( "DALi", value->Get<std::string>(), TEST_LOCATION );
 515
 516   map.Add( 100, 9 );
 517   DALI_TEST_EQUALS( 4u, map.Count(), TEST_LOCATION );
 518   value = map.Find( 100 );
 519   DALI_TEST_CHECK( value );
 520   DALI_TEST_CHECK( value->Get<int>() == 9 );
 521
 522   END_TEST;
 523 }
 524
 525 int UtcDaliPropertyMapAddChainP(void)
 526 {
 527   Property::Map map;
 528   DALI_TEST_EQUALS( 0u, map.Count(), TEST_LOCATION );
 529   map
 530     .Add( "foo", "bar")
 531     .Add( std::string("foo2"), "testing" )
 532     .Add( 10, "DALi" )
 533     .Add( 100, 9 );
 534
 535   DALI_TEST_EQUALS( 4u, map.Count(), TEST_LOCATION );
 536
 537   Property::Value* value = map.Find( "foo" );
 538   DALI_TEST_CHECK( value );
 539   DALI_TEST_EQUALS( "bar", value->Get<std::string>(), TEST_LOCATION );
 540
 541   value = map.Find( "foo2" );
 542   DALI_TEST_CHECK( value );
 543   DALI_TEST_EQUALS( "testing", value->Get<std::string>(), TEST_LOCATION );
 544
 545   value = map.Find( 10 );
 546   DALI_TEST_CHECK( value );
 547   DALI_TEST_EQUALS( "DALi", value->Get<std::string>(), TEST_LOCATION );
 548
 549   value = map.Find( 100 );
 550   DALI_TEST_CHECK( value );
 551   DALI_TEST_CHECK( value->Get<int>() == 9 );
 552
 553   END_TEST;
 554 }
 555
 556 int UtcDaliPropertyMapAnonymousAddChainP(void)
 557 {
 558   class TestMap
 559   {
 560   public:
 561     TestMap(Property::Map map)
 562     : mMap(map)
 563     {
 564     }
 565     Property::Map mMap;
 566   };
 567
 568   TestMap mapTest( Property::Map().Add( "foo", "bar")
 569                                   .Add( std::string("foo2"), "testing" )
 570                                   .Add( 10, "DALi" )
 571                                   .Add( 100, 9 ));
 572
 573
 574   Property::Value* value = mapTest.mMap.Find( "foo" );
 575   DALI_TEST_CHECK( value );
 576   DALI_TEST_EQUALS( "bar", value->Get<std::string>(), TEST_LOCATION );
 577
 578   value = mapTest.mMap.Find( "foo2" );
 579   DALI_TEST_CHECK( value );
 580   DALI_TEST_EQUALS( "testing", value->Get<std::string>(), TEST_LOCATION );
 581
 582   value = mapTest.mMap.Find( 10 );
 583   DALI_TEST_CHECK( value );
 584   DALI_TEST_EQUALS( "DALi", value->Get<std::string>(), TEST_LOCATION );
 585
 586   value = mapTest.mMap.Find( 100 );
 587   DALI_TEST_CHECK( value );
 588   DALI_TEST_CHECK( value->Get<int>() == 9 );
 589
 590   END_TEST;
 591 }
 592
 593
 594 int UtcDaliPropertyMapMerge(void)
 595 {
 596   Property::Map map;
 597   map[ "hello" ] = 1;
 598   map[ 10 ] = "DALi";
 599   map[ "world" ] = 2;
 600
 601   DALI_TEST_CHECK( map.Count() == 3 );
 602
 603   // Create another map with the same keys but different values
 604   Property::Map map2;
 605   map2[ "hello" ] = 3;
 606   map2[ "world" ] = 4;
 607   map[ 10 ] = "3DEngine";
 608
 609   // Merge map2 into map1, count should still be 2, map values should be from map2
 610   map.Merge( map2 );
 611   DALI_TEST_CHECK( map.Count() == 3 );
 612   DALI_TEST_CHECK( map[ "hello" ].Get< int >() == 3 );
 613   DALI_TEST_CHECK( map[ "world"].Get< int >() == 4 );
 614   DALI_TEST_EQUALS( "3DEngine", map[ 10 ].Get<std::string>(), TEST_LOCATION );
 615
 616   // Create another map with different keys
 617   Property::Map map3;
 618   map3[ "foo" ] = 5;
 619   map3[ 100 ] = 6;
 620
 621   // Merge map3 into map1, count should increase, existing values should match previous and new values should match map3
 622   map.Merge( map3 );
 623   DALI_TEST_CHECK( map.Count() == 5 );
 624   DALI_TEST_CHECK( map[ "hello" ].Get< int >() == 3 );
 625   DALI_TEST_CHECK( map[ "world"].Get< int >() == 4 );
 626   DALI_TEST_CHECK( map[ "foo"].Get< int >() == 5 );
 627   DALI_TEST_EQUALS( "3DEngine", map[ 10 ].Get<std::string>(), TEST_LOCATION );
 628   DALI_TEST_CHECK( map[ 100].Get< int >() == 6 );
 629
 630   // Create an empty map and attempt to merge, should be successful, nothing should change
 631   Property::Map map4;
 632   DALI_TEST_CHECK( map4.Empty() );
 633   map.Merge( map4 );
 634   DALI_TEST_CHECK( map4.Empty() );
 635   DALI_TEST_CHECK( map.Count() == 5 );
 636   DALI_TEST_CHECK( map[ "hello" ].Get< int >() == 3 );
 637   DALI_TEST_CHECK( map[ "world"].Get< int >() == 4 );
 638   DALI_TEST_CHECK( map[ "foo"].Get< int >() == 5 );
 639   DALI_TEST_EQUALS( "3DEngine", map[ 10 ].Get<std::string>(), TEST_LOCATION );
 640   DALI_TEST_CHECK( map[ 100 ].Get< int >() == 6 );
 641
 642   // Merge map into map4, map4 should be the same as map now.
 643   map4.Merge( map );
 644   DALI_TEST_CHECK( map4.Count() == 5 );
 645   DALI_TEST_CHECK( map4[ "hello" ].Get< int >() == 3 );
 646   DALI_TEST_CHECK( map4[ "world"].Get< int >() == 4 );
 647   DALI_TEST_CHECK( map4[ "foo"].Get< int >() == 5 );
 648   DALI_TEST_EQUALS( "3DEngine", map[ 10 ].Get<std::string>(), TEST_LOCATION );
 649   DALI_TEST_CHECK( map4[ 100 ].Get< int >() == 6 );
 650
 651   // Attempt to merge into itself, should be successful, nothing should change
 652   map.Merge( map );
 653   DALI_TEST_CHECK( map.Count() == 5 );
 654   DALI_TEST_CHECK( map[ "hello" ].Get< int >() == 3 );
 655   DALI_TEST_CHECK( map[ "world"].Get< int >() == 4 );
 656   DALI_TEST_CHECK( map[ "foo"].Get< int >() == 5 );
 657   DALI_TEST_EQUALS( "3DEngine", map[ 10 ].Get<std::string>(), TEST_LOCATION );
 658   DALI_TEST_CHECK( map[ 100 ].Get< int >() == 6 );
 659
 660   END_TEST;
 661 }
 662
 663 int UtcDaliPropertyMapOstream01(void)
 664 {
 665   Property::Map map;
 666
 667   map.Insert("duration", 5.0f);
 668   map.Insert( 10, "DALi" );
 669   map.Insert("delay", 1.0f);
 670   map.Insert( 100, 9 );
 671   map.Insert("value", 100);
 672
 673   std::ostringstream oss;
 674   oss << map;
 675
 676   tet_printf("Testing ouput of map: %s\n", oss.str().c_str());
 677
 678   // string-value pairs first, then index-value pairs
 679   DALI_TEST_EQUALS( oss.str().compare("Map(5) = {duration:5, delay:1, value:100, 10:DALi, 100:9}"), 0, TEST_LOCATION );
 680
 681   END_TEST;
 682 }
 683
 684
 685 int UtcDaliPropertyMapOstream02(void)
 686 {
 687   Property::Map map, map2;
 688
 689   map2.Insert("duration", 5.0f);
 690   map2.Insert("delay", 1.0f);
 691   map2.Insert( 10, "DALi" );
 692   map.Insert("timePeriod", map2);
 693   map.Insert( 100, 9 );
 694   map.Insert("value", 100);
 695
 696   std::ostringstream oss;
 697   oss << map;
 698
 699   tet_printf("Testing ouput of map: %s\n", oss.str().c_str());
 700
 701   // string-value pairs first, then index-value pairs
 702   DALI_TEST_EQUALS( oss.str().compare("Map(3) = {timePeriod:Map(3) = {duration:5, delay:1, 10:DALi}, value:100, 100:9}"), 0, TEST_LOCATION );
 703
 704   END_TEST;
 705 }
 706
 707 int UtcDaliPropertyKeyConstructorP(void)
 708 {
 709   Property::Key key1( "aKey" );
 710   DALI_TEST_EQUALS( key1.type, Property::Key::STRING, TEST_LOCATION );
 711   DALI_TEST_EQUALS( key1.stringKey, "aKey", TEST_LOCATION );
 712   DALI_TEST_EQUALS( key1.indexKey, Property::INVALID_INDEX, TEST_LOCATION );
 713
 714   Property::Key key2( Actor::Property::COLOR );
 715   DALI_TEST_EQUALS( key2.type, Property::Key::INDEX, TEST_LOCATION );
 716   DALI_TEST_EQUALS( key2.indexKey, (Dali::Property::Index)Actor::Property::COLOR, TEST_LOCATION );
 717   END_TEST;
 718 }
 719
 720 int UtcDaliPropertyKeyEqualityOperatorP(void)
 721 {
 722   Property::Key key1( "aKey" );
 723   Property::Key key2( 113 );
 724
 725   DALI_TEST_CHECK( key1 == "aKey" );
 726   DALI_TEST_CHECK( ! (key1 == "notTheKey") );
 727   DALI_TEST_CHECK( ! (key1 == 1) );
 728
 729   DALI_TEST_CHECK( key2 == 113 );
 730   DALI_TEST_CHECK( ! (key2 == 0) );
 731   DALI_TEST_CHECK( ! (key2 == "One hundred and thirteen" ) );
 732
 733   DALI_TEST_CHECK( ! (key1 == key2) );
 734   DALI_TEST_CHECK( key1 != key2 );
 735
 736   Property::Key key1B( "aKey" );
 737   Property::Key key2B( 113 );
 738
 739   DALI_TEST_CHECK( key1 == key1B );
 740   DALI_TEST_CHECK( key2 == key2B );
 741
 742   END_TEST;
 743 }
 744
 745 int UtcDaliPropertyKeyInequalityOperatorP(void)
 746 {
 747   Property::Key key1( "aKey" );
 748   Property::Key key2( 113 );
 749
 750   DALI_TEST_CHECK( key1 != "notTheKey" );
 751   DALI_TEST_CHECK( key1 != 1 );
 752
 753   DALI_TEST_CHECK( key2 != 0 );
 754   DALI_TEST_CHECK( key2 != "One hundred and thirteen" );
 755
 756   DALI_TEST_CHECK( key1 != key2 );
 757
 758   END_TEST;
 759 }
 760
 761
 762 int UtcDaliPropertyKeyOutputStream(void)
 763 {
 764   Property::Key key1( "aKey" );
 765   Property::Key key2( 113 );
 766
 767   std::ostringstream oss;
 768   oss << key1;
 769   DALI_TEST_EQUALS( oss.str(), "aKey", TEST_LOCATION );
 770
 771   std::ostringstream oss2;
 772   oss2 << key2;
 773   DALI_TEST_EQUALS( oss2.str(), "113", TEST_LOCATION );
 774
 775   END_TEST;
 776 }
 777
 778 int UtcDaliPropertyMapInitializerListConstructor(void)
 779 {
 780   auto map = Property::Map{
 781       {"number mapped to string", 1},
 782       {10, "string mapped to number"},
 783       {"string mapped", "to string"},
 784       {100, 3},
 785   };
 786
 787   DALI_TEST_CHECK( !map.Empty() );    // Should not be empty
 788   DALI_TEST_EQUALS( 4, map.Count(), TEST_LOCATION ); // Should have four items
 789
 790   DALI_TEST_EQUALS( 1, map[ "number mapped to string" ].Get< int >(), TEST_LOCATION );
 791   DALI_TEST_EQUALS( "string mapped to number", map[ 10 ].Get< std::string >(), TEST_LOCATION );
 792   DALI_TEST_EQUALS( "to string", map[ "string mapped" ].Get< std::string >(), TEST_LOCATION );
 793   DALI_TEST_EQUALS( 3, map[ 100 ].Get< int >(), TEST_LOCATION );
 794
 795   END_TEST;
 796 }
 797
 798 int UtcDaliPropertyMapNestedInitializerListConstructor(void)
 799 {
 800   auto map = Property::Map
 801   {
 802     {1, 1},
 803     {2, {{2, 2}}},
 804     {3, {{3, {{3, 3}}}}}
 805   };
 806
 807   DALI_TEST_CHECK( !map.Empty() );
 808   DALI_TEST_EQUALS( 3, map.Count(), TEST_LOCATION );
 809
 810   // Check first item
 811   {
 812     DALI_TEST_EQUALS( 1, map[ 1 ].Get< int >(), TEST_LOCATION );
 813   }
 814
 815   // Check second item
 816   {
 817     auto& value1 = map[ 2 ];
 818     DALI_TEST_EQUALS( Property::MAP, value1.GetType(), TEST_LOCATION );
 819
 820     auto& map2 = *(value1.GetMap());
 821     DALI_TEST_EQUALS( 1, map2.Count(), TEST_LOCATION );
 822
 823     // check the value
 824     DALI_TEST_EQUALS( 2, map2[ 2 ].Get< int >(), TEST_LOCATION );
 825   }
 826
 827   // Check the third item
 828   {
 829     auto& value1 = map[ 3 ];
 830     DALI_TEST_EQUALS( Property::MAP, value1.GetType(), TEST_LOCATION );
 831
 832     auto& map2 = *(value1.GetMap());
 833     DALI_TEST_EQUALS( 1, map2.Count(), TEST_LOCATION );
 834
 835     auto& value2 = map2[ 3 ];
 836     DALI_TEST_EQUALS( Property::MAP, value2.GetType(), TEST_LOCATION );
 837
 838     auto& map3 = *(value2.GetMap());
 839     DALI_TEST_EQUALS( 1, map3.Count(), TEST_LOCATION );
 840
 841     // check the value
 842     DALI_TEST_EQUALS( 3, map3[ 3 ].Get< int >(), TEST_LOCATION );
 843   }
 844
 845   END_TEST;
 846 }