X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali%2Futc-Dali-PropertyValue.cpp;h=a3f829275aa238f58cc631c350df4fef3f22828a;hb=24cf3ec005ffb58f751fe8f1ff41beb52128917d;hp=ea87d517c29f6b9c7ae6380fda77dca4116530f6;hpb=d43cb862080fe2f4271980d3d666865b6e616b0d;p=platform%2Fcore%2Fuifw%2Fdali-core.git

diff --git a/automated-tests/src/dali/utc-Dali-PropertyValue.cpp b/automated-tests/src/dali/utc-Dali-PropertyValue.cpp
index ea87d51..a3f8292 100644
--- a/automated-tests/src/dali/utc-Dali-PropertyValue.cpp
+++ b/automated-tests/src/dali/utc-Dali-PropertyValue.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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,1312 +15,1277 @@
  *
  */
 
-#include <iostream>
-#include <iomanip>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
 #include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iomanip>
+#include <iostream>
 
 using namespace Dali;
 
 namespace
 {
-
-void CheckTypeName(const Property::Type& type)
-{
-  switch(type)
-  {
-    case Property::NONE:
-    {
-      DALI_TEST_CHECK( "NONE" == std::string(PropertyTypes::GetName( type ) ) );
-      break;
-    }
-    case Property::BOOLEAN:
-    {
-      DALI_TEST_CHECK( "BOOLEAN" == std::string(PropertyTypes::GetName( type ) ) );
-      break;
-    }
-    case Property::FLOAT:
-    {
-      DALI_TEST_CHECK( "FLOAT" == std::string(PropertyTypes::GetName( type ) ) );
-      break;
-    }
-    case Property::INTEGER:
-    {
-      DALI_TEST_CHECK( "INTEGER" == std::string(PropertyTypes::GetName( type ) ) );
-      break;
-    }
-    case Property::UNSIGNED_INTEGER:
-    {
-      DALI_TEST_CHECK( "UNSIGNED_INTEGER" == std::string(PropertyTypes::GetName( type ) ) );
-      break;
-    }
-    case Property::VECTOR2:
-    {
-      DALI_TEST_CHECK( "VECTOR2" == std::string(PropertyTypes::GetName( type ) ) );
-      break;
-    }
-    case Property::VECTOR3:
-    {
-      DALI_TEST_CHECK( "VECTOR3" == std::string(PropertyTypes::GetName( type ) ) );
-      break;
-    }
-    case Property::VECTOR4:
-    {
-      DALI_TEST_CHECK( "VECTOR4" == std::string(PropertyTypes::GetName( type ) ) );
-      break;
-    }
-    case Property::MATRIX3:
-    {
-      DALI_TEST_CHECK( "MATRIX3" == std::string(PropertyTypes::GetName( type  ) ) );
-      break;
-    }
-    case Property::MATRIX:
-    {
-      DALI_TEST_CHECK( "MATRIX" == std::string(PropertyTypes::GetName( type ) ) );
-      break;
-    }
-    case Property::RECTANGLE:
-    {
-      DALI_TEST_CHECK( "RECTANGLE" == std::string(PropertyTypes::GetName( type ) ) );
-      break;
-    }
-    case Property::ROTATION:
-    {
-      DALI_TEST_CHECK( "ROTATION" == std::string(PropertyTypes::GetName( type ) ) );
-      break;
-    }
-    case Property::STRING:
-    {
-      DALI_TEST_CHECK( "STRING" == std::string(PropertyTypes::GetName( type ) ) );
-      break;
-    }
-    case Property::ARRAY:
-    {
-      DALI_TEST_CHECK( "ARRAY" == std::string(PropertyTypes::GetName( type ) ) );
-      break;
-    }
-    case Property::MAP:
-    {
-      DALI_TEST_CHECK( "MAP" == std::string(PropertyTypes::GetName( type ) ) );
-      break;
-    }
-    case Property::TYPE_COUNT:
-    {
-      DALI_TEST_CHECK( "NONE" == std::string(PropertyTypes::GetName( type ) ) );
-      break;
-    }
-  } // switch(type)
-
-} // CheckTypeName
-
-template <typename T>
-struct GetCheckP
-{
-  GetCheckP(T value)
-  {
-    Property::Value v(value);
-    DALI_TEST_CHECK( v.Get<T>() == value );
-  }
-};
-
-template <typename T>
+template<typename T>
 struct CheckCopyCtorP
 {
   CheckCopyCtorP(Property::Value value)
   {
-    Property::Value copy( value );
-    DALI_TEST_CHECK( value.Get<T>() == copy.Get<T>() );
+    Property::Value copy(value);
+    DALI_TEST_CHECK(value.Get<T>() == copy.Get<T>());
   }
 };
 
-template <>
-struct CheckCopyCtorP<AngleAxis>
+} // unnamed namespace
+
+void utc_dali_property_value_startup(void)
 {
-  CheckCopyCtorP(Property::Value value)
-  {
-    Property::Value copy( value );
-    AngleAxis a = value.Get<AngleAxis>();
-    AngleAxis b = copy.Get<AngleAxis>();
-    DALI_TEST_CHECK( a.angle == b.angle );
-    DALI_TEST_CHECK( a.axis == b.axis );
-  }
-};
+  test_return_value = TET_UNDEF;
+}
 
-template <>
-struct CheckCopyCtorP<Property::Array>
+void utc_dali_property_value_cleanup(void)
 {
-  CheckCopyCtorP(Property::Value value)
-  {
-    Property::Value copy( value );
-    Property::Array a = value.Get<Property::Array>();
-    Property::Array b = copy.Get<Property::Array>();
-    DALI_TEST_CHECK( a.size() == b.size() );
-  }
-};
+  test_return_value = TET_PASS;
+}
 
-template <>
-struct CheckCopyCtorP<Property::Map>
+int UtcDaliPropertyValueConstructorsNoneP(void)
 {
-  CheckCopyCtorP(Property::Value value)
-  {
-    Property::Value copy( value );
-    Property::Map a = value.Get<Property::Map>();
-    Property::Map b = copy.Get<Property::Map>();
-    DALI_TEST_CHECK( a.Count() == b.Count() );
-  }
-};
+  Property::Value value;
 
+  DALI_TEST_CHECK(value.GetType() == Property::NONE);
 
-template <typename T>
-struct GetCheckN
-{
-  GetCheckN()
-  {
-    Property::Value v;
-    try
-    {
-      T got = v.Get<T>();
-      (void)got;
-      tet_result(TET_FAIL);
-    }
-    catch( Dali::DaliException& e )
-    {
-      DALI_TEST_PRINT_ASSERT( e );
-      DALI_TEST_ASSERT( e, "Property type invalid", TEST_LOCATION );
-    }
-    catch( ... )
-    {
-      tet_printf("Assertion test failed - wrong Exception\n" );
-      tet_result(TET_FAIL);
-    }
-  }
-};
+  END_TEST;
+}
 
-template<>
-struct GetCheckN<Property::Array>
+int UtcDaliPropertyValueConstructorsNoneTypeP(void)
 {
-  GetCheckN()
-  {
-    Property::Value value;
-    try
-    {
-      Property::Array array = value.Get<Property::Array>();
-      tet_result(TET_FAIL);
-    }
-    catch( Dali::DaliException& e )
-    {
-      DALI_TEST_PRINT_ASSERT( e );
-      DALI_TEST_ASSERT( e, "Property type invalid", TEST_LOCATION );
-    }
-    catch( ... )
-    {
-      tet_printf("Assertion test failed - wrong Exception\n" );
-      tet_result(TET_FAIL);
-    }
-  }
-};
+  Property::Value value(Property::NONE);
+
+  DALI_TEST_CHECK(value.GetType() == Property::NONE);
 
-template<>
-struct GetCheckN<Property::Map>
+  END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsBoolP(void)
 {
-  GetCheckN()
-  {
-    Property::Value value;
-    try
-    {
-      Property::Map map = value.Get<Property::Map>();
-      tet_result(TET_FAIL);
-    }
-    catch( Dali::DaliException& e )
-    {
-      DALI_TEST_PRINT_ASSERT( e );
-      DALI_TEST_ASSERT( e, "Property type invalid", TEST_LOCATION );
-    }
-    catch( ... )
-    {
-      tet_printf("Assertion test failed - wrong Exception\n" );
-      tet_result(TET_FAIL);
-    }
-  }
-};
+  Property::Value value(true);
 
+  DALI_TEST_CHECK(value.GetType() == Property::BOOLEAN);
+  DALI_TEST_CHECK(value.Get<bool>() == true);
 
-} // unnamed namespace
+  END_TEST;
+}
 
-void utc_dali_property_value_startup(void)
+int UtcDaliPropertyValueConstructorBoolTypeP(void)
 {
-  test_return_value = TET_UNDEF;
+  Property::Value value(Property::BOOLEAN);
+
+  DALI_TEST_CHECK(value.GetType() == Property::BOOLEAN);
+  DALI_TEST_CHECK(value.Get<bool>() == false);
+
+  END_TEST;
 }
 
-void utc_dali_property_value_cleanup(void)
+int UtcDaliPropertyValueConstructorsFloatP(void)
 {
-  test_return_value = TET_PASS;
-}
+  Property::Value value(2.f);
 
+  DALI_TEST_CHECK(value.GetType() == Property::FLOAT);
+  DALI_TEST_CHECK(value.Get<float>() == 2.f);
 
-int UtcDaliPropertyValueConstructors01P(void)
+  END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsFloatTypeP(void)
 {
-  TestApplication application;
-  Property::Value value;
+  Property::Value value(Property::FLOAT);
 
-  DALI_TEST_CHECK( value.GetType() == Property::NONE );
+  DALI_TEST_CHECK(value.GetType() == Property::FLOAT);
+  DALI_TEST_CHECK(value.Get<float>() == 0.f);
 
   END_TEST;
 }
 
-int UtcDaliPropertyValueConstructors02P(void)
+int UtcDaliPropertyValueConstructorsIntP(void)
 {
-  TestApplication application;
-  Property::Value value(true);
+  Property::Value value(1);
 
-  DALI_TEST_CHECK( value.GetType() == Property::BOOLEAN );
-  DALI_TEST_CHECK( value.Get<bool>() == true );
+  DALI_TEST_CHECK(value.GetType() == Property::INTEGER);
+  DALI_TEST_CHECK(value.Get<int>() == 1);
 
   END_TEST;
 }
 
