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

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