+namespace
+{
+template<typename T>
+struct CheckCopyCtorP
+{
+ CheckCopyCtorP(Property::Value value)
+ {
+ Property::Value copy(value);
+ DALI_TEST_CHECK(value.Get<T>() == copy.Get<T>());
+ }
+};
+
+} // unnamed namespace
+
+void utc_dali_property_value_startup(void)
+{
+ test_return_value = TET_UNDEF;
+}
+
+void utc_dali_property_value_cleanup(void)
+{
+ test_return_value = TET_PASS;
+}
+
+int UtcDaliPropertyValueConstructorsNoneP(void)
+{
+ Property::Value value;
+
+ DALI_TEST_CHECK(value.GetType() == Property::NONE);
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsNoneTypeP(void)
+{
+ Property::Value value(Property::NONE);
+
+ DALI_TEST_CHECK(value.GetType() == Property::NONE);
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsBoolP(void)
+{
+ Property::Value value(true);
+
+ DALI_TEST_CHECK(value.GetType() == Property::BOOLEAN);
+ DALI_TEST_CHECK(value.Get<bool>() == true);
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorBoolTypeP(void)
+{
+ Property::Value value(Property::BOOLEAN);
+
+ DALI_TEST_CHECK(value.GetType() == Property::BOOLEAN);
+ DALI_TEST_CHECK(value.Get<bool>() == false);
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsFloatP(void)
+{
+ Property::Value value(2.f);
+
+ DALI_TEST_CHECK(value.GetType() == Property::FLOAT);
+ DALI_TEST_CHECK(value.Get<float>() == 2.f);
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsFloatTypeP(void)
+{
+ Property::Value value(Property::FLOAT);
+
+ DALI_TEST_CHECK(value.GetType() == Property::FLOAT);
+ DALI_TEST_CHECK(value.Get<float>() == 0.f);
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsIntP(void)
+{
+ Property::Value value(1);
+
+ DALI_TEST_CHECK(value.GetType() == Property::INTEGER);
+ DALI_TEST_CHECK(value.Get<int>() == 1);
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsIntTypeP(void)
+{
+ Property::Value value(Property::INTEGER);
+
+ DALI_TEST_CHECK(value.GetType() == Property::INTEGER);
+ DALI_TEST_CHECK(value.Get<int>() == 0);
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsVector2P(void)
+{
+ Vector2 v(1, 1);
+ Property::Value value(v);
+
+ DALI_TEST_CHECK(value.GetType() == Property::VECTOR2);
+ DALI_TEST_CHECK(value.Get<Vector2>() == v);
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsVector2TypeP(void)
+{
+ Property::Value value(Property::VECTOR2);
+
+ DALI_TEST_CHECK(value.GetType() == Property::VECTOR2);
+ DALI_TEST_CHECK(value.Get<Vector2>() == Vector2::ZERO);
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsVector3P(void)
+{
+ Vector3 v(1.f, 2.f, 3.f);
+ Property::Value value(v);
+
+ DALI_TEST_CHECK(value.GetType() == Property::VECTOR3);
+ DALI_TEST_CHECK(value.Get<Vector3>() == v);
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsVector3TypeP(void)
+{
+ Property::Value value(Property::VECTOR3);
+
+ DALI_TEST_CHECK(value.GetType() == Property::VECTOR3);
+ DALI_TEST_CHECK(value.Get<Vector3>() == Vector3());
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsVector4P(void)
+{
+ Vector4 v(1.f, 1.f, 1.f, 0.9f);
+ Property::Value value(v);
+
+ DALI_TEST_CHECK(value.GetType() == Property::VECTOR4);
+ DALI_TEST_CHECK(value.Get<Vector4>() == v);
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsVector4TypeP(void)
+{
+ Property::Value value(Property::VECTOR4);
+
+ DALI_TEST_CHECK(value.GetType() == Property::VECTOR4);
+ DALI_TEST_CHECK(value.Get<Vector4>() == Vector4());
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsMatrix3P(void)
+{
+ 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::MATRIX3);
+ DALI_TEST_CHECK(value.Get<Matrix3>() == v);
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsMatrix3TypeP(void)
+{
+ Property::Value value(Property::MATRIX3);
+
+ DALI_TEST_CHECK(value.GetType() == Property::MATRIX3);
+ DALI_TEST_CHECK(value.Get<Matrix3>() == Matrix3());
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsMatrixP(void)
+{
+ 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::MATRIX);
+ DALI_TEST_CHECK(value.Get<Matrix>() == v);
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsMatrixTypeP(void)
+{
+ Property::Value value(Property::MATRIX);
+
+ DALI_TEST_CHECK(value.GetType() == Property::MATRIX);
+ DALI_TEST_CHECK(value.Get<Matrix>() == Matrix());
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsRectP(void)
+{
+ Rect<int> v(1.0, 1.0, 1.0, 1.0);
+ Property::Value value(v);
+
+ DALI_TEST_EQUALS(value.GetType(), Property::RECTANGLE, TEST_LOCATION);
+ DALI_TEST_CHECK(value.Get<Rect<int> >() == v);
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsRectTypeP(void)
+{
+ Property::Value value(Property::RECTANGLE);
+
+ DALI_TEST_CHECK(value.GetType() == Property::RECTANGLE);
+ DALI_TEST_CHECK(value.Get<Rect<int> >() == Rect<int>(0, 0, 0, 0));
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsAngleAxisP(void)
+{
+ 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 UtcDaliPropertyValueConstructorsQuaternionP(void)
+{
+ 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 UtcDaliPropertyValueConstructorsRotationTypeP(void)
+{
+ 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 UtcDaliPropertyValueConstructorsStringP(void)
+{
+ 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 UtcDaliPropertyValueConstructorsStringTypeP(void)
+{
+ Property::Value value(Property::STRING);
+
+ DALI_TEST_CHECK(value.GetType() == Property::STRING);
+ DALI_TEST_CHECK(value.Get<std::string>() == std::string());
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsArrayP(void)
+{
+ 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 UtcDaliPropertyValueConstructorsArray2P(void)
+{
+ 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 UtcDaliPropertyValueConstructorsArrayTypeP(void)
+{
+ Property::Value value(Property::ARRAY);
+
+ DALI_TEST_CHECK(value.GetType() == Property::ARRAY);
+ DALI_TEST_CHECK(value.Get<Property::Array>().Count() == 0);
+
+ END_TEST;
+}
+
+int UtcDaliPropertyValueConstructorsMapP(void)
+{
+ 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 UtcDaliPropertyValueConstructorsMap2P(void)
+{
+ 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 UtcDaliPropertyValueConstructorsMapTypeP(void)
+{
+ Property::Value value(Property::MAP);
+
+ DALI_TEST_CHECK(value.GetType() == Property::MAP);
+ DALI_TEST_CHECK(value.Get<Property::Map>().Count() == 0);
+
+ 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.GetMap(), value2.GetMap(), TEST_LOCATION);
+ DALI_TEST_EQUALS(value.GetArray(), value2.GetArray(), TEST_LOCATION);
+ END_TEST;
+}
+
+int UtcDaliPropertyValueCopyConstructorBoolP(void)
+{
+ CheckCopyCtorP<bool> check(true);
+ END_TEST;
+}
+
+int UtcDaliPropertyValueCopyConstructorFloatP(void)
+{
+ CheckCopyCtorP<float> check(1.f);
+ END_TEST;
+}
+
+int UtcDaliPropertyValueCopyConstructorIntP(void)
+{
+ CheckCopyCtorP<int> check(1);
+ END_TEST;
+}
+
+int UtcDaliPropertyValueCopyConstructoVector2P(void)
+{
+ CheckCopyCtorP<Vector2> check(Vector2(2, 1));
+ END_TEST;
+}
+
+int UtcDaliPropertyValueCopyConstructorVector3P(void)
+{
+ CheckCopyCtorP<Vector3> check(Vector3(3.f, 2.f, 1.f));
+ END_TEST;
+}
+
+int UtcDaliPropertyValueCopyConstructorVector4P(void)
+{
+ CheckCopyCtorP<Vector3> check(Vector4(4.f, 3.f, 2.f, 1.f));
+ END_TEST;
+}
+
+int UtcDaliPropertyValueCopyConstructorMatrix3P(void)
+{
+ CheckCopyCtorP<Matrix3> check(Matrix3::IDENTITY);
+ END_TEST;
+}
+
+int UtcDaliPropertyValueCopyConstructorMatrixP(void)
+{
+ CheckCopyCtorP<Matrix> check(Matrix::IDENTITY);
+ END_TEST;
+}
+
+int UtcDaliPropertyValueCopyConstructorRectP(void)
+{
+ CheckCopyCtorP<Rect<int> > check(Rect<int>(1.0, 1.0, 1.0, 1.0));
+ END_TEST;
+}
+
+int UtcDaliPropertyValueCopyConstructorAngleAxisP(void)
+{
+ CheckCopyCtorP<AngleAxis> check(AngleAxis(Degree(1.0), Vector3(1.0, 1.0, 1.0)));
+ END_TEST;
+}
+
+int UtcDaliPropertyValueCopyConstructorQuaternionP(void)
+{
+ CheckCopyCtorP<Quaternion> check(Quaternion(Vector4(1.0, 1.0, 1.0, 1.0)));
+ END_TEST;
+}
+
+int UtcDaliPropertyValueCopyConstructorStringP(void)
+{
+ CheckCopyCtorP<std::string> check(std::string("1"));
+ END_TEST;
+}
+
+int UtcDaliPropertyValueCopyAssignStringDifferentTypeP(void)
+{
+ Property::Value value1{Vector4(3.f, 2.f, 1.f, 2.0f)};
+ Property::Value value2{"very very long string ..................."};
+ value2 = value1;
+
+ 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 UtcDaliPropertyValueCopyConstructorArrayP(void)
+{
+ 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 UtcDaliPropertyValueCopyConstructorMapP(void)
+{
+ 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 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_CHECK(value.GetMap() == NULL);
+ DALI_TEST_CHECK(value.GetArray() == NULL);
+ END_TEST;
+}
+
+int UtcDaliPropertyValueAssignmentOperatorNoneP(void)
+{
+ Property::Value value;
+ 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 UtcDaliPropertyValueAssignmentOperatorBoolP(void)
+{
+ 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 UtcDaliPropertyValueAssignmentOperatorIntP(void)
+{
+ Property::Value value;
+ 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 UtcDaliPropertyValueAssignmentOperatorFloatP(void)
+{
+ 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 UtcDaliPropertyValueAssignmentOperatorVector2P(void)
+{
+ 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 UtcDaliPropertyValueAssignmentOperatorVector3P(void)
+{
+ 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 UtcDaliPropertyValueAssignmentOperatorVector4P(void)
+{
+ 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 UtcDaliPropertyValueAssignmentOperatorMatrix3P(void)
+{
+ 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 UtcDaliPropertyValueAssignmentOperatorMatrixP(void)
+{
+ 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 UtcDaliPropertyValueAssignmentOperatorRectP(void)
+{
+ 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 UtcDaliPropertyValueAssignmentOperatorQuaternionP(void)
+{
+ 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 UtcDaliPropertyValueAssignmentOperatorAngleAxisP(void)
+{
+ 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 UtcDaliPropertyValueAssignmentOperatorStringP(void)
+{
+ 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 UtcDaliPropertyValueAssignmentOperatorArrayP(void)
+{
+ 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 UtcDaliPropertyValueAssignmentOperatorMapP(void)
+{
+ 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 UtcDaliPropertyValueAssignmentOperatorExtentsP(void)