X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali%2Futc-Dali-PropertyMap.cpp;h=61edaee0ff16c174edc5df3ccedf0625eb0f1f4f;hb=b6e3c77d9956fa042d06b396c5e5cbf1768614f0;hp=bb17787d5fc54d53204cff29f4f63c2db9b7ad6d;hpb=92e7cadff8208604a66f43925f6dc7c8627cb229;p=platform%2Fcore%2Fuifw%2Fdali-core.git

diff --git a/automated-tests/src/dali/utc-Dali-PropertyMap.cpp b/automated-tests/src/dali/utc-Dali-PropertyMap.cpp
old mode 100644
new mode 100755
index bb17787..61edaee
--- a/automated-tests/src/dali/utc-Dali-PropertyMap.cpp
+++ b/automated-tests/src/dali/utc-Dali-PropertyMap.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,11 +15,12 @@
  *
  */
 
+#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
 #include <iostream>
 #include <string>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali-test-suite-utils.h>
 
 using namespace Dali;
 
@@ -36,46 +37,134 @@ void utc_dali_property_map_cleanup(void)
 int UtcDaliPropertyMapPopulate(void)
 {
   Property::Map map;
-  DALI_TEST_CHECK( map.Empty() );
-
-  map[ "hello" ] = 1;
-  map[ 10 ] = "DALi";
-  map[ "world" ] = "world";
-  map[ 100 ] = 9;
-  map[ "world" ] = 3; // same item as line above
-  DALI_TEST_CHECK( !map.Empty() ); // Should no longer be empty
-  DALI_TEST_CHECK( map.Count() == 4 ); // Should only have four items, not five!!
-  DALI_TEST_CHECK( map["hello"].Get<int>() == 1 );
-  DALI_TEST_CHECK( map["world"].Get<int>() == 3 );
-  DALI_TEST_EQUALS( "DALi", map[ 10 ].Get<std::string>(), TEST_LOCATION );
-  DALI_TEST_CHECK( map[100].Get<int>() == 9 );
+  DALI_TEST_CHECK(map.Empty());
+
+  map["hello"] = 1;
+  map[10]      = "DALi";
+  map["world"] = "world";
+  map[100]     = 9;
+  map["world"] = 3;                  // same item as line above
+  DALI_TEST_CHECK(!map.Empty());     // Should no longer be empty
+  DALI_TEST_CHECK(map.Count() == 4); // Should only have four items, not five!!
+  DALI_TEST_CHECK(map["hello"].Get<int>() == 1);
+  DALI_TEST_CHECK(map["world"].Get<int>() == 3);
+  DALI_TEST_EQUALS("DALi", map[10].Get<std::string>(), TEST_LOCATION);
+  DALI_TEST_CHECK(map[100].Get<int>() == 9);
 
   map.Clear();
-  DALI_TEST_CHECK( map.Empty() );
+  DALI_TEST_CHECK(map.Empty());
   END_TEST;
 }
 
 int UtcDaliPropertyMapCopyAndAssignment(void)
 {
   Property::Map map;
-  map[ "hello" ] = 1;
-  map[ "world" ] = 2;
-  map[ 10 ] = "DALi";
+  map["hello"] = 1;
+  map["world"] = 2;
+  map[10]      = "DALi";
 
   Property::Map assignedMap;
-  assignedMap[ "foo" ] = 3;
-  assignedMap[ 100 ] = 9;
-  DALI_TEST_CHECK( assignedMap.Count() == 2 );
+  assignedMap["foo"] = 3;
+  assignedMap[100]   = 9;
+  DALI_TEST_CHECK(assignedMap.Count() == 2);
   assignedMap = map;
-  DALI_TEST_CHECK( assignedMap.Count() == 3 );
+  DALI_TEST_CHECK(assignedMap.Count() == 3);
 
-  Property::Map copiedMap( map );
-  DALI_TEST_CHECK( copiedMap.Count() == 3 );
+  Property::Map copiedMap(map);
+  DALI_TEST_CHECK(copiedMap.Count() == 3);
 
   // Self assignment
-  DALI_TEST_CHECK( map.Count() == 3 );
+  DALI_TEST_CHECK(map.Count() == 3);
   map = map;
-  DALI_TEST_CHECK( map.Count() == 3 );
+  DALI_TEST_CHECK(map.Count() == 3);
+
+  END_TEST;
+}
+
+int UtcDaliPropertyMapMoveConstructor(void)
+{
+  Property::Map map1;
+  map1["hello"] = 1;
+  map1["world"] = 2;
+  map1[10]      = "DALi";
+  DALI_TEST_EQUALS(3u, map1.Count(), TEST_LOCATION);
+
+  Property::Map map2(std::move(map1));
+  DALI_TEST_EQUALS(3u, map2.Count(), TEST_LOCATION);
+
+  // Calling any methods on map1 will debug assert
+  const char* exceptionMessage = "Cannot use an object previously used as an r-value";
+  DALI_TEST_ASSERTION(map1.Count(), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Empty(), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Insert((const char*)"key", Property::Value()), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Insert(std::string("key"), Property::Value()), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Insert(0, Property::Value()), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.GetValue(0), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.GetKey(0), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.GetKeyAt(1), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.GetPair(0), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.GetKeyValue(0), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Find((const char*)"key"), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Find(std::string("key")), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Find(0), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Find(0, "key"), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Find("key", Property::INTEGER), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Find(0, Property::INTEGER), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Clear(), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Merge(Property::Map()), exceptionMessage);
+  DALI_TEST_ASSERTION(map1["key"], exceptionMessage);
+  DALI_TEST_ASSERTION(const_cast<const Property::Map&>(map1)["key"], exceptionMessage);
+  DALI_TEST_ASSERTION(map1[0], exceptionMessage);
+  DALI_TEST_ASSERTION(const_cast<const Property::Map&>(map1)[0], exceptionMessage);
+  DALI_TEST_ASSERTION(Property::Map temp; map1 = temp, exceptionMessage);
+
+  END_TEST;
+}
+
+int UtcDaliPropertyMapMoveAssignmentOperator(void)
+{
+  Property::Map map1;
+  map1["hello"] = 1;
+  map1["world"] = 2;
+  map1[10]      = "DALi";
+  DALI_TEST_EQUALS(3u, map1.Count(), TEST_LOCATION);
+
+  Property::Map map2;
+  map2[10] = "DALi again";
+  DALI_TEST_EQUALS(1u, map2.Count(), TEST_LOCATION);
+
+  map2 = std::move(map1);
+  DALI_TEST_EQUALS(3u, map2.Count(), TEST_LOCATION);
+
+  // Calling any methods on map1 will debug assert
+  const char* exceptionMessage = "Cannot use an object previously used as an r-value";
+  DALI_TEST_ASSERTION(map1.Count(), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Empty(), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Insert((const char*)"key", Property::Value()), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Insert(std::string("key"), Property::Value()), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Insert(0, Property::Value()), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.GetValue(0), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.GetKey(0), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.GetKeyAt(1), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.GetPair(0), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.GetKeyValue(0), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Find((const char*)"key"), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Find(std::string("key")), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Find(0), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Find(0, "key"), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Find("key", Property::INTEGER), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Find(0, Property::INTEGER), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Clear(), exceptionMessage);
+  DALI_TEST_ASSERTION(map1.Merge(Property::Map()), exceptionMessage);
+  DALI_TEST_ASSERTION(map1["key"], exceptionMessage);
+  DALI_TEST_ASSERTION(const_cast<const Property::Map&>(map1)["key"], exceptionMessage);
+  DALI_TEST_ASSERTION(map1[0], exceptionMessage);
+  DALI_TEST_ASSERTION(const_cast<const Property::Map&>(map1)[0], exceptionMessage);
+  DALI_TEST_ASSERTION(Property::Map temp; map1 = temp, exceptionMessage);
+
+  // Self assignment
+  map2 = std::move(map2);
+  DALI_TEST_EQUALS(3u, map2.Count(), TEST_LOCATION); // No debug assert as nothing should happen
 
   END_TEST;
 }
