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

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