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

   1 /*
   2  * Copyright (c) 2020 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 UtcDaliPropertyMapMerge(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
 594   // Create another map with the same keys but different values
 595   Property::Map map2;
 596   map2["hello"] = 3;
 597   map2["world"] = 4;
 598   map[10]       = "3DEngine";
 599
 600   // Merge map2 into map1, count should still be 2, map values should be from map2
 601   map.Merge(map2);
 602   DALI_TEST_CHECK(map.Count() == 3);
 603   DALI_TEST_CHECK(map["hello"].Get<int>() == 3);
 604   DALI_TEST_CHECK(map["world"].Get<int>() == 4);
 605   DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
 606
 607   // Create another map with different keys
 608   Property::Map map3;
 609   map3["foo"] = 5;
 610   map3[100]   = 6;
 611
 612   // Merge map3 into map1, count should increase, existing values should match previous and new values should match map3
 613   map.Merge(map3);
 614   DALI_TEST_CHECK(map.Count() == 5);
 615   DALI_TEST_CHECK(map["hello"].Get<int>() == 3);
 616   DALI_TEST_CHECK(map["world"].Get<int>() == 4);
 617   DALI_TEST_CHECK(map["foo"].Get<int>() == 5);
 618   DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
 619   DALI_TEST_CHECK(map[100].Get<int>() == 6);
 620
 621   // Create an empty map and attempt to merge, should be successful, nothing should change
 622   Property::Map map4;
 623   DALI_TEST_CHECK(map4.Empty());
 624   map.Merge(map4);
 625   DALI_TEST_CHECK(map4.Empty());
 626   DALI_TEST_CHECK(map.Count() == 5);
 627   DALI_TEST_CHECK(map["hello"].Get<int>() == 3);
 628   DALI_TEST_CHECK(map["world"].Get<int>() == 4);
 629   DALI_TEST_CHECK(map["foo"].Get<int>() == 5);
 630   DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
 631   DALI_TEST_CHECK(map[100].Get<int>() == 6);
 632
 633   // Merge map into map4, map4 should be the same as map now.
 634   map4.Merge(map);
 635   DALI_TEST_CHECK(map4.Count() == 5);
 636   DALI_TEST_CHECK(map4["hello"].Get<int>() == 3);
 637   DALI_TEST_CHECK(map4["world"].Get<int>() == 4);
 638   DALI_TEST_CHECK(map4["foo"].Get<int>() == 5);
 639   DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
 640   DALI_TEST_CHECK(map4[100].Get<int>() == 6);
 641
 642   // Attempt to merge into itself, should be successful, nothing should change
 643   map.Merge(map);
 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   END_TEST;
 652 }
 653
 654 int UtcDaliPropertyMapOstream01(void)
 655 {
 656   Property::Map map;
 657
 658   map.Insert("duration", 5.0f);
 659   map.Insert(10, "DALi");
 660   map.Insert("delay", 1.0f);
 661   map.Insert(100, 9);
 662   map.Insert("value", 100);
 663
 664   std::ostringstream oss;
 665   oss << map;
 666
 667   tet_printf("Testing ouput of map: %s\n", oss.str().c_str());
 668
 669   // string-value pairs first, then index-value pairs
 670   DALI_TEST_EQUALS(oss.str().compare("Map(5) = {duration:5, delay:1, value:100, 10:DALi, 100:9}"), 0, TEST_LOCATION);
 671
 672   END_TEST;
 673 }
 674
 675 int UtcDaliPropertyMapOstream02(void)
 676 {
 677   Property::Map map, map2;
 678
 679   map2.Insert("duration", 5.0f);
 680   map2.Insert("delay", 1.0f);
 681   map2.Insert(10, "DALi");
 682   map.Insert("timePeriod", map2);
 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(3) = {timePeriod:Map(3) = {duration:5, delay:1, 10:DALi}, value:100, 100:9}"), 0, TEST_LOCATION);
 693
 694   END_TEST;
 695 }
 696
 697 int UtcDaliPropertyKeyConstructorP(void)
 698 {
 699   Property::Key key1("aKey");
 700   DALI_TEST_EQUALS(key1.type, Property::Key::STRING, TEST_LOCATION);
 701   DALI_TEST_EQUALS(key1.stringKey, "aKey", TEST_LOCATION);
 702   DALI_TEST_EQUALS(key1.indexKey, Property::INVALID_INDEX, TEST_LOCATION);
 703
 704   Property::Key key2(Actor::Property::COLOR);
 705   DALI_TEST_EQUALS(key2.type, Property::Key::INDEX, TEST_LOCATION);
 706   DALI_TEST_EQUALS(key2.indexKey, (Dali::Property::Index)Actor::Property::COLOR, TEST_LOCATION);
 707   END_TEST;
 708 }
 709
 710 int UtcDaliPropertyKeyEqualityOperatorP(void)
 711 {
 712   Property::Key key1("aKey");
 713   Property::Key key2(113);
 714
 715   DALI_TEST_CHECK(key1 == "aKey");
 716   DALI_TEST_CHECK(!(key1 == "notTheKey"));
 717   DALI_TEST_CHECK(!(key1 == 1));
 718
 719   DALI_TEST_CHECK(key2 == 113);
 720   DALI_TEST_CHECK(!(key2 == 0));
 721   DALI_TEST_CHECK(!(key2 == "One hundred and thirteen"));
 722
 723   DALI_TEST_CHECK(!(key1 == key2));
 724   DALI_TEST_CHECK(key1 != key2);
 725
 726   Property::Key key1B("aKey");
 727   Property::Key key2B(113);
 728
 729   DALI_TEST_CHECK(key1 == key1B);
 730   DALI_TEST_CHECK(key2 == key2B);
 731
 732   END_TEST;
 733 }
 734
 735 int UtcDaliPropertyKeyInequalityOperatorP(void)
 736 {
 737   Property::Key key1("aKey");
 738   Property::Key key2(113);
 739
 740   DALI_TEST_CHECK(key1 != "notTheKey");
 741   DALI_TEST_CHECK(key1 != 1);
 742
 743   DALI_TEST_CHECK(key2 != 0);
 744   DALI_TEST_CHECK(key2 != "One hundred and thirteen");
 745
 746   DALI_TEST_CHECK(key1 != key2);
 747
 748   END_TEST;
 749 }
 750
 751 int UtcDaliPropertyKeyOutputStream(void)
 752 {
 753   Property::Key key1("aKey");
 754   Property::Key key2(113);
 755
 756   std::ostringstream oss;
 757   oss << key1;
 758   DALI_TEST_EQUALS(oss.str(), "aKey", TEST_LOCATION);
 759
 760   std::ostringstream oss2;
 761   oss2 << key2;
 762   DALI_TEST_EQUALS(oss2.str(), "113", TEST_LOCATION);
 763
 764   END_TEST;
 765 }
 766
 767 int UtcDaliPropertyMapInitializerListConstructor(void)
 768 {
 769   auto map = Property::Map{
 770     {"number mapped to string", 1},
 771     {10, "string mapped to number"},
 772     {"string mapped", "to string"},
 773     {100, 3},
 774   };
 775
 776   DALI_TEST_CHECK(!map.Empty());                   // Should not be empty
 777   DALI_TEST_EQUALS(4, map.Count(), TEST_LOCATION); // Should have four items
 778
 779   DALI_TEST_EQUALS(1, map["number mapped to string"].Get<int>(), TEST_LOCATION);
 780   DALI_TEST_EQUALS("string mapped to number", map[10].Get<std::string>(), TEST_LOCATION);
 781   DALI_TEST_EQUALS("to string", map["string mapped"].Get<std::string>(), TEST_LOCATION);
 782   DALI_TEST_EQUALS(3, map[100].Get<int>(), TEST_LOCATION);
 783
 784   END_TEST;
 785 }
 786
 787 int UtcDaliPropertyMapNestedInitializerListConstructor(void)
 788 {
 789   auto map = Property::Map{
 790     {1, 1},
 791     {2, {{2, 2}}},
 792     {3, {{3, {{3, 3}}}}}};
 793
 794   DALI_TEST_CHECK(!map.Empty());
 795   DALI_TEST_EQUALS(3, map.Count(), TEST_LOCATION);
 796
 797   // Check first item
 798   {
 799     DALI_TEST_EQUALS(1, map[1].Get<int>(), TEST_LOCATION);
 800   }
 801
 802   // Check second item
 803   {
 804     auto& value1 = map[2];
 805     DALI_TEST_EQUALS(Property::MAP, value1.GetType(), TEST_LOCATION);
 806
 807     auto& map2 = *(value1.GetMap());
 808     DALI_TEST_EQUALS(1, map2.Count(), TEST_LOCATION);
 809
 810     // check the value
 811     DALI_TEST_EQUALS(2, map2[2].Get<int>(), TEST_LOCATION);
 812   }
 813
 814   // Check the third item
 815   {
 816     auto& value1 = map[3];
 817     DALI_TEST_EQUALS(Property::MAP, value1.GetType(), TEST_LOCATION);
 818
 819     auto& map2 = *(value1.GetMap());
 820     DALI_TEST_EQUALS(1, map2.Count(), TEST_LOCATION);
 821
 822     auto& value2 = map2[3];
 823     DALI_TEST_EQUALS(Property::MAP, value2.GetType(), TEST_LOCATION);
 824
 825     auto& map3 = *(value2.GetMap());
 826     DALI_TEST_EQUALS(1, map3.Count(), TEST_LOCATION);
 827
 828     // check the value
 829     DALI_TEST_EQUALS(3, map3[3].Get<int>(), TEST_LOCATION);
 830   }
 831
 832   END_TEST;
 833 }