@@ -83,53 +172,58 @@ int UtcDaliPropertyMapCopyAndAssignment(void)
 int UtcDaliPropertyMapConstOperator(void)
 {
   Property::Map map;
-  map[ "hello" ] = 1;
-  map[ 10 ] = "DALi";
-  map[ "world" ] = 2;
-  DALI_TEST_CHECK( map.Count() == 3 );
+  map["hello"] = 1;
+  map[10]      = "DALi";
+  map["world"] = 2;
+  DALI_TEST_CHECK(map.Count() == 3);
 
-  const Property::Map& constMap( map );
-  DALI_TEST_CHECK( constMap[ "world" ].Get<int>() == 2 );
-  DALI_TEST_CHECK( constMap.Count() == 3 ); // Ensure count hasn't gone up
+  const Property::Map& constMap(map);
+  DALI_TEST_CHECK(constMap["world"].Get<int>() == 2);
+  DALI_TEST_CHECK(constMap.Count() == 3); // Ensure count hasn't gone up
 
-  DALI_TEST_EQUALS( "DALi", map[ 10 ].Get<std::string>(), TEST_LOCATION );
-  DALI_TEST_CHECK( constMap.Count() == 3 ); // Ensure count hasn't gone up
+  DALI_TEST_EQUALS("DALi", map[10].Get<std::string>(), TEST_LOCATION);
+  DALI_TEST_CHECK(constMap.Count() == 3); // Ensure count hasn't gone up
 
   // Invalid Key
   try
   {
-    constMap[ "invalidKey" ];
-    tet_result( TET_FAIL );
+    constMap["invalidKey"];
+    tet_result(TET_FAIL);
   }
-  catch ( DaliException& e )
+  catch(DaliException& e)
   {
-    DALI_TEST_ASSERT( e, "! \"Invalid Key\"", TEST_LOCATION );
+    DALI_TEST_ASSERT(e, "!\"Invalid Key\"", TEST_LOCATION);
   }
 
   END_TEST;
 }
 