-int UtcDaliPropertyValueConstructors03P(void)
+int UtcDaliPropertyValueConstructorsIntTypeP(void)
 {
-  TestApplication application;
-  Property::Value value(2.f);
+  Property::Value value(Property::INTEGER);
 
-  DALI_TEST_CHECK( value.GetType() == Property::FLOAT );
-  DALI_TEST_CHECK( value.Get<float>() == 2.f );
+  DALI_TEST_CHECK(value.GetType() == Property::INTEGER);
+  DALI_TEST_CHECK(value.Get<int>() == 0);
 
   END_TEST;
 }
 
-int UtcDaliPropertyValueConstructors04P(void)
+int UtcDaliPropertyValueConstructorsVector2P(void)
 {
-  TestApplication application;
-  Property::Value value(1);
+  Vector2         v(1, 1);
+  Property::Value value(v);
 
-  DALI_TEST_CHECK( value.GetType() == Property::INTEGER );
-  DALI_TEST_CHECK( value.Get<int>() == 1 );
+  DALI_TEST_CHECK(value.GetType() == Property::VECTOR2);
+  DALI_TEST_CHECK(value.Get<Vector2>() == v);
 
   END_TEST;
 }
 
-int UtcDaliPropertyValueConstructors05P(void)
+int UtcDaliPropertyValueConstructorsVector2TypeP(void)
 {
-  TestApplication application;
-  Property::Value value(1u);
+  Property::Value value(Property::VECTOR2);
 
-  DALI_TEST_CHECK( value.GetType() == Property::UNSIGNED_INTEGER );
-  DALI_TEST_CHECK( value.Get<unsigned int>() == 1u );
+  DALI_TEST_CHECK(value.GetType() == Property::VECTOR2);
+  DALI_TEST_CHECK(value.Get<Vector2>() == Vector2::ZERO);
 
   END_TEST;
 }
 
-int UtcDaliPropertyValueConstructors06P(void)
+int UtcDaliPropertyValueConstructorsVector3P(void)
 {
-  TestApplication application;
-  Vector2 v(1,1);
+  Vector3         v(1.f, 2.f, 3.f);
   Property::Value value(v);
 
-  DALI_TEST_CHECK( value.GetType() == Property::VECTOR2 );
-  DALI_TEST_CHECK( value.Get<Vector2>() == v );
+  DALI_TEST_CHECK(value.GetType() == Property::VECTOR3);
+  DALI_TEST_CHECK(value.Get<Vector3>() == v);
 
   END_TEST;
 }
 
-int UtcDaliPropertyValueConstructors07P(void)
+int UtcDaliPropertyValueConstructorsVector3TypeP(void)
 {
-  TestApplication application;
-  Vector3 v(1.0,1.0,1.0);
-  Property::Value value(v);
+  Property::Value value(Property::VECTOR3);
 
-  DALI_TEST_CHECK( value.GetType() == Property::VECTOR3 );
-  DALI_TEST_CHECK( value.Get<Vector3>() == v );
+  DALI_TEST_CHECK(value.GetType() == Property::VECTOR3);
+  DALI_TEST_CHECK(value.Get<Vector3>() == Vector3());
 
   END_TEST;
 }
 
-int UtcDaliPropertyValueConstructors08P(void)
+int UtcDaliPropertyValueConstructorsVector4P(void)
 {
-  TestApplication application;
-  Matrix3 v(1.0,1.0,1.0, 1.0,1.0,1.0, 1.0,1.0,1.0);
+  Vector4         v(1.f, 1.f, 1.f, 0.9f);
   Property::Value value(v);
 
-  DALI_TEST_CHECK( value.GetType() == Property::MATRIX3 );
-  DALI_TEST_CHECK( value.Get<Matrix3>() == v );
+  DALI_TEST_CHECK(value.GetType() == Property::VECTOR4);
+  DALI_TEST_CHECK(value.Get<Vector4>() == v);
 
   END_TEST;
 }
 
-int UtcDaliPropertyValueConstructors09P(void)
+int UtcDaliPropertyValueConstructorsVector4TypeP(void)
 {
-  TestApplication application;
-  float a[] = {1.0,1.0,1.0,1.0, 1.0,1.0,1.0,1.0, 1.0,1.0,1.0,1.0, 1.0,1.0,1.0,1.0};
-  Matrix v(a);
-  Property::Value value(v);
+  Property::Value value(Property::VECTOR4);
 
-  DALI_TEST_CHECK( value.GetType() == Property::MATRIX );
-  DALI_TEST_CHECK( value.Get<Matrix>() == v );
+  DALI_TEST_CHECK(value.GetType() == Property::VECTOR4);
+  DALI_TEST_CHECK(value.Get<Vector4>() == Vector4());
 
   END_TEST;
 }
 
-int UtcDaliPropertyValueConstructors10P(void)
+int UtcDaliPropertyValueConstructorsMatrix3P(void)
 {
-  TestApplication application;
-  Rect<int> v(1.0,1.0,1.0,1.0);
+  Matrix3         v(1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0);
   Property::Value value(v);
 
-  DALI_TEST_CHECK( value.GetType() == Property::RECTANGLE );
-  DALI_TEST_CHECK( value.Get<Rect<int> >() == v );
+  DALI_TEST_CHECK(value.GetType() == Property::MATRIX3);
+  DALI_TEST_CHECK(value.Get<Matrix3>() == v);
 
   END_TEST;
 }
 
-int UtcDaliPropertyValueConstructors11P(void)
+int UtcDaliPropertyValueConstructorsMatrix3TypeP(void)
 {
-  TestApplication application;
-  AngleAxis v(Degree(1.0), Vector3(1.0,1.0,1.0));
-  Property::Value value(v);
+  Property::Value value(Property::MATRIX3);
 
-  DALI_TEST_CHECK( value.GetType() == Property::ROTATION );
-  AngleAxis got = value.Get<AngleAxis>();
-  DALI_TEST_CHECK( got.angle == v.angle );
-  DALI_TEST_CHECK( got.axis == v.axis );
+  DALI_TEST_CHECK(value.GetType() == Property::MATRIX3);
+  DALI_TEST_CHECK(value.Get<Matrix3>() == Matrix3());
 
   END_TEST;
 }
 
-int UtcDaliPropertyValueConstructors12P(void)
+int UtcDaliPropertyValueConstructorsMatrixP(void)
 {
-  TestApplication application;
-  Quaternion v( Vector4(1.0,1.0,1.0,1.0) );
+  float           a[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};
+  Matrix          v(a);
   Property::Value value(v);
 
-  DALI_TEST_CHECK( value.GetType() == Property::ROTATION );
-  DALI_TEST_CHECK( value.Get<Quaternion>() == v );
+  DALI_TEST_CHECK(value.GetType() == Property::MATRIX);
+  DALI_TEST_CHECK(value.Get<Matrix>() == v);
 
   END_TEST;
 }
 
-int UtcDaliPropertyValueConstructors13P(void)
+int UtcDaliPropertyValueConstructorsMatrixTypeP(void)
 {
-  TestApplication application;
-  std::string v("1");
-  Property::Value value(v);
+  Property::Value value(Property::MATRIX);
 
-  DALI_TEST_CHECK( value.GetType() == Property::STRING );
-  DALI_TEST_CHECK( value.Get<std::string>() == v );
+  DALI_TEST_CHECK(value.GetType() == Property::MATRIX);
+  DALI_TEST_CHECK(value.Get<Matrix>() == Matrix());
 
   END_TEST;
 }
 
-int UtcDaliPropertyValueConstructors14P(void)
+int UtcDaliPropertyValueConstructorsRectP(void)
 {
-  TestApplication application;
-
-  Property::Value value(Property::ARRAY);
-  value.AppendItem(Property::Value(1));
+  Rect<int>       v(1.0, 1.0, 1.0, 1.0);
+  Property::Value value(v);
 
-  DALI_TEST_CHECK( value.GetType() == Property::ARRAY );
-  DALI_TEST_CHECK( value.GetSize() == 1);
+  DALI_TEST_EQUALS(value.GetType(), Property::RECTANGLE, TEST_LOCATION);
+  DALI_TEST_CHECK(value.Get<Rect<int> >() == v);
 
   END_TEST;
 }
 
-int UtcDaliPropertyValueConstructors15P(void)
+int UtcDaliPropertyValueConstructorsRectTypeP(void)
 {
-  TestApplication application;
+  Property::Value value(Property::RECTANGLE);
 
-  Property::Value value(Property::MAP);
-  value.SetValue("1", Property::Value(1));
-
-  DALI_TEST_CHECK( value.GetType() == Property::MAP );
-  DALI_TEST_CHECK( value.GetSize() == 1);
+  DALI_TEST_CHECK(value.GetType() == Property::RECTANGLE);
+  DALI_TEST_CHECK(value.Get<Rect<int> >() == Rect<int>(0, 0, 0, 0));
 
   END_TEST;
 }
 
