X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali%2Futc-Dali-PropertyValue.cpp;h=712f60fa9a6e5bac6693faba93cd4dfd0c1ec8d3;hb=17f28cc04cbb2708a29a6ef7a353ce15fc434b2d;hp=5163b92b03a4d238a4cfa383391c5172760dfb1e;hpb=46ff27fd5e5f627927c94aee6fc94461c65c05cb;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 5163b92..712f60f 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) 2019 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.
@@ -26,94 +26,6 @@ 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 CheckCopyCtorP
 {
@@ -124,43 +36,6 @@ struct CheckCopyCtorP
   }
 };
 
-template <>
-struct CheckCopyCtorP<AngleAxis>
-{
-  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 );
-  }
-};
-
-template <>
-struct CheckCopyCtorP<Property::Array>
-{
-  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() );
-  }
-};
-
-template <>
-struct CheckCopyCtorP<Property::Map>
-{
-  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() );
-  }
-};
-
 } // unnamed namespace
 
 void utc_dali_property_value_startup(void)
@@ -189,10 +64,6 @@ int UtcDaliPropertyValueConstructorsNoneTypeP(void)
 
   DALI_TEST_CHECK( value.GetType() == Property::NONE );
 
-  Property::Value value2( Property::TYPE_COUNT );
-
-  DALI_TEST_CHECK( value2.GetType() == Property::NONE );
-
   END_TEST;
 }
 
@@ -256,26 +127,6 @@ int UtcDaliPropertyValueConstructorsIntTypeP(void)
   END_TEST;
 }
 
-int UtcDaliPropertyValueConstructorsUnsignedIntP(void)
-{
-  Property::Value value(1u);
-
-  DALI_TEST_CHECK( value.GetType() == Property::UNSIGNED_INTEGER );
-  DALI_TEST_CHECK( value.Get<unsigned int>() == 1u );
-
-  END_TEST;
-}
-
-int UtcDaliPropertyValueConstructorsUnsignedIntTypeP(void)
-{
-  Property::Value value( Property::UNSIGNED_INTEGER );
-
-  DALI_TEST_CHECK( value.GetType() == Property::UNSIGNED_INTEGER );
-  DALI_TEST_CHECK( value.Get<unsigned int>() == 0u );
-
-  END_TEST;
-}
-
 int UtcDaliPropertyValueConstructorsVector2P(void)
 {
   Vector2 v(1,1);
@@ -418,11 +269,11 @@ int UtcDaliPropertyValueConstructorsAngleAxisP(void)
 
 int UtcDaliPropertyValueConstructorsQuaternionP(void)
 {
-  Quaternion v( Vector4(1.0,1.0,1.0,1.0) );
+  Quaternion v( Radian( Math::PI ), Vector3::ZAXIS );
   Property::Value value(v);
 
   DALI_TEST_CHECK( value.GetType() == Property::ROTATION );
-  DALI_TEST_CHECK( value.Get<Quaternion>() == v );
+  DALI_TEST_EQUALS( v, value.Get<Quaternion>(), 0.001, TEST_LOCATION);
 
   END_TEST;
 }
@@ -526,13 +377,33 @@ int UtcDaliPropertyValueConstructorsMapTypeP(void)
   END_TEST;
 }
 