-// deprecated API, only retrieve the value from string-value pairs
 int UtcDaliPropertyMapGetValue(void)
 {
   Property::Map map;
-  map[ "hello" ] = 1;
-  map[ "world" ] = 2;
+  map["hello"]                = 1;
+  map["world"]                = 2;
+  map[Actor::Property::COLOR] = Color::MAGENTA;
 
-  Property::Value& value = map.GetValue( 0 );
-  DALI_TEST_CHECK( value.Get<int>() == 1 );
+  Property::Value& value = map.GetValue(0);
+  DALI_TEST_CHECK(value.Get<int>() == 1);
   value = 10; // Allows the actual changing of the value as we have a ref
-  DALI_TEST_CHECK( map[ "hello" ].Get<int>() == 10 );
+  DALI_TEST_CHECK(map["hello"].Get<int>() == 10);
+
+  Property::Value& value2 = map.GetValue(2);
+  DALI_TEST_CHECK(value2.Get<Vector4>() == Color::MAGENTA);
+  value2 = Color::CYAN;
+  DALI_TEST_EQUALS(map[Actor::Property::COLOR].Get<Vector4>(), Color::CYAN, TEST_LOCATION);
 
   // Out of bounds
   try
   {
-    map.GetValue( 2 );
-    tet_result( TET_FAIL );
+    map.GetValue(3);
+    tet_result(TET_FAIL);
   }
-  catch ( DaliException& e )
+  catch(DaliException& e)
   {
-    DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
+    DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
   }
 
   END_TEST;
@@ -139,47 +233,123 @@ int UtcDaliPropertyMapGetValue(void)
 int UtcDaliPropertyMapGetKey(void)
 {
   Property::Map map;
-  map[ "hello" ] = 1;
-  map[ "world" ] = 2;
+  map["hello"]                = 1;
+  map["world"]                = 2;
+  map[Actor::Property::COLOR] = Color::MAGENTA;
 
-  DALI_TEST_CHECK( map.GetKey( 0 ) == "hello" );
-  DALI_TEST_CHECK( map.GetKey( 1 ) == "world" );
+  DALI_TEST_CHECK(map.GetKey(0) == "hello");
+  DALI_TEST_CHECK(map.GetKey(1) == "world");
+
+  // Wrong type
+  try
+  {
+    map.GetKey(2);
+    tet_result(TET_FAIL);
+  }
+  catch(DaliException& e)
+  {
+    DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
+  }
 
   // Out of bounds
   try
   {
-    map.GetKey( 2 );
-    tet_result( TET_FAIL );
+    map.GetKey(3);
+    tet_result(TET_FAIL);
   }
-  catch ( DaliException& e )
+  catch(DaliException& e)
   {
-    DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
+    DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
+  }
+
+  END_TEST;
+}
+
+int UtcDaliPropertyMapGetKeyAt(void)
+{
+  Property::Map map;
+  map["hello"]                = 1;
+  map["world"]                = 2;
+  map[Actor::Property::COLOR] = Color::MAGENTA;
+
+  DALI_TEST_CHECK(map.GetKeyAt(0) == "hello");
+  DALI_TEST_CHECK(map.GetKeyAt(1) == "world");
+  DALI_TEST_CHECK(map.GetKeyAt(2) == Actor::Property::COLOR);
+
+  // Out of bounds
+  try
+  {
+    map.GetKey(3);
+    tet_result(TET_FAIL);
+  }
+  catch(DaliException& e)
+  {
+    DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
   }
 
   END_TEST;
 }
 
-// deprecated API, only retrieve the string-value pairs
 int UtcDaliPropertyMapGetPair(void)
 {
   Property::Map map;
-  map[ "hello" ] = 1;
-  map[ "world" ] = 2;
+  map["hello"]                = 1;
+  map["world"]                = 2;
+  map[Actor::Property::COLOR] = Color::MAGENTA;
+
+  DALI_TEST_CHECK(map.GetPair(0).first == "hello");
+  DALI_TEST_CHECK(map.GetPair(0).second.Get<int>() == 1);
+  DALI_TEST_CHECK(map.GetPair(1).first == "world");
+  DALI_TEST_CHECK(map.GetPair(1).second.Get<int>() == 2);
+
+  // Wrong Type
+  try
+  {
+    map.GetPair(2);
+    tet_result(TET_FAIL);
+  }
+  catch(DaliException& e)
+  {
+    DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
+  }
+
+  // Out of bounds
+  try
+  {
+    map.GetPair(3);
+    tet_result(TET_FAIL);
+  }
+  catch(DaliException& e)
+  {
+    DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
+  }
+
+  END_TEST;
+}
+
+int UtcDaliPropertyMapGetKeyValue(void)
+{
+  Property::Map map;
+  map["hello"]                = 1;
+  map["world"]                = 2;
+  map[Actor::Property::COLOR] = Color::MAGENTA;
 
-  DALI_TEST_CHECK( map.GetPair( 0 ).first == "hello" );
-  DALI_TEST_CHECK( map.GetPair( 0 ).second.Get< int >() == 1 );
-  DALI_TEST_CHECK( map.GetPair( 1 ).first == "world" );
-  DALI_TEST_CHECK( map.GetPair( 1 ).second.Get< int >() == 2 );
+  DALI_TEST_CHECK(map.GetKeyValue(0).first == "hello");
+  DALI_TEST_CHECK(map.GetKeyValue(0).second.Get<int>() == 1);
+  DALI_TEST_CHECK(map.GetKeyValue(1).first == "world");
+  DALI_TEST_CHECK(map.GetKeyValue(1).second.Get<int>() == 2);
+  DALI_TEST_CHECK(map.GetKeyValue(2).first == Actor::Property::COLOR);
+  DALI_TEST_CHECK(map.GetKeyValue(2).second.Get<Vector4>() == Color::MAGENTA);
 
   // Out of bounds
   try
   {
-    map.GetPair( 2 );
-    tet_result( TET_FAIL );
+    map.GetPair(3);
+    tet_result(TET_FAIL);
   }
-  catch ( DaliException& e )
+  catch(DaliException& e)
   {
-    DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
+    DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
   }
 
   END_TEST;
@@ -188,57 +358,100 @@ int UtcDaliPropertyMapGetPair(void)
 int UtcDaliPropertyMapFind(void)
 {
   Property::Map map;
-  map[ "hello" ] = 1;
-  map[ 10 ] = "DALi";
-  map[ "world" ] = 2;
-  map[ 100 ] = 9;
+  map["hello"] = 1;
+  map[10]      = "DALi";
+  map["world"] = 2;
+  map[100]     = 9;
 
   Property::Value* value = NULL;
 
-  value = map.Find( "hello" );
-  DALI_TEST_CHECK( value );
-  DALI_TEST_CHECK( value->Get<int>() == 1 );
+  value = map.Find("hello");
+  DALI_TEST_CHECK(value);
+  DALI_TEST_CHECK(value->Get<int>() == 1);
 
   const std::string world("world");
-  value = map.Find( world );
-  DALI_TEST_CHECK( value );
-  DALI_TEST_CHECK( value->Get<int>() == 2 );
+  value = map.Find(world);
+  DALI_TEST_CHECK(value);
+  DALI_TEST_CHECK(value->Get<int>() == 2);
 
-  value = map.Find( 100 );
-  DALI_TEST_CHECK( value );
-  DALI_TEST_CHECK( value->Get<int>() == 9 );
+  value = map.Find(100);
+  DALI_TEST_CHECK(value);
+  DALI_TEST_CHECK(value->Get<int>() == 9);
 
-  value = map.Find( 10, Property::STRING );
-  DALI_TEST_CHECK( value );
-  DALI_TEST_EQUALS( "DALi", value->Get<std::string>(), TEST_LOCATION );
+  value = map.Find(10, Property::STRING);
+  DALI_TEST_CHECK(value);
+  DALI_TEST_EQUALS("DALi", value->Get<std::string>(), TEST_LOCATION);
 
-  value = map.Find( 10, Property::INTEGER );
-  DALI_TEST_CHECK( value == NULL );
+  value = map.Find(10, Property::INTEGER);
+  DALI_TEST_CHECK(value == NULL);
 
-  value = map.Find( "invalidKey" );
-  DALI_TEST_CHECK( !value );
+  value = map.Find("invalidKey");
+  DALI_TEST_CHECK(!value);
 
   END_TEST;
 }
 
+int UtcDaliPropertyMapFindIndexThenString(void)
+{
+  // Define the valid keys and values to test with.
+  std::string stringKeyValid   = "bar";
+  std::string stringKeyInvalid = "aardvark";
+  int         indexKeyValid    = 100;
+  int         indexKeyInvalid  = 101;
+
+  // Define invalid key and value to test with.
+  std::string stringValueValid = "DALi";
+  int         indexValueValid  = 3;
+
+  // Set up a property map containing the valid keys and values defined above.
+  Property::Map map;
+  map["foo"]          = 1;
+  map[10]             = "string";
+  map[stringKeyValid] = stringValueValid;
+  map[indexKeyValid]  = indexValueValid;
+
+  Property::Value* value = NULL;
+
+  // TEST: If both index and string are valid, the Property::Value of the index is returned.
+  value = map.Find(indexKeyValid, stringKeyValid);
+
+  DALI_TEST_EQUALS(value->Get<int>(), indexValueValid, TEST_LOCATION);
+
+  // TEST: If only the index is valid, the Property::Value of the index is returned.
+  value = map.Find(indexKeyValid, stringKeyInvalid);
+
+  DALI_TEST_EQUALS(value->Get<int>(), indexValueValid, TEST_LOCATION);
+
+  // TEST: If only the string is valid, the Property::Value of the string is returned.
+  value = map.Find(indexKeyInvalid, stringKeyValid);
+
+  DALI_TEST_EQUALS(value->Get<std::string>(), stringValueValid, TEST_LOCATION);
+
+  // TEST: If neither the index or string are valid, then a NULL pointer is returned.
+  value = map.Find(indexKeyInvalid, stringKeyInvalid);
+
+  DALI_TEST_CHECK(value == NULL);
+
+  END_TEST;
+}
 
 int UtcDaliPropertyMapOperatorIndex(void)
 {
   Property::Map map;
-  map[ "hello" ] = 1;
-  map[ 10 ] = "DALi";
-  map[ "world" ] = 2;
-  map[ 100 ] = 9;
+  map["hello"] = 1;
+  map[10]      = "DALi";
+  map["world"] = 2;
+  map[100]     = 9;
 
-  const Property::Map map2 = map;
+  const Property::Map    map2    = map;
   const Property::Value& value10 = map2[10];
-  DALI_TEST_EQUALS( value10.Get<std::string>(), "DALi", TEST_LOCATION );
+  DALI_TEST_EQUALS(value10.Get<std::string>(), "DALi", TEST_LOCATION);
 
   const Property::Value& value100 = map2[100];
-  DALI_TEST_EQUALS( value100.Get<int>(), 9, TEST_LOCATION );
+  DALI_TEST_EQUALS(value100.Get<int>(), 9, TEST_LOCATION);
 
   const Property::Value& valueHello = map2["hello"];
-  DALI_TEST_EQUALS( valueHello.Get<int>(), 1, TEST_LOCATION );
+  DALI_TEST_EQUALS(valueHello.Get<int>(), 1, TEST_LOCATION);
 
   END_TEST;
 }
@@ -246,30 +459,147 @@ int UtcDaliPropertyMapOperatorIndex(void)
 int UtcDaliPropertyMapInsertP(void)
 {
   Property::Map map;
-  DALI_TEST_EQUALS( 0u, map.Count(), TEST_LOCATION );
-  map.Insert( "foo", "bar");
-  DALI_TEST_EQUALS( 1u, map.Count(), TEST_LOCATION );
-  Property::Value* value = map.Find( "foo" );
-  DALI_TEST_CHECK( value );
-  DALI_TEST_EQUALS( "bar", value->Get<std::string>(), TEST_LOCATION );
-
-  map.Insert( std::string("foo2"), "testing" );
-  DALI_TEST_EQUALS( 2u, map.Count(), TEST_LOCATION );
-  value = map.Find( "foo2" );
-  DALI_TEST_CHECK( value );
-  DALI_TEST_EQUALS( "testing", value->Get<std::string>(), TEST_LOCATION );
-
-  map.Insert( 10, "DALi" );
-  DALI_TEST_EQUALS( 3u, map.Count(), TEST_LOCATION );
-  value = map.Find( 10 );
-  DALI_TEST_CHECK( value );
-  DALI_TEST_EQUALS( "DALi", value->Get<std::string>(), TEST_LOCATION );
-
-  map.Insert( 100, 9 );
-  DALI_TEST_EQUALS( 4u, map.Count(), TEST_LOCATION );
-  value = map.Find( 100 );
-  DALI_TEST_CHECK( value );
-  DALI_TEST_CHECK( value->Get<int>() == 9 );
+  DALI_TEST_EQUALS(0u, map.Count(), TEST_LOCATION);
+  map.Insert("foo", "bar");
+  DALI_TEST_EQUALS(1u, map.Count(), TEST_LOCATION);
+  Property::Value* value = map.Find("foo");
+  DALI_TEST_CHECK(value);
+  DALI_TEST_EQUALS("bar", value->Get<std::string>(), TEST_LOCATION);
+
+  map.Insert(std::string("foo2"), "testing");
+  DALI_TEST_EQUALS(2u, map.Count(), TEST_LOCATION);
+  value = map.Find("foo2");
+  DALI_TEST_CHECK(value);
+  DALI_TEST_EQUALS("testing", value->Get<std::string>(), TEST_LOCATION);
+
+  map.Insert(10, "DALi");
+  DALI_TEST_EQUALS(3u, map.Count(), TEST_LOCATION);
+  value = map.Find(10);
+  DALI_TEST_CHECK(value);
+  DALI_TEST_EQUALS("DALi", value->Get<std::string>(), TEST_LOCATION);
+
+  map.Insert(100, 9);
+  DALI_TEST_EQUALS(4u, map.Count(), TEST_LOCATION);
+  value = map.Find(100);
+  DALI_TEST_CHECK(value);
+  DALI_TEST_CHECK(value->Get<int>() == 9);
+
+  END_TEST;
+}
+
+int UtcDaliPropertyMapAddP(void)
+{
+  Property::Map map;
+  DALI_TEST_EQUALS(0u, map.Count(), TEST_LOCATION);
+  map.Add("foo", "bar");
+  DALI_TEST_EQUALS(1u, map.Count(), TEST_LOCATION);
+  Property::Value* value = map.Find("foo");
+  DALI_TEST_CHECK(value);
+  DALI_TEST_EQUALS("bar", value->Get<std::string>(), TEST_LOCATION);
+
+  map.Add(std::string("foo2"), "testing");
+  DALI_TEST_EQUALS(2u, map.Count(), TEST_LOCATION);
+  value = map.Find("foo2");
+  DALI_TEST_CHECK(value);
+  DALI_TEST_EQUALS("testing", value->Get<std::string>(), TEST_LOCATION);
+
+  map.Add(10, "DALi");
+  DALI_TEST_EQUALS(3u, map.Count(), TEST_LOCATION);
+  value = map.Find(10);
+  DALI_TEST_CHECK(value);
+  DALI_TEST_EQUALS("DALi", value->Get<std::string>(), TEST_LOCATION);
+
+  map.Add(100, 9);
+  DALI_TEST_EQUALS(4u, map.Count(), TEST_LOCATION);
+  value = map.Find(100);
+  DALI_TEST_CHECK(value);
+  DALI_TEST_CHECK(value->Get<int>() == 9);
+
+  END_TEST;
+}
+
+int UtcDaliPropertyMapAddChainP(void)
+{
+  Property::Map map;
+  DALI_TEST_EQUALS(0u, map.Count(), TEST_LOCATION);
+  map
+    .Add("foo", "bar")
+    .Add(std::string("foo2"), "testing")
+    .Add(10, "DALi")
+    .Add(100, 9);
+
+  DALI_TEST_EQUALS(4u, map.Count(), TEST_LOCATION);
+
+  Property::Value* value = map.Find("foo");
+  DALI_TEST_CHECK(value);
+  DALI_TEST_EQUALS("bar", value->Get<std::string>(), TEST_LOCATION);
+
+  value = map.Find("foo2");
+  DALI_TEST_CHECK(value);
+  DALI_TEST_EQUALS("testing", value->Get<std::string>(), TEST_LOCATION);
+
+  value = map.Find(10);
+  DALI_TEST_CHECK(value);
+  DALI_TEST_EQUALS("DALi", value->Get<std::string>(), TEST_LOCATION);
+
+  value = map.Find(100);
+  DALI_TEST_CHECK(value);
+  DALI_TEST_CHECK(value->Get<int>() == 9);
+
+  END_TEST;
+}
+
+int UtcDaliPropertyMapAnonymousAddChainP(void)
+{
+  class TestMap
+  {
+  public:
+    TestMap(Property::Map map)
+    : mMap(map)
+    {
+    }
+    Property::Map mMap;
+  };
+
+  TestMap mapTest(Property::Map().Add("foo", "bar").Add(std::string("foo2"), "testing").Add(10, "DALi").Add(100, 9));
+
+  Property::Value* value = mapTest.mMap.Find("foo");
+  DALI_TEST_CHECK(value);
+  DALI_TEST_EQUALS("bar", value->Get<std::string>(), TEST_LOCATION);
+
+  value = mapTest.mMap.Find("foo2");
+  DALI_TEST_CHECK(value);
+  DALI_TEST_EQUALS("testing", value->Get<std::string>(), TEST_LOCATION);
+
+  value = mapTest.mMap.Find(10);
+  DALI_TEST_CHECK(value);
+  DALI_TEST_EQUALS("DALi", value->Get<std::string>(), TEST_LOCATION);
+
+  value = mapTest.mMap.Find(100);
+  DALI_TEST_CHECK(value);
+  DALI_TEST_CHECK(value->Get<int>() == 9);
+
+  END_TEST;
+}
+
+int UtcDaliPropertyMapRemove(void)
+{
+  Property::Map map;
+  map["hello"] = 1;
+  map[10]      = "DALi";
+  map["world"] = 2;
+
+  DALI_TEST_CHECK(map.Count() == 3);
+  DALI_TEST_CHECK(!map.Remove(0));
+  DALI_TEST_CHECK(map.Count() == 3);
+  DALI_TEST_CHECK(!map.Remove("doesnotexist"));
+  DALI_TEST_CHECK(map.Count() == 3);
+  DALI_TEST_CHECK(map.Remove(10));
+  DALI_TEST_CHECK(map.Count() == 2);
+  DALI_TEST_CHECK(map.Remove("hello"));
+  DALI_TEST_CHECK(map.Count() == 1);
+  DALI_TEST_CHECK(map.Remove("world"));
+  DALI_TEST_CHECK(map.Count() == 0);
 
   END_TEST;
 }
@@ -277,68 +607,68 @@ int UtcDaliPropertyMapInsertP(void)
 int UtcDaliPropertyMapMerge(void)
 {
   Property::Map map;
-  map[ "hello" ] = 1;
-  map[ 10 ] = "DALi";
-  map[ "world" ] = 2;
+  map["hello"] = 1;
+  map[10]      = "DALi";
+  map["world"] = 2;
 
-  DALI_TEST_CHECK( map.Count() == 3 );
+  DALI_TEST_CHECK(map.Count() == 3);
 
   // Create another map with the same keys but different values
   Property::Map map2;
-  map2[ "hello" ] = 3;
-  map2[ "world" ] = 4;
-  map[ 10 ] = "3DEngine";
+  map2["hello"] = 3;
+  map2["world"] = 4;
+  map[10]       = "3DEngine";
 
   // Merge map2 into map1, count should still be 2, map values should be from map2
-  map.Merge( map2 );
-  DALI_TEST_CHECK( map.Count() == 3 );
-  DALI_TEST_CHECK( map[ "hello" ].Get< int >() == 3 );
-  DALI_TEST_CHECK( map[ "world"].Get< int >() == 4 );
-  DALI_TEST_EQUALS( "3DEngine", map[ 10 ].Get<std::string>(), TEST_LOCATION );
+  map.Merge(map2);
+  DALI_TEST_CHECK(map.Count() == 3);
+  DALI_TEST_CHECK(map["hello"].Get<int>() == 3);
+  DALI_TEST_CHECK(map["world"].Get<int>() == 4);
+  DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
 
   // Create another map with different keys
   Property::Map map3;
-  map3[ "foo" ] = 5;
-  map3[ 100 ] = 6;
+  map3["foo"] = 5;
+  map3[100]   = 6;
 
   // Merge map3 into map1, count should increase, existing values should match previous and new values should match map3
-  map.Merge( map3 );
-  DALI_TEST_CHECK( map.Count() == 5 );
-  DALI_TEST_CHECK( map[ "hello" ].Get< int >() == 3 );
-  DALI_TEST_CHECK( map[ "world"].Get< int >() == 4 );
-  DALI_TEST_CHECK( map[ "foo"].Get< int >() == 5 );
-  DALI_TEST_EQUALS( "3DEngine", map[ 10 ].Get<std::string>(), TEST_LOCATION );
-  DALI_TEST_CHECK( map[ 100].Get< int >() == 6 );
+  map.Merge(map3);
+  DALI_TEST_CHECK(map.Count() == 5);
+  DALI_TEST_CHECK(map["hello"].Get<int>() == 3);
+  DALI_TEST_CHECK(map["world"].Get<int>() == 4);
+  DALI_TEST_CHECK(map["foo"].Get<int>() == 5);
+  DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
+  DALI_TEST_CHECK(map[100].Get<int>() == 6);
 
   // Create an empty map and attempt to merge, should be successful, nothing should change
   Property::Map map4;
-  DALI_TEST_CHECK( map4.Empty() );
-  map.Merge( map4 );
-  DALI_TEST_CHECK( map4.Empty() );
-  DALI_TEST_CHECK( map.Count() == 5 );
-  DALI_TEST_CHECK( map[ "hello" ].Get< int >() == 3 );
-  DALI_TEST_CHECK( map[ "world"].Get< int >() == 4 );
-  DALI_TEST_CHECK( map[ "foo"].Get< int >() == 5 );
-  DALI_TEST_EQUALS( "3DEngine", map[ 10 ].Get<std::string>(), TEST_LOCATION );
-  DALI_TEST_CHECK( map[ 100 ].Get< int >() == 6 );
+  DALI_TEST_CHECK(map4.Empty());
+  map.Merge(map4);
+  DALI_TEST_CHECK(map4.Empty());
+  DALI_TEST_CHECK(map.Count() == 5);
+  DALI_TEST_CHECK(map["hello"].Get<int>() == 3);
+  DALI_TEST_CHECK(map["world"].Get<int>() == 4);
+  DALI_TEST_CHECK(map["foo"].Get<int>() == 5);
+  DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
+  DALI_TEST_CHECK(map[100].Get<int>() == 6);
 
   // Merge map into map4, map4 should be the same as map now.
-  map4.Merge( map );
-  DALI_TEST_CHECK( map4.Count() == 5 );
-  DALI_TEST_CHECK( map4[ "hello" ].Get< int >() == 3 );
-  DALI_TEST_CHECK( map4[ "world"].Get< int >() == 4 );
-  DALI_TEST_CHECK( map4[ "foo"].Get< int >() == 5 );
-  DALI_TEST_EQUALS( "3DEngine", map[ 10 ].Get<std::string>(), TEST_LOCATION );
-  DALI_TEST_CHECK( map4[ 100 ].Get< int >() == 6 );
+  map4.Merge(map);
+  DALI_TEST_CHECK(map4.Count() == 5);
+  DALI_TEST_CHECK(map4["hello"].Get<int>() == 3);
+  DALI_TEST_CHECK(map4["world"].Get<int>() == 4);
+  DALI_TEST_CHECK(map4["foo"].Get<int>() == 5);
+  DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
+  DALI_TEST_CHECK(map4[100].Get<int>() == 6);
 
   // Attempt to merge into itself, should be successful, nothing should change
-  map.Merge( map );
-  DALI_TEST_CHECK( map.Count() == 5 );
-  DALI_TEST_CHECK( map[ "hello" ].Get< int >() == 3 );
-  DALI_TEST_CHECK( map[ "world"].Get< int >() == 4 );
-  DALI_TEST_CHECK( map[ "foo"].Get< int >() == 5 );
-  DALI_TEST_EQUALS( "3DEngine", map[ 10 ].Get<std::string>(), TEST_LOCATION );
-  DALI_TEST_CHECK( map[ 100 ].Get< int >() == 6 );
+  map.Merge(map);
+  DALI_TEST_CHECK(map.Count() == 5);
+  DALI_TEST_CHECK(map["hello"].Get<int>() == 3);
+  DALI_TEST_CHECK(map["world"].Get<int>() == 4);
+  DALI_TEST_CHECK(map["foo"].Get<int>() == 5);
+  DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
+  DALI_TEST_CHECK(map[100].Get<int>() == 6);
 
   END_TEST;
 }
@@ -348,9 +678,9 @@ int UtcDaliPropertyMapOstream01(void)
   Property::Map map;
 
   map.Insert("duration", 5.0f);
-  map.Insert( 10, "DALi" );
+  map.Insert(10, "DALi");
   map.Insert("delay", 1.0f);
-  map.Insert( 100, 9 );
+  map.Insert(100, 9);
   map.Insert("value", 100);
 
   std::ostringstream oss;
@@ -359,21 +689,20 @@ int UtcDaliPropertyMapOstream01(void)
   tet_printf("Testing ouput of map: %s\n", oss.str().c_str());
 
   // string-value pairs first, then index-value pairs
-  DALI_TEST_EQUALS( oss.str().compare("Map(5) = {duration:5, delay:1, value:100, 10:DALi, 100:9}"), 0, TEST_LOCATION );
+  DALI_TEST_EQUALS(oss.str().compare("Map(5) = {duration:5, delay:1, value:100, 10:DALi, 100:9}"), 0, TEST_LOCATION);
 
   END_TEST;
 }
 
-
 int UtcDaliPropertyMapOstream02(void)
 {
   Property::Map map, map2;
 
   map2.Insert("duration", 5.0f);
   map2.Insert("delay", 1.0f);
-  map2.Insert( 10, "DALi" );
+  map2.Insert(10, "DALi");
   map.Insert("timePeriod", map2);
-  map.Insert( 100, 9 );
+  map.Insert(100, 9);
   map.Insert("value", 100);
 
   std::ostringstream oss;
@@ -382,7 +711,145 @@ int UtcDaliPropertyMapOstream02(void)
   tet_printf("Testing ouput of map: %s\n", oss.str().c_str());
 
   // string-value pairs first, then index-value pairs
-  DALI_TEST_EQUALS( oss.str().compare("Map(3) = {timePeriod:Map(3) = {duration:5, delay:1, 10:DALi}, value:100, 100:9}"), 0, TEST_LOCATION );
+  DALI_TEST_EQUALS(oss.str().compare("Map(3) = {timePeriod:Map(3) = {duration:5, delay:1, 10:DALi}, value:100, 100:9}"), 0, TEST_LOCATION);
+
+  END_TEST;
+}
+
+int UtcDaliPropertyKeyConstructorP(void)
+{
+  Property::Key key1("aKey");
+  DALI_TEST_EQUALS(key1.type, Property::Key::STRING, TEST_LOCATION);
+  DALI_TEST_EQUALS(key1.stringKey, "aKey", TEST_LOCATION);
+  DALI_TEST_EQUALS(key1.indexKey, Property::INVALID_INDEX, TEST_LOCATION);
+
+  Property::Key key2(Actor::Property::COLOR);
+  DALI_TEST_EQUALS(key2.type, Property::Key::INDEX, TEST_LOCATION);
+  DALI_TEST_EQUALS(key2.indexKey, (Dali::Property::Index)Actor::Property::COLOR, TEST_LOCATION);
+  END_TEST;
+}
+
+int UtcDaliPropertyKeyEqualityOperatorP(void)
+{
+  Property::Key key1("aKey");
+  Property::Key key2(113);
+
+  DALI_TEST_CHECK(key1 == "aKey");
+  DALI_TEST_CHECK(!(key1 == "notTheKey"));
+  DALI_TEST_CHECK(!(key1 == 1));
+
+  DALI_TEST_CHECK(key2 == 113);
+  DALI_TEST_CHECK(!(key2 == 0));
+  DALI_TEST_CHECK(!(key2 == "One hundred and thirteen"));
+
+  DALI_TEST_CHECK(!(key1 == key2));
+  DALI_TEST_CHECK(key1 != key2);
+
+  Property::Key key1B("aKey");
+  Property::Key key2B(113);
+
+  DALI_TEST_CHECK(key1 == key1B);
+  DALI_TEST_CHECK(key2 == key2B);
+
+  END_TEST;
+}
+
+int UtcDaliPropertyKeyInequalityOperatorP(void)
+{
+  Property::Key key1("aKey");
+  Property::Key key2(113);
+
+  DALI_TEST_CHECK(key1 != "notTheKey");
+  DALI_TEST_CHECK(key1 != 1);
+
+  DALI_TEST_CHECK(key2 != 0);
+  DALI_TEST_CHECK(key2 != "One hundred and thirteen");
+
+  DALI_TEST_CHECK(key1 != key2);
+
+  END_TEST;
+}
+
+int UtcDaliPropertyKeyOutputStream(void)
+{
+  Property::Key key1("aKey");
+  Property::Key key2(113);
+
+  std::ostringstream oss;
+  oss << key1;
+  DALI_TEST_EQUALS(oss.str(), "aKey", TEST_LOCATION);
+
+  std::ostringstream oss2;
+  oss2 << key2;
+  DALI_TEST_EQUALS(oss2.str(), "113", TEST_LOCATION);
+
+  END_TEST;
+}
+
+int UtcDaliPropertyMapInitializerListConstructor(void)
+{
+  auto map = Property::Map{
+    {"number mapped to string", 1},
+    {10, "string mapped to number"},
+    {"string mapped", "to string"},
+    {100, 3},
+  };
+
+  DALI_TEST_CHECK(!map.Empty());                   // Should not be empty
+  DALI_TEST_EQUALS(4, map.Count(), TEST_LOCATION); // Should have four items
+
+  DALI_TEST_EQUALS(1, map["number mapped to string"].Get<int>(), TEST_LOCATION);
+  DALI_TEST_EQUALS("string mapped to number", map[10].Get<std::string>(), TEST_LOCATION);
+  DALI_TEST_EQUALS("to string", map["string mapped"].Get<std::string>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(3, map[100].Get<int>(), TEST_LOCATION);
+
+  END_TEST;
+}
+
+int UtcDaliPropertyMapNestedInitializerListConstructor(void)
+{
+  auto map = Property::Map{
+    {1, 1},
+    {2, {{2, 2}}},
+    {3, {{3, {{3, 3}}}}}};
+
+  DALI_TEST_CHECK(!map.Empty());
+  DALI_TEST_EQUALS(3, map.Count(), TEST_LOCATION);
+
+  // Check first item
+  {
+    DALI_TEST_EQUALS(1, map[1].Get<int>(), TEST_LOCATION);
+  }
+
+  // Check second item
+  {
+    auto& value1 = map[2];
+    DALI_TEST_EQUALS(Property::MAP, value1.GetType(), TEST_LOCATION);
+
+    auto& map2 = *(value1.GetMap());
+    DALI_TEST_EQUALS(1, map2.Count(), TEST_LOCATION);
+
+    // check the value
+    DALI_TEST_EQUALS(2, map2[2].Get<int>(), TEST_LOCATION);
+  }
+
+  // Check the third item
+  {
+    auto& value1 = map[3];
+    DALI_TEST_EQUALS(Property::MAP, value1.GetType(), TEST_LOCATION);
+
+    auto& map2 = *(value1.GetMap());
+    DALI_TEST_EQUALS(1, map2.Count(), TEST_LOCATION);
+
+    auto& value2 = map2[3];
+    DALI_TEST_EQUALS(Property::MAP, value2.GetType(), TEST_LOCATION);
+
+    auto& map3 = *(value2.GetMap());
+    DALI_TEST_EQUALS(1, map3.Count(), TEST_LOCATION);
+
+    // check the value
+    DALI_TEST_EQUALS(3, map3[3].Get<int>(), TEST_LOCATION);
+  }
 
   END_TEST;
 }