-int UtcDaliPropertyValueCopyConstructor01P(void)
+int UtcDaliPropertyValueConstructorsAngleAxisP(void)
 {
-  TestApplication application;
-  CheckCopyCtorP<float> check(1.f);
+  AngleAxis       input(Dali::ANGLE_90, Vector3::XAXIS);
+  Property::Value value(input);
+
+  DALI_TEST_CHECK(value.GetType() == Property::ROTATION);
+  AngleAxis result = value.Get<AngleAxis>();
+  DALI_TEST_EQUALS(result.angle, input.angle, TEST_LOCATION);
+  DALI_TEST_EQUALS(result.axis, input.axis, TEST_LOCATION);
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueCopyConstructor02P(void)
+int UtcDaliPropertyValueConstructorsQuaternionP(void)
 {
-  TestApplication application;
-  CheckCopyCtorP<bool> check(true);
+  Quaternion      v(Radian(Math::PI), Vector3::ZAXIS);
+  Property::Value value(v);
+
+  DALI_TEST_CHECK(value.GetType() == Property::ROTATION);
+  DALI_TEST_EQUALS(v, value.Get<Quaternion>(), 0.001, TEST_LOCATION);
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueCopyConstructor03P(void)
+int UtcDaliPropertyValueConstructorsRotationTypeP(void)
 {
-  TestApplication application;
-  CheckCopyCtorP<float> check(1.f);
+  Property::Value value(Property::ROTATION);
+
+  DALI_TEST_CHECK(value.GetType() == Property::ROTATION);
+  AngleAxis result = value.Get<AngleAxis>();
+  DALI_TEST_EQUALS(result.angle, Radian(0.f), TEST_LOCATION);
+  DALI_TEST_EQUALS(result.axis, Vector3::ZERO, TEST_LOCATION); // identity quaternion returns a zero angle-axis
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueCopyConstructor04P(void)
+int UtcDaliPropertyValueConstructorsStringP(void)
 {
-  TestApplication application;
-  CheckCopyCtorP<int> check(1);
+  std::string     v("1");
+  Property::Value value(v);
+
+  DALI_TEST_CHECK(value.GetType() == Property::STRING);
+  DALI_TEST_CHECK(value.Get<std::string>() == v);
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueCopyConstructor05P(void)
+int UtcDaliPropertyValueConstructorsStringTypeP(void)
 {
-  TestApplication application;
-  CheckCopyCtorP<unsigned int> check(1u);
+  Property::Value value(Property::STRING);
+
+  DALI_TEST_CHECK(value.GetType() == Property::STRING);
+  DALI_TEST_CHECK(value.Get<std::string>() == std::string());
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueCopyConstructor06P(void)
+int UtcDaliPropertyValueConstructorsArrayP(void)
 {
-  TestApplication application;
-  CheckCopyCtorP<Vector2> check( Vector2(1,1) );
+  Property::Array foo;
+  Property::Value value(foo);
+
+  DALI_TEST_CHECK(value.GetType() == Property::ARRAY);
+  DALI_TEST_CHECK(value.Get<Property::Array>().Count() == 0);
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueCopyConstructor07P(void)
+int UtcDaliPropertyValueConstructorsArray2P(void)
 {
-  TestApplication application;
-  CheckCopyCtorP<Vector3> check( Vector3(1.0,1.0,1.0) );
+  Property::Array foo;
+  foo.PushBack(Property::Value());
+  Property::Value value(foo);
+
+  DALI_TEST_CHECK(value.GetType() == Property::ARRAY);
+  DALI_TEST_CHECK(value.Get<Property::Array>().Count() == 1);
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueCopyConstructor08P(void)
+int UtcDaliPropertyValueConstructorsArrayTypeP(void)
 {
-  TestApplication application;
-  CheckCopyCtorP<Matrix3> check( Matrix3::IDENTITY );
+  Property::Value value(Property::ARRAY);
+
+  DALI_TEST_CHECK(value.GetType() == Property::ARRAY);
+  DALI_TEST_CHECK(value.Get<Property::Array>().Count() == 0);
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueCopyConstructor09P(void)
+int UtcDaliPropertyValueConstructorsMapP(void)
 {
-  TestApplication application;
-  CheckCopyCtorP<Matrix> check(Matrix::IDENTITY);
+  Property::Map   map;
+  Property::Value value(map);
+
+  DALI_TEST_CHECK(value.GetType() == Property::MAP);
+  DALI_TEST_CHECK(value.Get<Property::Map>().Count() == 0);
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueCopyConstructor10P(void)
+int UtcDaliPropertyValueConstructorsMap2P(void)
 {
-  TestApplication application;
-  CheckCopyCtorP<Rect<int> > check( Rect<int>(1.0,1.0,1.0,1.0) );
+  Property::Map map;
+  map.Insert("", "");
+  Property::Value value(map);
+
+  DALI_TEST_CHECK(value.GetType() == Property::MAP);
+  DALI_TEST_CHECK(value.Get<Property::Map>().Count() == 1);
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueCopyConstructor11P(void)
+int UtcDaliPropertyValueConstructorsMapTypeP(void)
 {
-  TestApplication application;
-  CheckCopyCtorP<AngleAxis> check( AngleAxis(Degree(1.0), Vector3(1.0,1.0,1.0)) );
+  Property::Value value(Property::MAP);
+
+  DALI_TEST_CHECK(value.GetType() == Property::MAP);
+  DALI_TEST_CHECK(value.Get<Property::Map>().Count() == 0);
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueCopyConstructor12P(void)
+int UtcDaliPropertyValueConstructorsExtentsTypeP(void)
 {
-  TestApplication application;
-  CheckCopyCtorP<Quaternion> check( Quaternion( Vector4(1.0, 1.0, 1.0, 1.0) ) );
+  Property::Value value(Property::EXTENTS);
+
+  DALI_TEST_CHECK(value.GetType() == Property::EXTENTS);
+  DALI_TEST_CHECK(value.Get<Extents>() == Extents(0u, 0u, 0u, 0u));
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueCopyConstructor13P(void)
+int UtcDaliPropertyValueConstructorsExtentsType2P(void)
 {
-  TestApplication application;
-  CheckCopyCtorP<std::string> check( std::string("1") );
+  Property::Value value(Property::VECTOR4);
+
+  DALI_TEST_CHECK(value.GetType() == Property::VECTOR4);
+  DALI_TEST_CHECK(value.Get<Extents>() == Extents(0u, 0u, 0u, 0u));
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueCopyConstructor14P(void)
+int UtcDaliPropertyValueCopyConstructorP(void)
 {
-  TestApplication application;
-  Property::Array value;
-  value.push_back(Property::Value(1));
-  CheckCopyCtorP<Property::Array> check(value);
+  Property::Value value;
+  Property::Value value2(value);
+  DALI_TEST_EQUALS(value.GetType(), value2.GetType(), TEST_LOCATION);
+  DALI_TEST_EQUALS(value.GetMap(), value2.GetMap(), TEST_LOCATION);
+  DALI_TEST_EQUALS(value.GetArray(), value2.GetArray(), TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueCopyConstructor15P(void)
+int UtcDaliPropertyValueCopyConstructorBoolP(void)
 {
-  TestApplication application;
-  Property::Map value;
-  value["1"] = Property::Value(1);
-  CheckCopyCtorP<Property::Map> check(value);
+  CheckCopyCtorP<bool> check(true);
   END_TEST;
 }
 
+int UtcDaliPropertyValueCopyConstructorFloatP(void)
+{
+  CheckCopyCtorP<float> check(1.f);
+  END_TEST;
+}
 
-int UtcDaliPropertyValueAssignmentOperator01P(void)
+int UtcDaliPropertyValueCopyConstructorIntP(void)
 {
-  TestApplication application;
-  Property::Value value;
-  value = Property::Value(true);
-  {
-    Property::Value copy( false );
-    copy = value;
-    DALI_TEST_CHECK( true == copy.Get<bool>() );
-  }
+  CheckCopyCtorP<int> check(1);
   END_TEST;
 }
 
+int UtcDaliPropertyValueCopyConstructoVector2P(void)
+{
+  CheckCopyCtorP<Vector2> check(Vector2(2, 1));
+  END_TEST;
+}
 
-int UtcDaliPropertyValueAssignmentOperator02P(void)
+int UtcDaliPropertyValueCopyConstructorVector3P(void)
 {
-  TestApplication application;
-  Property::Value value;
-  value = Property::Value(10.f);
-  {
-    Property::Value copy(false);
-    copy = value;
-    DALI_TEST_CHECK( Dali::Equals(10.f, copy.Get<float>() ) );
-  }
+  CheckCopyCtorP<Vector3> check(Vector3(3.f, 2.f, 1.f));
   END_TEST;
 }
 
-int UtcDaliPropertyValueAssignmentOperator03P(void)
+int UtcDaliPropertyValueCopyConstructorVector4P(void)
 {
-  TestApplication application;
-  Property::Value value;
-  value = Property::Value(10);
-  {
-    Property::Value copy(false);
-    copy = value;
-    DALI_TEST_CHECK( 10 == copy.Get<int>() );
-  }
+  CheckCopyCtorP<Vector3> check(Vector4(4.f, 3.f, 2.f, 1.f));
   END_TEST;
 }
 
-int UtcDaliPropertyValueAssignmentOperator04P(void)
+int UtcDaliPropertyValueCopyConstructorMatrix3P(void)
 {
-  TestApplication application;
-  Property::Value value;
-  value = Property::Value(10U);
-  {
-    Property::Value copy(false);
-    copy = value;
-    DALI_TEST_CHECK( 10 == copy.Get< unsigned int>() );
-  }
+  CheckCopyCtorP<Matrix3> check(Matrix3::IDENTITY);
   END_TEST;
 }
 
-int UtcDaliPropertyValueAssignmentOperator05P(void)
+int UtcDaliPropertyValueCopyConstructorMatrixP(void)
 {
-  TestApplication application;
-  Property::Value value;
-  value = Property::Value( Vector2(1,1) );
-  {
-    Property::Value copy(false);
-    copy = value;
-    DALI_TEST_CHECK( Vector2(1,1) == copy.Get<Vector2>() );
-  }
+  CheckCopyCtorP<Matrix> check(Matrix::IDENTITY);
   END_TEST;
 }
 
-int UtcDaliPropertyValueAssignmentOperator06P(void)
+int UtcDaliPropertyValueCopyConstructorRectP(void)
 {
-  TestApplication application;
-  Property::Value value;
-  value = Property::Value( Vector3(1.f,1.f,1.f) );
-  {
-    Property::Value copy(false);
-    copy = value;
-    DALI_TEST_CHECK( Vector3(1.f,1.f,1.f) == copy.Get<Vector3>() );
-  }
+  CheckCopyCtorP<Rect<int> > check(Rect<int>(1.0, 1.0, 1.0, 1.0));
   END_TEST;
 }
 
-int UtcDaliPropertyValueAssignmentOperator07P(void)
+int UtcDaliPropertyValueCopyConstructorAngleAxisP(void)
 {
-  TestApplication application;
-  Property::Value value;
-  value = Property::Value( Vector4(1,1,1,1) );
-  {
-    Property::Value copy(false);
-    copy = value;
-    DALI_TEST_CHECK( Vector4(1,1,1,1) == copy.Get<Vector4>() );
-  }
+  CheckCopyCtorP<AngleAxis> check(AngleAxis(Degree(1.0), Vector3(1.0, 1.0, 1.0)));
   END_TEST;
 }
 
-int UtcDaliPropertyValueAssignmentOperator08P(void)
+int UtcDaliPropertyValueCopyConstructorQuaternionP(void)
 {
-  TestApplication application;
-  Property::Value value;
-  value = Property::Value( Matrix3::IDENTITY );
-  {
-    Property::Value copy(false);
-    copy = value;
-    DALI_TEST_CHECK( Matrix3::IDENTITY == copy.Get<Matrix3>() );
-  }
+  CheckCopyCtorP<Quaternion> check(Quaternion(Vector4(1.0, 1.0, 1.0, 1.0)));
   END_TEST;
 }
 
-int UtcDaliPropertyValueAssignmentOperator09P(void)
+int UtcDaliPropertyValueCopyConstructorStringP(void)
 {
-  TestApplication application;
-  Property::Value value;
-  value = Property::Value( Matrix::IDENTITY );
-  {
-    Property::Value copy(false);
-    copy = value;
-    DALI_TEST_CHECK( Matrix::IDENTITY == copy.Get<Matrix>()  );
-  }
+  CheckCopyCtorP<std::string> check(std::string("1"));
   END_TEST;
 }
 
-int UtcDaliPropertyValueAssignmentOperator10P(void)
+int UtcDaliPropertyValueCopyAssignStringDifferentTypeP(void)
 {
-  TestApplication application;
-  Property::Value value;
-  typedef Dali::Rect<int> Rectangle;
+  Property::Value value1{Vector4(3.f, 2.f, 1.f, 2.0f)};
+  Property::Value value2{"very very long string ..................."};
+  value2 = value1;
 
-  value = Property::Value( Rectangle(1,1,1,1) );
-  {
-    Property::Value copy(false);
-    copy = value;
-    Rectangle copyRect;
-    copy.Get(copyRect);
-    DALI_TEST_CHECK(  Rectangle(1,1,1,1) == copyRect);
-  }
+  Vector4 vec1, vec2;
+  value1.Get(vec1);
+  value2.Get(vec2);
+  DALI_TEST_EQUALS(value1.GetType(), value2.GetType(), TEST_LOCATION);
+  DALI_TEST_EQUALS(vec1, vec2, TEST_LOCATION);
+
+  Property::Value value3{Vector4(3.f, 2.f, 1.f, 2.0f)};
+  Property::Value value4{"very very long string ..................."};
+
+  value3 = value4;
+
+  DALI_TEST_EQUALS(value3.GetType(), value4.GetType(), TEST_LOCATION);
+  DALI_TEST_EQUALS(value3.Get<std::string>(), "very very long string ...................", TEST_LOCATION);
+  DALI_TEST_EQUALS(value3.Get<std::string>(), value4.Get<std::string>(), TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueAssignmentOperator11P(void)
+int UtcDaliPropertyValueCopyConstructorArrayP(void)
 {
-  TestApplication application;
-  Property::Value value;
-  value = Property::Value( Quaternion(1,1,1,1) );
-  {
-    Property::Value copy(false);
-    copy = value;
-    DALI_TEST_CHECK( Quaternion(1,1,1,1) == copy.Get<Quaternion>() );
-  }
+  Property::Value  value1(Property::ARRAY);
+  Property::Array* array = value1.GetArray();
+  array->PushBack(Property::Value(1));
+
+  Property::Value value2(value1);
+  DALI_TEST_EQUALS(value1.GetType(), value2.GetType(), TEST_LOCATION);
+  DALI_TEST_EQUALS(value1.GetArray()->Count(), value2.GetArray()->Count(), TEST_LOCATION);
+
   END_TEST;
 }
 
-
-int UtcDaliPropertyValueAssignmentOperator12P(void)
+int UtcDaliPropertyValueCopyConstructorMapP(void)
 {
-  TestApplication application;
-  Property::Value value;
-  value = Property::Value( AngleAxis( Radian(Math::PI_2), Vector3::XAXIS  ));
-  {
-    Property::Value copy(false);
-    copy = value;
-    DALI_TEST_CHECK( value.Get<AngleAxis>().axis == copy.Get<AngleAxis>().axis );
-    DALI_TEST_CHECK( value.Get<AngleAxis>().angle == copy.Get<AngleAxis>().angle );
-  }
+  Property::Value value1(Property::MAP);
+  Property::Map*  map = value1.GetMap();
+  (*map)["1"]         = Property::Value(1);
+
+  Property::Value value2(value1);
+  DALI_TEST_EQUALS(value1.GetType(), value2.GetType(), TEST_LOCATION);
+  DALI_TEST_EQUALS(value1.GetMap()->Count(), value2.GetMap()->Count(), TEST_LOCATION);
+  DALI_TEST_EQUALS(value1.GetMap()->GetKey(0), value2.GetMap()->GetKey(0), TEST_LOCATION);
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueAssignmentOperator13P(void)
+int UtcDaliPropertyValueMoveConstructor(void)
 {
-  TestApplication application;
-  Property::Value value;
-  value = Property::Value("yes");
-  {
-    Property::Value copy(false);
-    copy = value;
-    DALI_TEST_CHECK( "yes" == copy.Get<std::string>() );
-  }
+  Property::Value value1(Vector4::ONE);
+  DALI_TEST_EQUALS(Property::VECTOR4, value1.GetType(), TEST_LOCATION);
+
+  Vector4 valueVector;
+  DALI_TEST_EQUALS(true, value1.Get(valueVector), TEST_LOCATION); // Able to convert
+  DALI_TEST_EQUALS(valueVector, Vector4::ONE, TEST_LOCATION);
+
+  Property::Value value2(std::move(value1));
+  DALI_TEST_EQUALS(Property::NONE, value1.GetType(), TEST_LOCATION);
+  DALI_TEST_EQUALS(false, value1.Get(valueVector), TEST_LOCATION); // Unable to convert, but no crash either
+  DALI_TEST_EQUALS(Property::VECTOR4, value2.GetType(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value2.Get(valueVector), TEST_LOCATION); // Able to convert
+  DALI_TEST_EQUALS(valueVector, Vector4::ONE, TEST_LOCATION);
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueAssignmentOperator14P(void)
+int UtcDaliPropertyValueMoveConstructorArray(void)
 {
-  TestApplication application;
-  Property::Value value;
   Property::Array array;
-  value = Property::Value(Property::ARRAY);
-  value.AppendItem(10);
-  {
-    Property::Value copy(false);
-    copy = value;
-    copy.Get( array );
-    int getItem = 0;
-    array[0].Get( getItem );
-    DALI_TEST_CHECK( getItem == 10 );
-  }
+  array.PushBack(1);
+  array.PushBack(2);
+  array.PushBack(3);
+  DALI_TEST_EQUALS(3u, array.Size(), TEST_LOCATION);
+
+  Property::Value value(std::move(array));
+  DALI_TEST_ASSERTION(array.Size(), "Cannot use an object previously used as an r-value"); // Our local variable should become invalid
+
+  Property::Array* arrayPtr = value.GetArray();
+  DALI_TEST_CHECK(arrayPtr);
+  DALI_TEST_EQUALS(3u, arrayPtr->Size(), TEST_LOCATION);
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueAssignmentOperator15P(void)
+int UtcDaliPropertyValueMoveConstructorMap(void)
 {
-  TestApplication application;
-  Property::Value value;
   Property::Map map;
-  value = Property::Value(Property::MAP);
-  value.SetValue("key", "value");
-  {
-    Property::Value copy(false);
-    copy = value;
-    copy.Get( map );
-    DALI_TEST_CHECK( map.GetKey(0) == "key" );
-  }
+  map[1] = 1;
+  map[2] = 2;
+  map[3] = 3;
+  DALI_TEST_EQUALS(3u, map.Count(), TEST_LOCATION);
+
+  Property::Value value(std::move(map));
+  DALI_TEST_ASSERTION(map.Count(), "Cannot use an object previously used as an r-value"); // Our local variable should become invalid
+
+  Property::Map* mapPtr = value.GetMap();
+  DALI_TEST_CHECK(mapPtr);
+  DALI_TEST_EQUALS(3u, mapPtr->Count(), TEST_LOCATION);
+
   END_TEST;
 }
 
-
-int UtcDaliPropertyValueGetTypeP(void)
+int UtcDaliPropertyValueAssignmentSelfP(void)
 {
-  TestApplication application;
+  Property::Value  value;
+  Property::Value* self = &value;
+  value                 = *self;
+  DALI_TEST_EQUALS(value.GetType(), Property::NONE, TEST_LOCATION);
+  DALI_TEST_CHECK(value.GetMap() == NULL);
+  DALI_TEST_CHECK(value.GetArray() == NULL);
+  END_TEST;
+}
 
+int UtcDaliPropertyValueAssignmentOperatorNoneP(void)
+{
   Property::Value value;
-  DALI_TEST_CHECK( value.GetType() == Property::NONE );
+  value = Property::Value(); // type match
+  DALI_TEST_EQUALS(value.GetType(), Property::NONE, TEST_LOCATION);
+  Property::Value copy(false);
+  copy = value; // type mismatch
+  DALI_TEST_EQUALS(value.GetType(), Property::NONE, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet01P(void)
+int UtcDaliPropertyValueAssignmentOperatorBoolP(void)
 {
-  TestApplication application;
-  Property::Value value(true);
-  DALI_TEST_CHECK( value.Get<bool>() == true );
-  value = Property::Value(1.f);
-  DALI_TEST_CHECK( value.Get<float>() == 1.f );
+  Property::Value value;
+  value = Property::Value(true); // type mismatch
+  DALI_TEST_CHECK(true == value.Get<bool>());
+  Property::Value copy(false);
+  copy = value; // type match
+  DALI_TEST_CHECK(true == copy.Get<bool>());
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet01N(void)
+int UtcDaliPropertyValueAssignmentOperatorIntP(void)
 {
-  TestApplication application;
-
   Property::Value value;
-  try
-  {
-    value.Get<bool>() == true;
-    tet_result(TET_FAIL);
-  }
-  catch( Dali::DaliException& e )
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT( e, "Property type invalid", TEST_LOCATION );
-  }
-  catch( ... )
-  {
-    tet_printf("Assertion test failed - wrong Exception\n" );
-    tet_result(TET_FAIL);
-  }
-
+  value = Property::Value(10); // type mismatch
+  DALI_TEST_CHECK(10 == value.Get<int>());
+  Property::Value copy(99);
+  copy = value; // type match
+  DALI_TEST_CHECK(10 == copy.Get<int>());
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet02P(void)
+int UtcDaliPropertyValueAssignmentOperatorFloatP(void)
 {
-  TestApplication application;
-  Property::Value value(true);
-  DALI_TEST_CHECK( value.Get<bool>() == true );
+  Property::Value value;
+  value = Property::Value(10.f); // mismatch
+  DALI_TEST_CHECK(Dali::Equals(10.f, value.Get<float>()));
+  Property::Value copy(321.f);
+  copy = value; // match
+  DALI_TEST_CHECK(Dali::Equals(10.f, copy.Get<float>()));
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet02N(void)
+int UtcDaliPropertyValueAssignmentOperatorVector2P(void)
 {
-  TestApplication application;
-  GetCheckN<bool> check;
+  Property::Value value;
+  value = Property::Value(Vector2(1, 2)); // mismatch
+  DALI_TEST_CHECK(Vector2(1, 2) == value.Get<Vector2>());
+  Property::Value copy(Property::VECTOR2);
+  copy = value; // match
+  DALI_TEST_CHECK(Vector2(1, 2) == copy.Get<Vector2>());
   END_TEST;
 }
 
-
-int UtcDaliPropertyValueGet03P(void)
+int UtcDaliPropertyValueAssignmentOperatorVector3P(void)
 {
-  TestApplication application;
-  GetCheckP<float> check(1.f);
+  Property::Value value;
+  value = Property::Value(Vector3(1.f, 2.f, 3.f)); // mismatch
+  DALI_TEST_CHECK(Vector3(1.f, 2.f, 3.f) == value.Get<Vector3>());
+  Property::Value copy(Property::VECTOR3);
+  copy = value; // match
+  DALI_TEST_CHECK(Vector3(1.f, 2.f, 3.f) == copy.Get<Vector3>());
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet03N(void)
+int UtcDaliPropertyValueAssignmentOperatorVector4P(void)
 {
-  TestApplication application;
-  GetCheckN<float> check;
+  Property::Value value;
+  value = Property::Value(Vector4(1, 2, 3, 4)); // mismatch
+  DALI_TEST_CHECK(Vector4(1, 2, 3, 4) == value.Get<Vector4>());
+  Property::Value copy(Vector4(0, 1, 2, 3));
+  copy = value; // match
+  DALI_TEST_CHECK(Vector4(1, 2, 3, 4) == copy.Get<Vector4>());
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet04P(void)
+int UtcDaliPropertyValueAssignmentOperatorMatrix3P(void)
 {
-  TestApplication application;
-  GetCheckP<int> check(1);
+  Property::Value value;
+  value = Property::Value(Matrix3::IDENTITY); // mismatch
+  DALI_TEST_CHECK(Matrix3::IDENTITY == value.Get<Matrix3>());
+  Property::Value copy(Property::MATRIX3);
+  copy = value; // match
+  DALI_TEST_CHECK(Matrix3::IDENTITY == copy.Get<Matrix3>());
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet04N(void)
+int UtcDaliPropertyValueAssignmentOperatorMatrixP(void)
 {
-  TestApplication application;
-  GetCheckN<int> check;
+  Property::Value value;
+  value = Property::Value(Matrix::IDENTITY); // mismatch
+  DALI_TEST_CHECK(Matrix::IDENTITY == value.Get<Matrix>());
+  Matrix          foo;
+  Property::Value copy(foo);
+  copy = value; // match
+  DALI_TEST_CHECK(Matrix::IDENTITY == copy.Get<Matrix>());
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet05P(void)
+int UtcDaliPropertyValueAssignmentOperatorRectP(void)
 {
-  TestApplication application;
-  GetCheckP<unsigned int> check(1u);
+  Property::Value         value;
+  typedef Dali::Rect<int> Rectangle;
+  value = Property::Value(Rectangle(4, 3, 2, 1)); // mismatch
+  DALI_TEST_CHECK(Rectangle(4, 3, 2, 1) == value.Get<Rectangle>());
+  Property::Value copy(Property::RECTANGLE);
+  copy = value; // match
+  Rectangle copyRect;
+  copy.Get(copyRect);
+  DALI_TEST_CHECK(Rectangle(4, 3, 2, 1) == copyRect);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet05N(void)
+int UtcDaliPropertyValueAssignmentOperatorQuaternionP(void)
 {
-  TestApplication application;
-  GetCheckN<unsigned int> check;
+  Property::Value value;
+  Quaternion      result(Radian(Math::PI_2), Vector3::YAXIS);
+  value = Property::Value(result);
+
+  DALI_TEST_EQUALS(value.Get<Quaternion>(), result, 0.001, TEST_LOCATION);
+
+  Property::Value copy(Property::ROTATION);
+  copy = value; // match
+  DALI_TEST_EQUALS(copy.Get<Quaternion>(), result, 0.001, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet06P(void)
+int UtcDaliPropertyValueAssignmentOperatorAngleAxisP(void)
 {
-  TestApplication application;
-  GetCheckP<Rect<int> > check(Rect<int>(1,1,1,1));
+  Property::Value value;
+  value = Property::Value(AngleAxis(Radian(Math::PI_2), Vector3::XAXIS)); // mismatch
+  DALI_TEST_EQUALS(value.Get<AngleAxis>().axis, Vector3::XAXIS, TEST_LOCATION);
+  DALI_TEST_EQUALS(value.Get<AngleAxis>().angle, Radian(Math::PI_2), TEST_LOCATION);
+  Property::Value copy(Property::ROTATION);
+  copy = value; // match
+  DALI_TEST_EQUALS(value.Get<AngleAxis>().axis, copy.Get<AngleAxis>().axis, TEST_LOCATION);
+  DALI_TEST_EQUALS(value.Get<AngleAxis>().angle, copy.Get<AngleAxis>().angle, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet06N(void)
+int UtcDaliPropertyValueAssignmentOperatorStringP(void)
 {
-  TestApplication application;
-  GetCheckN<Rect<int> > check;
+  Property::Value value;
+  value = Property::Value("yes"); // mismatch
+  DALI_TEST_CHECK("yes" == value.Get<std::string>());
+  Property::Value copy("no");
+  copy = value; // match
+  DALI_TEST_CHECK("yes" == copy.Get<std::string>());
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet07P(void)
+int UtcDaliPropertyValueAssignmentOperatorArrayP(void)
 {
-  TestApplication application;
-  GetCheckP<Vector2> check(Vector2(1.0,1.0));
+  Property::Value value;
+  value = Property::Value(Property::ARRAY); // mismatch
+  value.GetArray()->PushBack(10);
+  DALI_TEST_CHECK(value.GetArray());
+  Property::Value copy(Property::ARRAY);
+  copy = value; // match
+  Property::Array array;
+  copy.Get(array);
+  int getItem = 0;
+  array[0].Get(getItem);
+  DALI_TEST_CHECK(getItem == 10);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet07N(void)
+int UtcDaliPropertyValueAssignmentOperatorMapP(void)
 {
-  TestApplication application;
-  GetCheckN<Vector2> check;
+  Property::Value value;
+  value = Property::Value(Property::MAP); // mismatch
+  value.GetMap()->Insert("key", "value");
+  Property::Value copy(Property::MAP); // match
+  copy = value;
+  Property::Map map;
+  copy.Get(map);
+  DALI_TEST_CHECK(map.GetKey(0) == "key");
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet8P(void)
+int UtcDaliPropertyValueAssignmentOperatorExtentsP(void)
 {
-  TestApplication application;
-  GetCheckP<Vector3> check(Vector3(1.0,1.0,1.0));
+  Property::Value value;
+  value = Property::Value(Extents(4, 3, 2, 1)); // mismatch
+  DALI_TEST_CHECK(Extents(4, 3, 2, 1) == value.Get<Extents>());
+  Property::Value copy(Property::EXTENTS);
+  copy = value; // match
+  Extents copyExtents;
+  copy.Get(copyExtents);
+  DALI_TEST_CHECK(Extents(4, 3, 2, 1) == copyExtents);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet08N(void)
+int UtcDaliPropertyValueMoveAssignmentOperator(void)
 {
-  TestApplication application;
-  GetCheckN<Vector3> check;
+  Property::Value value1(Vector4::ONE);
+  DALI_TEST_EQUALS(Property::VECTOR4, value1.GetType(), TEST_LOCATION);
+
+  Vector4 valueVector;
+  DALI_TEST_EQUALS(true, value1.Get(valueVector), TEST_LOCATION); // Able to convert
+  DALI_TEST_EQUALS(valueVector, Vector4::ONE, TEST_LOCATION);
+
+  Property::Value value2;
+  value2 = std::move(value1);
+  DALI_TEST_EQUALS(Property::NONE, value1.GetType(), TEST_LOCATION);
+  DALI_TEST_EQUALS(false, value1.Get(valueVector), TEST_LOCATION); // Unable to convert, but no crash either
+  DALI_TEST_EQUALS(Property::VECTOR4, value2.GetType(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value2.Get(valueVector), TEST_LOCATION); // Able to convert
+  DALI_TEST_EQUALS(valueVector, Vector4::ONE, TEST_LOCATION);
+
+  // Change to another value type
+  value2 = std::move(Property::Value(1.0f));
+  DALI_TEST_EQUALS(false, value2.Get(valueVector), TEST_LOCATION); // Should not be able to convert to a Vector4 now
+  float valueFloat;
+  DALI_TEST_EQUALS(true, value2.Get(valueFloat), TEST_LOCATION); // Should be able to convert to a float now
+  DALI_TEST_EQUALS(valueFloat, 1.0f, TEST_LOCATION);
+
+  // Ensure self assignment doesn't do anything silly
+  value2 = std::move(value2);
+  DALI_TEST_EQUALS(true, value2.Get(valueFloat), TEST_LOCATION);
+  DALI_TEST_EQUALS(valueFloat, 1.0f, TEST_LOCATION);
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet09P(void)
+int UtcDaliPropertyValueGetTypeP(void)
 {
-  TestApplication application;
-  GetCheckP<Vector4> check(Vector4(1.0,1.0,1.0,1.0));
+  Property::Value value;
+  DALI_TEST_CHECK(value.GetType() == Property::NONE);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet09N(void)
+int UtcDaliPropertyValueGetBoolP(void)
 {
-  TestApplication application;
-  GetCheckN<Vector4> check;
+  Property::Value value(true);
+  bool            boolean(false);
+  DALI_TEST_CHECK(value.Get(boolean) == true);
+  DALI_TEST_CHECK(value.Get<bool>() == true);
+  std::string string;
+  DALI_TEST_CHECK(value.Get(string) == false);
+  value = Property::Value(1.f);
+  DALI_TEST_CHECK(value.Get<float>() == 1.f);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet10P(void)
+int UtcDaliPropertyValueGetBoolN(void)
 {
-  TestApplication application;
-  GetCheckP<Matrix3> check(Matrix3(Matrix3::IDENTITY));
+  Property::Value value;
+  DALI_TEST_CHECK(value.Get<bool>() == false);
+  bool boolean(false);
+  DALI_TEST_CHECK(value.Get(boolean) == false);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet10N(void)
+int UtcDaliPropertyValueGetFloatP(void)
 {
-  TestApplication application;
-  GetCheckN<Matrix3> check;
+  Property::Value value(1.1f);
+  float           flow(0.0f);
+  DALI_TEST_EQUALS(1.1f, value.Get<float>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value.Get(flow), TEST_LOCATION);
+  DALI_TEST_EQUALS(1.1f, flow, TEST_LOCATION);
+
+  Property::Value intValue(100);
+  DALI_TEST_EQUALS(100.f, intValue.Get<float>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, intValue.Get(flow), TEST_LOCATION);
+  DALI_TEST_EQUALS(100.f, flow, TEST_LOCATION);
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet11P(void)
+int UtcDaliPropertyValueGetFloatN(void)
 {
-  TestApplication application;
-  GetCheckP<Matrix> check(Matrix(Matrix::IDENTITY));
+  Property::Value value;
+  float           result(1.0f);
+  DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(1.0f, result, TEST_LOCATION); // result is not modified
+  Property::Value value2("");
+  DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(1.0f, result, TEST_LOCATION); // result is not modified
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet11N(void)
+int UtcDaliPropertyValueGetIntP(void)
 {
-  TestApplication application;
-  GetCheckN<Matrix> check;
+  Property::Value value(123);
+  int             result(10);
+  DALI_TEST_EQUALS(123, value.Get<int>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(123, result, TEST_LOCATION);
+
+  Property::Value floatValue(21.f);
+  DALI_TEST_EQUALS(21, floatValue.Get<int>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, floatValue.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(21, result, TEST_LOCATION);
+
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet12P(void)
+int UtcDaliPropertyValueGetIntN(void)
 {
-  TestApplication application;
-  AngleAxis a(Degree(1.0), Vector3(1.0,1.0,1.0));
-  Property::Value v(a);
-  AngleAxis b = v.Get<AngleAxis>();
-  DALI_TEST_CHECK(a.angle == b.angle);
-  DALI_TEST_CHECK(a.axis == b.axis);
+  Property::Value value;
+  int             result(10);
+  DALI_TEST_EQUALS(0, value.Get<int>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(10, result, TEST_LOCATION); // result is not modified
+  Property::Value value2("");
+  DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(10, result, TEST_LOCATION); // result is not modified
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet12N(void)
+int UtcDaliPropertyValueGetRectP(void)
 {
-  TestApplication application;
-  GetCheckN<AngleAxis> check;
+  Property::Value value(Rect<int>(1, 2, 3, 4));
+  Rect<int>       result(4, 3, 2, 1);
+  DALI_TEST_EQUALS(Rect<int>(1, 2, 3, 4), value.Get<Rect<int> >(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Rect<int>(1, 2, 3, 4), result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet13P(void)
+int UtcDaliPropertyValueGetRectN(void)
 {
-  TestApplication application;
-  GetCheckP<Quaternion> check(Quaternion(1.0,1.0,1.0,1.0));
+  Property::Value value;
+  Rect<int>       result(4, 3, 2, 1);
+  DALI_TEST_EQUALS(Rect<int>(0, 0, 0, 0), value.Get<Rect<int> >(), TEST_LOCATION);
+  DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Rect<int>(4, 3, 2, 1), result, TEST_LOCATION);
+  Property::Value value2("");
+  DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Rect<int>(4, 3, 2, 1), result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet13N(void)
+int UtcDaliPropertyValueGetVector2P(void)
 {
-  TestApplication application;
-  GetCheckN<Quaternion> check;
+  Property::Value value(Vector2(1.0f, 2.0f));
+  Vector2         result;
+  DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), value.Get<Vector2>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet14P(void)
+int UtcDaliPropertyValueGetVector2fromVector3P(void)
 {
-  TestApplication application;
-  GetCheckP<std::string> check(std::string("astring"));
+  Property::Value value(Vector3(1.f, 2.f, 3.f));
+  Vector2         result;
+  DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), value.Get<Vector2>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet14N(void)
+int UtcDaliPropertyValueGetVector2fromVector4P(void)
 {
-  TestApplication application;
-  GetCheckN<std::string> check;
+  Property::Value value(Vector4(1.f, 2.f, 3.f, 4.f));
+  Vector2         result;
+  DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), value.Get<Vector2>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet15P(void)
+int UtcDaliPropertyValueGetVector2N(void)
 {
-  TestApplication application;
-  Property::Value a(Property::ARRAY);
-  a.AppendItem(Property::Value(1));
-  Property::Array got = a.Get<Property::Array>();
-  DALI_TEST_CHECK(got[0].Get<int>() == 1);
+  Property::Value value;
+  Vector2         result;
+  DALI_TEST_EQUALS(Vector2(0.f, 0.f), value.Get<Vector2>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Vector2(), result, TEST_LOCATION);
+  Property::Value value2("");
+  DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Vector2(), result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet15N(void)
+int UtcDaliPropertyValueGetVector3P(void)
 {
-  TestApplication application;
-  GetCheckN<Property::Array> check;
+  Property::Value value(Vector3(1.0f, 2.0f, -1.f));
+  Vector3         result;
+  DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, -1.f), value.Get<Vector3>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, -1.f), result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet16P(void)
+int UtcDaliPropertyValueGetVector3FromVector2P(void)
 {
-  TestApplication application;
-  Property::Value a(Property::MAP);
-  a.SetValue("key", Property::Value(1));
-  Property::Map got = a.Get<Property::Map>();
-  DALI_TEST_CHECK(got.GetValue(0).Get<int>() == 1);
+  Property::Value value(Vector2(1.0f, 2.0f));
+  Vector3         result(99.f, 88.f, 77.f);
+  DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, 0.f), value.Get<Vector3>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, 0.f), result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGet16N(void)
+int UtcDaliPropertyValueGetVector3FromVector4P(void)
 {
-  TestApplication application;
-  GetCheckN<Property::Map> check;
+  Property::Value value(Vector4(4.f, 3.f, 2.f, 1.f));
+  Vector3         result;
+  DALI_TEST_EQUALS(Vector3(4.f, 3.f, 2.f), value.Get<Vector3>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Vector3(4.f, 3.f, 2.f), result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGetValueP(void)
+int UtcDaliPropertyValueGetVector3N(void)
 {
-  TestApplication application;
-  Property::Value map(Property::MAP);
-  Property::Value a(1);
-  map.SetValue("key", a);
-  DALI_TEST_CHECK( map.GetValue("key").Get<int>() == 1 );
+  Property::Value value;
+  Vector3         result;
+  DALI_TEST_EQUALS(Vector3(0.f, 0.f, 0.f), value.Get<Vector3>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Vector3(), result, TEST_LOCATION);
+  Property::Value value2("");
+  DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Vector3(), result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGetValue01N(void)
+int UtcDaliPropertyValueGetVector4P(void)
 {
-  TestApplication application;
-  Property::Value value(1);
-
-  try
-  {
-    Property::Value got = value.GetValue("key");
-    tet_result(TET_FAIL);
-  }
-  catch( Dali::DaliException& e )
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT( e, "Property type invalid", TEST_LOCATION );
-  }
-  catch( ... )
-  {
-    tet_printf("Assertion test failed - wrong Exception\n" );
-    tet_result(TET_FAIL);
-  }
-
+  Property::Value value(Vector4(1.f, 2.f, -1.f, -3.f));
+  Vector4         result;
+  DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, -3.f), value.Get<Vector4>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, -3.f), result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGetValue02N(void)
+int UtcDaliPropertyValueGetVector4FromVector2P(void)
 {
-  TestApplication application;
-  Property::Value value(Property::MAP);
-  value.SetValue("key", Property::Value(1));
-
-  try
-  {
-    Property::Value got = value.GetValue("nokey");
-    tet_result(TET_FAIL);
-  }
-  catch( Dali::DaliException& e )
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT( e, "Cannot find property map key", TEST_LOCATION );
-  }
-  catch( ... )
-  {
-    tet_printf("Assertion test failed - wrong Exception\n" );
-    tet_result(TET_FAIL);
-  }
-
+  Property::Value value(Vector2(-1.f, -3.f));
+  Vector4         result(99.f, 88.f, 77.f, 66.f);
+  DALI_TEST_EQUALS(Vector4(-1.f, -3.f, 0.f, 0.f), value.Get<Vector4>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Vector4(-1.f, -3.f, 0.f, 0.f), result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueHasKeyP(void)
+int UtcDaliPropertyValueGetVector4FromVector3P(void)
 {
-  TestApplication application;
-  Property::Value map(Property::MAP);
-  Property::Value a(1);
-  map.SetValue("key", a);
-  DALI_TEST_CHECK( map.HasKey("key") == true );
-  DALI_TEST_CHECK( map.HasKey("key2") == false );
+  Property::Value value(Vector3(1.f, 2.f, -1.f));
+  Vector4         result(99.f, 88.f, 77.f, 66.f);
+  DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, 0.f), value.Get<Vector4>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, 0.f), result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueHasKeyN(void)
+int UtcDaliPropertyValueGetVector4N(void)
 {
-  TestApplication application;
-  Property::Value a(1);
-  DALI_TEST_CHECK( a.HasKey("key") == false );
+  Property::Value value;
+  Vector4         result;
+  DALI_TEST_EQUALS(Vector4(0.f, 0.f, 0.f, 0.f), value.Get<Vector4>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Vector4(), result, TEST_LOCATION);
+  Property::Value value2("");
+  DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Vector4(), result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGetKeyP(void)
+int UtcDaliPropertyValueGetMatrix3P(void)
 {
-  TestApplication application;
-  Property::Value map(Property::MAP);
-  Property::Value a(1);
-  map.SetValue("key", a);
-  std::string empty;
-  DALI_TEST_CHECK( map.GetKey(-1) == empty );
-  DALI_TEST_CHECK( map.GetKey(1) == empty );
+  Property::Value value(Matrix3(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f));
+  Matrix3         result;
+  DALI_TEST_EQUALS(Matrix3(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f), value.Get<Matrix3>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Matrix3(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f), result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGetKeyN(void)
+int UtcDaliPropertyValueGetMatrix3N(void)
 {
-  TestApplication application;
-  Property::Value a(1);
-  std::string empty;
-  DALI_TEST_CHECK( a.GetKey(0) == empty );
+  Property::Value value;
+  Matrix3         result(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f);
+  DALI_TEST_EQUALS(Matrix3(), value.Get<Matrix3>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Matrix3(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f), result, TEST_LOCATION);
+  Property::Value value2("");
+  DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Matrix3(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f), result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueSetValueP(void)
+int UtcDaliPropertyValueGetMatrixP(void)
 {
-  TestApplication application;
-  Property::Value map(Property::MAP);
-  Property::Value a(1);
-  map.SetValue("key", a);
-  DALI_TEST_CHECK( map.GetValue("key").Get<int>() == 1 );
+  float           matrixValues[16] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
+  Matrix          input(matrixValues);
+  Property::Value value(input);
+  Matrix          result;
+  DALI_TEST_EQUALS(input, value.Get<Matrix>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(input, result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueSetValueN(void)
+int UtcDaliPropertyValueGetMatrixN(void)
 {
-  TestApplication application;
-  Property::Value value(1);
-
-  try
-  {
-    value.SetValue("key", Property::Value(1));
-    tet_result(TET_FAIL);
-  }
-  catch( Dali::DaliException& e )
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT( e, "Property type invalid", TEST_LOCATION );
-  }
-  catch( ... )
-  {
-    tet_printf("Assertion test failed - wrong Exception\n" );
-    tet_result(TET_FAIL);
-  }
+  Property::Value value;
+  Matrix          result(Matrix::IDENTITY);
+  DALI_TEST_EQUALS(Matrix(), value.Get<Matrix>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Matrix::IDENTITY, result, TEST_LOCATION);
 
+  Property::Value value2("");
+  DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Matrix::IDENTITY, result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGetItem01P(void)
+int UtcDaliPropertyValueGetAngleAxisP(void)
 {
-  TestApplication application;
-  Property::Value value(Property::ARRAY);
-  value.AppendItem(Property::Value(0));
-  value.SetItem(0, Property::Value(1));
-  DALI_TEST_CHECK( value.GetItem(0).Get<int>() == 1 );
-
-  value = Property::Value(Property::MAP);
-  value.SetValue("key", Property::Value(0));
-  value.SetItem(0, Property::Value(1));
-  DALI_TEST_CHECK( value.GetItem(0).Get<int>() == 1 );
+  AngleAxis       input(Dali::ANGLE_90, Vector3::XAXIS);
+  Property::Value value(input);
+  AngleAxis       result = value.Get<AngleAxis>();
+  DALI_TEST_EQUALS(input.angle, result.angle, TEST_LOCATION);
+  DALI_TEST_EQUALS(input.axis, result.axis, TEST_LOCATION);
 
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(input, result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGetItem01N(void)
+int UtcDaliPropertyValueGetAngleAxisN(void)
 {
-  TestApplication application;
-
-  Property::Value value(1);
-
-  try
-  {
-    Property::Value item = value.GetItem(0);
-    tet_result(TET_FAIL);
-  }
-  catch( Dali::DaliException& e )
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT( e, "Cannot GetItem on property Type; not a container", TEST_LOCATION );
-  }
-  catch( ... )
-  {
-    tet_printf("Assertion test failed - wrong Exception\n" );
-    tet_result(TET_FAIL);
-  }
+  Property::Value value;
+  AngleAxis       b = value.Get<AngleAxis>();
+  AngleAxis       result;
+  DALI_TEST_EQUALS((Radian)0.f, b.angle, TEST_LOCATION);
+  DALI_TEST_EQUALS(Vector3::ZERO, b.axis, TEST_LOCATION);
+  DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(AngleAxis(), result, TEST_LOCATION);
 
+  Property::Value value2("");
+  DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(AngleAxis(), result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGetItem02P(void)
+int UtcDaliPropertyValueGetQuaternionP(void)
 {
-  TestApplication application;
-  Property::Value value(Property::ARRAY);
-  value.AppendItem(Property::Value(0));
-  value.SetItem(0, Property::Value(1));
-  std::string key;
-  DALI_TEST_CHECK( value.GetItem(0, key).Get<int>() == 1 );
-  DALI_TEST_CHECK( key.size() == 0u );
+  Vector3 axis(1, 1, 0);
+  axis.Normalize();
 
-  value = Property::Value(Property::MAP);
-  value.SetValue("key", Property::Value(0));
-  value.SetItem(0, Property::Value(1));
-  DALI_TEST_CHECK( value.GetItem(0, key).Get<int>() == 1 );
-  DALI_TEST_CHECK( key.size() == 3 );
-  DALI_TEST_CHECK( key == std::string("key") );
+  Quaternion      result(Radian(1.f), axis);
+  Property::Value value(result);
 
+  DALI_TEST_EQUALS(result, value.Get<Quaternion>(), TEST_LOCATION);
+  Quaternion test2;
+  DALI_TEST_EQUALS(true, value.Get(test2), TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueGetItem02N(void)
+int UtcDaliPropertyValueGetQuaternionN(void)
 {
-  TestApplication application;
+  Property::Value value;
+  Vector3         axis(1, 1, 0);
+  axis.Normalize();
+  Quaternion result(Radian(1.f), axis);
+  Quaternion test(result);
 
-  Property::Value value(1);
-  std::string key;
-  try
-  {
-    Property::Value item = value.GetItem(0, key);
-    tet_result(TET_FAIL);
-  }
-  catch( Dali::DaliException& e )
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT( e, "Cannot GetItem on property Type; not a container", TEST_LOCATION );
-  }
-  catch( ... )
-  {
-    tet_printf("Assertion test failed - wrong Exception\n" );
-    tet_result(TET_FAIL);
-  }
+  DALI_TEST_EQUALS(Quaternion(), value.Get<Quaternion>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(false, value.Get(test), TEST_LOCATION);
+  DALI_TEST_EQUALS(test, result, TEST_LOCATION);
 
+  Property::Value value2("");
+  DALI_TEST_EQUALS(false, value2.Get(test), TEST_LOCATION);
+  DALI_TEST_EQUALS(test, result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueSetItemP(void)
+int UtcDaliPropertyValueGetStringP(void)
 {
-  TestApplication application;
-
-  Property::Value value(Property::ARRAY);
-  value.AppendItem(Property::Value(0));
-  value.SetItem(0, Property::Value(1));
-  DALI_TEST_CHECK( value.GetItem(0).Get<int>() == 1 );
-
-  value = Property::Value(Property::MAP);
-  value.SetValue("key", Property::Value(0));
-  value.SetItem(0, Property::Value(1));
-  DALI_TEST_CHECK( value.GetItem(0).Get<int>() == 1 );
+  Property::Value value(std::string("hello"));
+  std::string     result;
+  DALI_TEST_EQUALS(std::string("hello"), value.Get<std::string>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(std::string("hello"), result, TEST_LOCATION);
 
+  Property::Value value2("C hi!");
+  DALI_TEST_EQUALS("C hi!", value2.Get<std::string>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value2.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS("C hi!", result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueSetItemN(void)
+int UtcDaliPropertyValueGetStringN(void)
 {
-  TestApplication application;
+  Property::Value value;
+  std::string     result("doesn't change");
+  DALI_TEST_EQUALS(std::string(), value.Get<std::string>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS("doesn't change", result, TEST_LOCATION);
 
-  Property::Value value(1);
-
-  try
-  {
-    value.SetItem(0, Property::Value(2));
-    tet_result(TET_FAIL);
-  }
-  catch( Dali::DaliException& e )
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT( e, "Cannot SetItem on property Type; not a container", TEST_LOCATION );
-  }
-  catch( ... )
-  {
-    tet_printf("Assertion test failed - wrong Exception\n" );
-    tet_result(TET_FAIL);
-  }
+  Property::Value value2(10);
+  DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS("doesn't change", result, TEST_LOCATION);
 
+  Property::Value value3((char*)NULL);
+  DALI_TEST_EQUALS(true, value3.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(std::string(), result, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliPropertyValueAppendItemP(void)
+int UtcDaliPropertyValueGetArrayP(void)
 {
-  TestApplication application;
-
   Property::Value value(Property::ARRAY);
-  value.AppendItem(Property::Value(1));
-  DALI_TEST_CHECK( value.GetItem(0).Get<int>() == 1 );
+  DALI_TEST_CHECK(NULL != value.GetArray());
+  value.GetArray()->PushBack(Property::Value(1));
+  Property::Array got = value.Get<Property::Array>();
+  DALI_TEST_CHECK(got[0].Get<int>() == 1);
+  Property::Array result;
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_CHECK(result[0].Get<int>() == 1);
+  END_TEST;
+}
 
+int UtcDaliPropertyValueGetArrayN(void)
+{
+  Property::Value value;
+  DALI_TEST_CHECK(NULL == value.GetArray());
+  Property::Array result;
+  result.PushBack(Property::Value(10));
+  DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION); // array is not modified
+
+  Property::Value value2("");
+  DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION); // array is not modified
   END_TEST;
 }
 
-int UtcDaliPropertyValueAppendItemN(void)
+int UtcDaliPropertyValueGetMapP(void)
 {
-  TestApplication application;
+  Property::Value value(Property::MAP);
+  DALI_TEST_CHECK(NULL == value.GetArray());
+  DALI_TEST_CHECK(NULL != value.GetMap());
+  value.GetMap()->Insert("key", Property::Value(1));
+  Property::Map result = value.Get<Property::Map>();
+  DALI_TEST_CHECK(result.Find("key")->Get<int>() == 1);
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_CHECK(result.Find("key")->Get<int>() == 1);
+  END_TEST;
+}
 
-  Property::Value value(1);
+int UtcDaliPropertyValueGetMapN(void)
+{
+  Property::Value value;
+  DALI_TEST_CHECK(NULL == value.GetMap());
+  DALI_TEST_EQUALS(0u, value.Get<Property::Map>().Count(), TEST_LOCATION);
+  Property::Map result;
+  result.Insert("key", "value");
+  DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION);
 
-  try
-  {
-    Property::Value item = value.AppendItem(Property::Value(1));
-    tet_result(TET_FAIL);
-  }
-  catch( Dali::DaliException& e )
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT( e, "Property type invalid", TEST_LOCATION );
-  }
-  catch( ... )
-  {
-    tet_printf("Assertion test failed - wrong Exception\n" );
-    tet_result(TET_FAIL);
-  }
+  Property::Value value2("");
+  DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION); // array is not modified
+  END_TEST;
+}
 
+int UtcDaliPropertyValueGetExtentsP(void)
+{
+  Property::Value value(Extents(1u, 2u, 3u, 4u));
+  Extents         result(4u, 3u, 2u, 1u);
+  DALI_TEST_EQUALS(Extents(1u, 2u, 3u, 4u), value.Get<Extents>(), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(Extents(1u, 2u, 3u, 4u), result, TEST_LOCATION);
   END_TEST;
 }
 
+int UtcDaliPropertyValueEnum(void)
+{
+  enum class E
+  {
+    zero,
+    e
+  };
+  Property::Value value(E::e);
+  DALI_TEST_EQUALS(static_cast<int>(E::e), static_cast<int>(value.Get<E>()), TEST_LOCATION);
+  DALI_TEST_EQUALS(static_cast<int>(E::e), value.Get<int>(), TEST_LOCATION);
+  E result;
+  DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+  DALI_TEST_EQUALS(static_cast<int>(E::e), static_cast<int>(result), TEST_LOCATION);
+  int result2;
+  DALI_TEST_EQUALS(true, value.Get(result2), TEST_LOCATION);
+  DALI_TEST_EQUALS(static_cast<int>(E::e), result2, TEST_LOCATION);
+  END_TEST;
+}
 
 int UtcDaliPropertyValueOutputStream(void)
 {
@@ -1332,90 +1297,148 @@ int UtcDaliPropertyValueOutputStream(void)
   {
     std::ostringstream stream;
     stream << value;
-    DALI_TEST_CHECK( stream.str() == "1")
+    DALI_TEST_CHECK(stream.str() == "1")
+  }
+
+  {
+    Property::Value    empty;
+    std::ostringstream stream;
+    stream << empty;
+    DALI_TEST_EQUALS(stream.str(), "undefined type", TEST_LOCATION);
+  }
+
+  {
+    Property::Value    empty(Property::NONE);
+    std::ostringstream stream;
+    stream << empty;
+    DALI_TEST_CHECK(stream.str() == "undefined type")
   }
 
   {
     value = Property::Value(20.2f);
     std::ostringstream stream;
-    stream <<  value;
-    DALI_TEST_CHECK( stream.str() == "20.2")
+    stream << value;
+    DALI_TEST_CHECK(stream.str() == "20.2")
   }
 
   {
     value = Property::Value(-25);
     std::ostringstream stream;
-    stream <<  value;
-    DALI_TEST_CHECK( stream.str() == "-25")
+    stream << value;
+    DALI_TEST_CHECK(stream.str() == "-25")
   }
 
   {
-    value = Property::Value(25U);
+    value = Property::Value(Vector2(1.f, 1.f));
     std::ostringstream stream;
-    stream <<  value;
-    DALI_TEST_CHECK( stream.str() == "25")
+    stream << value;
+    DALI_TEST_CHECK(stream.str() == "[1, 1]");
   }
 
   {
-    value = Property::Value( Vector2(1.f,1.f) );
+    value = Property::Value(Vector3(1.f, 1.f, 1.f));
     std::ostringstream stream;
-    stream <<  value;
-    DALI_TEST_CHECK( stream.str() == "[1, 1]");
+    stream << value;
+    DALI_TEST_CHECK(stream.str() == "[1, 1, 1]");
   }
 
   {
-    value = Property::Value( Vector3(1.f,1.f,1.f) );
+    value = Property::Value(Vector4(-4.f, -3.f, -2.f, -1.f));
     std::ostringstream stream;
-    stream <<  value;
-    DALI_TEST_CHECK( stream.str() == "[1, 1, 1]");
+    stream << value;
+    DALI_TEST_EQUALS(stream.str(), "[-4, -3, -2, -1]", TEST_LOCATION);
   }
 
   {
-    value = Property::Value( Matrix3::IDENTITY );
+    value = Property::Value(Matrix3::IDENTITY);
     std::ostringstream stream;
-    stream <<  value;
-    DALI_TEST_CHECK( stream.str() == "[ [1, 0, 0], [0, 1, 0], [0, 0, 1] ]");
+    stream << value;
+    DALI_TEST_CHECK(stream.str() == "[ 1, 0, 0, 0, 1, 0, 0, 0, 1 ]");
   }
 
   {
-    value = Property::Value( Matrix::IDENTITY );
+    value = Property::Value(Matrix::IDENTITY);
     std::ostringstream stream;
-    stream <<  value;
-    DALI_TEST_CHECK( stream.str() == "[ [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1] ]");
+    stream << value;
+    DALI_TEST_CHECK(stream.str() == "[ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ]");
   }
 
   {
-    value = Property::Value( Rectangle(1,2,3,4) );
+    value = Property::Value(Rectangle(1, 2, 3, 4));
     std::ostringstream stream;
-    stream <<  value;
-    DALI_TEST_CHECK( stream.str() == "[1, 2, 3, 4]");
+    stream << value;
+    DALI_TEST_CHECK(stream.str() == "[1, 2, 3, 4]");
   }
 
   {
-    value = Property::Value( AngleAxis( Radian(1.2f), Vector3::XAXIS ));
+    value = Property::Value(AngleAxis(Dali::ANGLE_120, Vector3::XAXIS));
     std::ostringstream stream;
-    stream <<  value;
-    tet_printf("angle axis = %s \n", stream.str().c_str() );
-    DALI_TEST_CHECK( stream.str() == "[1.2, -0, 0, 0]");
+    stream << value;
+    tet_printf("angle axis = %s \n", stream.str().c_str());
+    DALI_TEST_EQUALS(stream.str(), "[ Axis: [1, 0, 0], Angle: 120 degrees ]", TEST_LOCATION);
+  }
+
+  {
+    value = Property::Value(std::string("Foo"));
+    std::ostringstream stream;
+    stream << value;
+    DALI_TEST_CHECK(stream.str() == "Foo");
   }
 
-  // Maps and arrays currently not supported, we just check a message is output
   {
     Property::Map map;
-    value = Property::Value( map );
+    map.Insert("key", "value");
+    map.Insert("duration", 10);
+    map.Insert("color", Vector4(1.0, 0.5, 1.0, 1.0));
+
+    value = Property::Value(map);
     std::ostringstream stream;
-    stream <<  value;
-    DALI_TEST_CHECK( !stream.str().empty() );
+    stream << value;
+    tet_printf("Checking Property::Value is %s", stream.str().c_str());
+    DALI_TEST_CHECK(!stream.str().compare("Map(3) = {key:value, duration:10, color:[1, 0.5, 1, 1]}"));
   }
   {
     Property::Array array;
-    value = Property::Value( array );
+    array.PushBack(0);
+    array.PushBack(2);
+    array.PushBack(3);
+    value = Property::Value(array);
     std::ostringstream stream;
-    stream <<  value;
-    DALI_TEST_CHECK( !stream.str().empty() );
+    stream << value;
+    tet_printf("Checking Property::Value is %s", stream.str().c_str());
+    DALI_TEST_CHECK(!stream.str().compare("Array(3) = [0, 2, 3]"));
   }
 
+  {
+    Property::Map   map;
+    Property::Map   map2;
+    Property::Array array;
 
-  END_TEST;
+    map2.Insert("key", "value");
+    map2.Insert("duration", 10);
+    map.Insert("color", Vector4(1.0, 0.5, 1.0, 1.0));
+    map.Insert("timePeriod", map2);
+    array.PushBack(Vector2(1, 0));
+    array.PushBack(Vector2(0, 1));
+    array.PushBack(Vector2(1, 0));
+    array.PushBack(Vector2(0, 0.5));
+    map.Insert("texCoords", array);
+    value = Property::Value(map);
+
+    std::ostringstream stream;
+    stream << value;
+
+    tet_printf("Checking Property::Value is %s", stream.str().c_str());
+
+    DALI_TEST_CHECK(!stream.str().compare("Map(3) = {color:[1, 0.5, 1, 1], timePeriod:Map(2) = {key:value, duration:10}, texCoords:Array(4) = [[1, 0], [0, 1], [1, 0], [0, 0.5]]}"));
+  }
 
+  {
+    value = Property::Value(Extents(1u, 2u, 3u, 4u));
+    std::ostringstream stream;
+    stream << value;
+    DALI_TEST_CHECK(stream.str() == "[1, 2, 3, 4]");
+  }
+
+  END_TEST;
 }