+int UtcDaliPropertyValueConstructorsExtentsTypeP(void)
+{
+  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 UtcDaliPropertyValueConstructorsExtentsType2P(void)
+{
+  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 UtcDaliPropertyValueCopyConstructorP(void)
 {
   Property::Value value;
   Property::Value value2( value );
   DALI_TEST_EQUALS( value.GetType(), value2.GetType(), TEST_LOCATION );
-  DALI_TEST_EQUALS( value.IsMap(), value2.IsMap(), TEST_LOCATION );
-  DALI_TEST_EQUALS( value.IsArray(), value2.IsArray(), TEST_LOCATION );
+  DALI_TEST_EQUALS( value.GetMap(), value2.GetMap(), TEST_LOCATION );
+  DALI_TEST_EQUALS( value.GetArray(), value2.GetArray(), TEST_LOCATION );
   END_TEST;
 }
 
@@ -554,12 +425,6 @@ int UtcDaliPropertyValueCopyConstructorIntP(void)
   END_TEST;
 }
 
-int UtcDaliPropertyValueCopyConstructorUnsignedIntP(void)
-{
-  CheckCopyCtorP<unsigned int> check(1u);
-  END_TEST;
-}
-
 int UtcDaliPropertyValueCopyConstructoVector2P(void)
 {
   CheckCopyCtorP<Vector2> check( Vector2(2,1) );
@@ -641,14 +506,69 @@ int UtcDaliPropertyValueCopyConstructorMapP(void)
   END_TEST;
 }
 
+int UtcDaliPropertyValueMoveConstructor(void)
+{
+  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 UtcDaliPropertyValueMoveConstructorArray(void)
+{
+  Property::Array array;
+  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 UtcDaliPropertyValueMoveConstructorMap(void)
+{
+  Property::Map map;
+  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 UtcDaliPropertyValueAssignmentSelfP(void)
 {
   Property::Value value;
   Property::Value* self = &value;
   value = *self;
   DALI_TEST_EQUALS( value.GetType(), Property::NONE, TEST_LOCATION );
-  DALI_TEST_EQUALS( value.IsMap(), false, TEST_LOCATION );
-  DALI_TEST_EQUALS( value.IsArray(), false, TEST_LOCATION );
+  DALI_TEST_CHECK( value.GetMap() == NULL );
+  DALI_TEST_CHECK( value.GetArray() == NULL );
   END_TEST;
 }
 
@@ -685,17 +605,6 @@ int UtcDaliPropertyValueAssignmentOperatorIntP(void)
   END_TEST;
 }
 
-int UtcDaliPropertyValueAssignmentOperatorUnsignedIntP(void)
-{
-  Property::Value value;
-  value = Property::Value(10U); // type mismatch
-  DALI_TEST_CHECK( 10U == value.Get<unsigned int>() );
-  Property::Value copy( 123U);
-  copy = value; // type match
-  DALI_TEST_CHECK( 10U == copy.Get<unsigned int>() );
-  END_TEST;
-}
-
 int UtcDaliPropertyValueAssignmentOperatorFloatP(void)
 {
   Property::Value value;
@@ -780,11 +689,14 @@ int UtcDaliPropertyValueAssignmentOperatorRectP(void)
 int UtcDaliPropertyValueAssignmentOperatorQuaternionP(void)
 {
   Property::Value value;
-  value = Property::Value( Quaternion(1,1,1,1) ); // mismatch
-  DALI_TEST_CHECK( Quaternion(1,1,1,1) == value.Get<Quaternion>() );
+  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_CHECK( Quaternion(1,1,1,1) == copy.Get<Quaternion>() );
+  DALI_TEST_EQUALS( copy.Get<Quaternion>(), result, 0.001, TEST_LOCATION );
   END_TEST;
 }
 
@@ -842,6 +754,51 @@ int UtcDaliPropertyValueAssignmentOperatorMapP(void)
   END_TEST;
 }
 
+int UtcDaliPropertyValueAssignmentOperatorExtentsP(void)
+{
+  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 UtcDaliPropertyValueMoveAssignmentOperator(void)
+{
+  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 UtcDaliPropertyValueGetTypeP(void)
 {
   Property::Value value;
@@ -852,7 +809,11 @@ int UtcDaliPropertyValueGetTypeP(void)
 int UtcDaliPropertyValueGetBoolP(void)
 {
   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;
@@ -862,118 +823,240 @@ int UtcDaliPropertyValueGetBoolN(void)
 {
   Property::Value value;
   DALI_TEST_CHECK( value.Get<bool>() == false );
+  bool boolean( false );
+  DALI_TEST_CHECK( value.Get( boolean ) == false );
   END_TEST;
 }
 
 int UtcDaliPropertyValueGetFloatP(void)
 {
   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 UtcDaliPropertyValueGetFloatN(void)
 {
   Property::Value value;
-  DALI_TEST_EQUALS( 0.0f, value.Get<float>(), TEST_LOCATION );
+  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 UtcDaliPropertyValueGetIntP(void)
 {
   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 UtcDaliPropertyValueGetIntN(void)
 {
   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 UtcDaliPropertyValueGetUnsignedIntP(void)
+int UtcDaliPropertyValueGetRectP(void)
 {
-  Property::Value value(123u);
-  DALI_TEST_EQUALS( 123u, value.Get<unsigned int>(), TEST_LOCATION );
+  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 UtcDaliPropertyValueGetUnsignedIntN(void)
+int UtcDaliPropertyValueGetRectN(void)
 {
   Property::Value value;
-  DALI_TEST_EQUALS( 0u, value.Get<unsigned int>(), TEST_LOCATION );
+  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 UtcDaliPropertyValueGetRectP(void)
+int UtcDaliPropertyValueGetVector2P(void)
 {
-  Property::Value value( Rect<int>(1,2,3,4) );
-  DALI_TEST_EQUALS( Rect<int>(1,2,3,4), value.Get< Rect<int> >(), TEST_LOCATION );
+  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 UtcDaliPropertyValueGetRectN(void)
+int UtcDaliPropertyValueGetVector2fromVector3P(void)
 {
-  Property::Value value;
-  DALI_TEST_EQUALS( Rect<int>(0,0,0,0), value.Get< Rect<int> >(), TEST_LOCATION );
+  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 UtcDaliPropertyValueGetVector2P(void)
+int UtcDaliPropertyValueGetVector2fromVector4P(void)
 {
-  Property::Value value( Vector2(1.0f,2.0f) );
+  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 UtcDaliPropertyValueGetVector2N(void)
 {
   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 UtcDaliPropertyValueGetVector3P(void)
 {
   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 UtcDaliPropertyValueGetVector3FromVector2P(void)
+{
+  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 UtcDaliPropertyValueGetVector3FromVector4P(void)
+{
+  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 UtcDaliPropertyValueGetVector3N(void)
 {
   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 UtcDaliPropertyValueGetVector4P(void)
 {
   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 UtcDaliPropertyValueGetVector4FromVector2P(void)
+{
+  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 UtcDaliPropertyValueGetVector4FromVector3P(void)
+{
+  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 UtcDaliPropertyValueGetVector4N(void)
 {
   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 UtcDaliPropertyValueGetMatrix3P(void)
 {
   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 UtcDaliPropertyValueGetMatrix3N(void)
 {
   Property::Value value;
-  DALI_TEST_EQUALS( Matrix3::IDENTITY, value.Get< Matrix3 >(), TEST_LOCATION );
+  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;
 }
 
@@ -982,14 +1065,24 @@ int UtcDaliPropertyValueGetMatrixP(void)
   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 UtcDaliPropertyValueGetMatrixN(void)
 {
   Property::Value value;
-  DALI_TEST_EQUALS( Matrix::IDENTITY, value.Get< Matrix >(), TEST_LOCATION );
+  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;
 }
 
@@ -1000,6 +1093,9 @@ int UtcDaliPropertyValueGetAngleAxisP(void)
   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;
 }
 
@@ -1007,36 +1103,80 @@ int UtcDaliPropertyValueGetAngleAxisN(void)
 {
   Property::Value value;
   AngleAxis b = value.Get<AngleAxis>();
-  DALI_TEST_EQUALS( 0.f, b.angle, TEST_LOCATION );
+  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 UtcDaliPropertyValueGetQuaternionP(void)
 {
-  Property::Value value( Quaternion(1.f,2.f,3.f,4.f) );
-  DALI_TEST_EQUALS( Quaternion(1.f,2.f,3.f,4.f), value.Get< Quaternion >(), TEST_LOCATION );
+  Vector3 axis(1, 1, 0);
+  axis.Normalize();
+
+  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 UtcDaliPropertyValueGetQuaternionN(void)
 {
   Property::Value value;
-  DALI_TEST_EQUALS( Quaternion::IDENTITY, value.Get< Quaternion >(), TEST_LOCATION );
+  Vector3 axis(1, 1, 0);
+  axis.Normalize();
+  Quaternion result( Radian( 1.f ), axis );
+  Quaternion test(result);
+
+  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 UtcDaliPropertyValueGetStringP(void)
 {
   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 UtcDaliPropertyValueGetStringN(void)
 {
   Property::Value value;
-  DALI_TEST_EQUALS( std::string(""), value.Get< std::string >(), TEST_LOCATION );
+  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 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;
 }
 
@@ -1047,6 +1187,9 @@ int UtcDaliPropertyValueGetArrayP(void)
   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;
 }
 
@@ -1054,10 +1197,14 @@ int UtcDaliPropertyValueGetArrayN(void)
 {
   Property::Value value;
   DALI_TEST_CHECK( NULL == value.GetArray() );
-  Property::Array array;
-  array.PushBack( Property::Value( 10 ) );
-  value.Get( array );
-  DALI_TEST_CHECK( 0 == array.Count() );
+  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;
 }
 
@@ -1067,8 +1214,10 @@ int UtcDaliPropertyValueGetMapP(void)
   DALI_TEST_CHECK( NULL == value.GetArray() );
   DALI_TEST_CHECK( NULL != value.GetMap() );
   value.GetMap()->Insert("key", Property::Value(1));
-  Property::Map got = value.Get<Property::Map>();
-  DALI_TEST_CHECK(got.Find("key")->Get<int>() == 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;
 }
 
@@ -1076,8 +1225,40 @@ int UtcDaliPropertyValueGetMapN(void)
 {
   Property::Value value;
   DALI_TEST_CHECK( NULL == value.GetMap() );
-  Property::Map map = value.Get<Property::Map>();
-  DALI_TEST_CHECK( 0 == map.Count() );
+  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 );
+
+  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;
 }
 
@@ -1098,7 +1279,7 @@ int UtcDaliPropertyValueOutputStream(void)
     Property::Value empty;
     std::ostringstream stream;
     stream << empty;
-    DALI_TEST_EQUALS( stream.str(), "empty type", TEST_LOCATION );
+    DALI_TEST_EQUALS( stream.str(), "undefined type", TEST_LOCATION );
   }
 
   {
@@ -1109,13 +1290,6 @@ int UtcDaliPropertyValueOutputStream(void)
   }
 
   {
-    Property::Value empty( Property::TYPE_COUNT );
-    std::ostringstream stream;
-    stream << empty;
-    DALI_TEST_CHECK( stream.str() == "undefined type" )
-  }
-
-  {
     value = Property::Value(20.2f);
     std::ostringstream stream;
     stream <<  value;
@@ -1130,13 +1304,6 @@ int UtcDaliPropertyValueOutputStream(void)
   }
 
   {
-    value = Property::Value(25U);
-    std::ostringstream stream;
-    stream <<  value;
-    DALI_TEST_CHECK( stream.str() == "25" )
-  }
-
-  {
     value = Property::Value( Vector2(1.f,1.f) );
     std::ostringstream stream;
     stream <<  value;
@@ -1161,14 +1328,14 @@ int UtcDaliPropertyValueOutputStream(void)
     value = Property::Value( Matrix3::IDENTITY );
     std::ostringstream stream;
     stream <<  value;
-    DALI_TEST_CHECK( stream.str() == "[ [1, 0, 0], [0, 1, 0], [0, 0, 1] ]" );
+    DALI_TEST_CHECK( stream.str() == "[ 1, 0, 0, 0, 1, 0, 0, 0, 1 ]" );
   }
 
   {
     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] ]" );
+    DALI_TEST_CHECK( stream.str() == "[ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ]" );
   }
 
   {
@@ -1193,20 +1360,59 @@ int UtcDaliPropertyValueOutputStream(void)
     DALI_TEST_CHECK( stream.str() == "Foo" );
   }
 
-  // Maps and arrays currently not supported, we just check a message is output
   {
     Property::Map 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;
+    array.PushBack(0);
+    array.PushBack(2);
+    array.PushBack(3);
     value = Property::Value( array );
     std::ostringstream stream;
     stream <<  value;
-    DALI_TEST_CHECK( !stream.str().empty() );
+    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;
+
+    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;