(AutomatedTests) Move devel-api dependent tests to internal tests 81/40081/1
authorAdeel Kazmi <adeel.kazmi@samsung.com>
Thu, 28 May 2015 14:50:35 +0000 (15:50 +0100)
committerAdeel Kazmi <adeel.kazmi@samsung.com>
Thu, 28 May 2015 14:51:07 +0000 (15:51 +0100)
TODO:
 - Stage: Move Dynamics API to Dynamics World
 - RenderTask: Uses HitTestAlgorithm, need to modify that test
 - TestNativeImage: Uses devel-api and is included by several image tests

Change-Id: I6f96b4d876c2418d3df99187786347ddd79defcd

47 files changed:
automated-tests/src/dali-internal/CMakeLists.txt
automated-tests/src/dali-internal/mesh-builder.cpp [new file with mode: 0644]
automated-tests/src/dali-internal/mesh-builder.h [new file with mode: 0644]
automated-tests/src/dali-internal/utc-Dali-AnimatableMesh.cpp [new file with mode: 0644]
automated-tests/src/dali-internal/utc-Dali-Atlas.cpp [new file with mode: 0644]
automated-tests/src/dali-internal/utc-Dali-Constrainer.cpp [new file with mode: 0644]
automated-tests/src/dali-internal/utc-Dali-Context.cpp [new file with mode: 0644]
automated-tests/src/dali-internal/utc-Dali-DistanceField.cpp [new file with mode: 0644]
automated-tests/src/dali-internal/utc-Dali-DynamicsBody.cpp [new file with mode: 0644]
automated-tests/src/dali-internal/utc-Dali-DynamicsBodyConfig.cpp [new file with mode: 0644]
automated-tests/src/dali-internal/utc-Dali-DynamicsJoint.cpp [new file with mode: 0644]
automated-tests/src/dali-internal/utc-Dali-DynamicsShape.cpp [new file with mode: 0644]
automated-tests/src/dali-internal/utc-Dali-DynamicsWorld.cpp [new file with mode: 0644]
automated-tests/src/dali-internal/utc-Dali-DynamicsWorldConfig.cpp [new file with mode: 0644]
automated-tests/src/dali-internal/utc-Dali-Hash.cpp [new file with mode: 0644]
automated-tests/src/dali-internal/utc-Dali-HitTestAlgorithm.cpp [new file with mode: 0644]
automated-tests/src/dali-internal/utc-Dali-Internal-Constraint.cpp [deleted file]
automated-tests/src/dali-internal/utc-Dali-Material.cpp [new file with mode: 0644]
automated-tests/src/dali-internal/utc-Dali-MeshActor.cpp [new file with mode: 0644]
automated-tests/src/dali-internal/utc-Dali-MeshData.cpp [new file with mode: 0644]
automated-tests/src/dali-internal/utc-Dali-Mutex.cpp [new file with mode: 0644]
automated-tests/src/dali-internal/utc-Dali-Scripting.cpp [new file with mode: 0644]
automated-tests/src/dali/CMakeLists.txt
automated-tests/src/dali/dali-test-suite-utils/mesh-builder.cpp [deleted file]
automated-tests/src/dali/dali-test-suite-utils/mesh-builder.h [deleted file]
automated-tests/src/dali/dali-test-suite-utils/test-platform-abstraction.h
automated-tests/src/dali/utc-Dali-AnimatableMesh.cpp [deleted file]
automated-tests/src/dali/utc-Dali-Atlas.cpp [deleted file]
automated-tests/src/dali/utc-Dali-Constrainer.cpp [deleted file]
automated-tests/src/dali/utc-Dali-Context.cpp [deleted file]
automated-tests/src/dali/utc-Dali-DistanceField.cpp [deleted file]
automated-tests/src/dali/utc-Dali-DynamicsBody.cpp [deleted file]
automated-tests/src/dali/utc-Dali-DynamicsBodyConfig.cpp [deleted file]
automated-tests/src/dali/utc-Dali-DynamicsJoint.cpp [deleted file]
automated-tests/src/dali/utc-Dali-DynamicsShape.cpp [deleted file]
automated-tests/src/dali/utc-Dali-DynamicsWorld.cpp [deleted file]
automated-tests/src/dali/utc-Dali-DynamicsWorldConfig.cpp [deleted file]
automated-tests/src/dali/utc-Dali-Hash.cpp [deleted file]
automated-tests/src/dali/utc-Dali-HitTestAlgorithm.cpp [deleted file]
automated-tests/src/dali/utc-Dali-IntrusivePtr.cpp
automated-tests/src/dali/utc-Dali-Material.cpp [deleted file]
automated-tests/src/dali/utc-Dali-MeshActor.cpp [deleted file]
automated-tests/src/dali/utc-Dali-MeshData.cpp [deleted file]
automated-tests/src/dali/utc-Dali-Mutex.cpp [deleted file]
automated-tests/src/dali/utc-Dali-ObjectRegistry.cpp
automated-tests/src/dali/utc-Dali-RenderableActor.cpp
automated-tests/src/dali/utc-Dali-Scripting.cpp [deleted file]

index 09109e4a1132d0a78fafa162d09fc75cc0aaf6df..217e8feb793c0a95e619b0b43ab59853528c9ead 100644 (file)
@@ -6,6 +6,22 @@ SET(RPM_NAME "core-${PKG_NAME}-tests")
 SET(CAPI_LIB "dali-internal")
 
 SET(TC_SOURCES
+        utc-Dali-Atlas.cpp
+        utc-Dali-AnimatableMesh.cpp
+        utc-Dali-Context.cpp
+        utc-Dali-Constrainer.cpp
+        utc-Dali-DistanceField.cpp
+        utc-Dali-DynamicsBodyConfig.cpp
+        utc-Dali-DynamicsShape.cpp
+        utc-Dali-DynamicsWorld.cpp
+        utc-Dali-DynamicsWorldConfig.cpp
+        utc-Dali-Hash.cpp
+        utc-Dali-HitTestAlgorithm.cpp
+        utc-Dali-Material.cpp
+        utc-Dali-MeshActor.cpp
+        utc-Dali-MeshData.cpp
+        utc-Dali-Mutex.cpp
+        utc-Dali-Scripting.cpp
         utc-Dali-Internal-Handles.cpp
         utc-Dali-Internal-ImageFactory.cpp
         utc-Dali-Internal-Mesh.cpp
@@ -17,7 +33,7 @@ SET(TC_SOURCES
 )
 
 LIST(APPEND TC_SOURCES
-        ../dali/dali-test-suite-utils/mesh-builder.cpp
+        mesh-builder.cpp
         ../dali/dali-test-suite-utils/test-harness.cpp
         ../dali/dali-test-suite-utils/dali-test-suite-utils.cpp
         ../dali/dali-test-suite-utils/test-application.cpp
@@ -43,6 +59,7 @@ ENDFOREACH(directory ${CAPI_LIB_LIBRARY_DIRS})
 
 INCLUDE_DIRECTORIES(
     ../../..
+    .
     ${${CAPI_LIB}_INCLUDE_DIRS}
     ../dali/dali-test-suite-utils
 )
@@ -50,6 +67,7 @@ INCLUDE_DIRECTORIES(
 ADD_EXECUTABLE(${EXEC_NAME} ${EXEC_NAME}.cpp ${TC_SOURCES})
 TARGET_LINK_LIBRARIES(${EXEC_NAME}
     ${${CAPI_LIB}_LIBRARIES}
+    -lpthread
 )
 
 INSTALL(PROGRAMS ${EXEC_NAME}
diff --git a/automated-tests/src/dali-internal/mesh-builder.cpp b/automated-tests/src/dali-internal/mesh-builder.cpp
new file mode 100644 (file)
index 0000000..772c892
--- /dev/null
@@ -0,0 +1,182 @@
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+#include "mesh-builder.h"
+
+namespace Dali
+{
+
+void AddVertex( MeshData::VertexContainer& verts, Vector3 V, Vector2 UV )
+{
+  MeshData::Vertex meshVertex;
+  meshVertex.x = V.x;
+  meshVertex.y = V.y;
+  meshVertex.z = V.z;
+  meshVertex.u = UV.x;
+  meshVertex.v = UV.y;
+  verts.push_back(meshVertex);
+}
+
+void SetNormal( MeshData::VertexContainer& verts, size_t vertIdx, Vector3 normal )
+{
+  verts[vertIdx].nX = normal.x;
+  verts[vertIdx].nY = normal.y;
+  verts[vertIdx].nZ = normal.z;
+}
+
+void SetBone( MeshData::VertexContainer& verts, size_t vertIdx, size_t index, size_t boneIndex, float weight)
+{
+  verts[vertIdx].boneIndices[index] = boneIndex;
+  verts[vertIdx].boneWeights[index] = weight;
+}
+
+void SetBones(MeshData::VertexContainer& verts)
+{
+  // Set all verts in one corner to be affected fully by bone 0
+  SetBone(verts, 0, 0, 0, 1.0f);
+  SetBone(verts, 1, 0, 0, 1.0f);
+  SetBone(verts, 2, 0, 0, 1.0f);
+
+  // Set all verts in next corner to be affected by bone 1 and bone 2 equally
+  SetBone(verts, 3, 0, 1, 0.5f);
+  SetBone(verts, 4, 0, 1, 0.5f);
+  SetBone(verts, 5, 0, 1, 0.5f);
+
+  SetBone(verts, 3, 1, 2, 0.5f);
+  SetBone(verts, 4, 1, 2, 0.5f);
+  SetBone(verts, 5, 1, 2, 0.5f);
+}
+
+void ConstructBones(BoneContainer& bones)
+{
+  bones.push_back(Bone("Bone1", Matrix::IDENTITY));
+  bones.push_back(Bone("Bone2", Matrix::IDENTITY));
+  bones.push_back(Bone("Bone3", Matrix::IDENTITY));
+}
+
+void CopyVertex( MeshData::Vertex& vert, Vector3& vector )
+{
+  vector.x = vert.x;
+  vector.y = vert.y;
+  vector.z = vert.z;
+}
+
+void AddTriangle( MeshData::VertexContainer& verts,
+                  MeshData::FaceIndices& faces,
+                  size_t v0, size_t v1, size_t v2 )
+{
+  faces.push_back(v0);
+  faces.push_back(v1);
+  faces.push_back(v2);
+
+  // Calculate normal...
+  Vector3 vert0, vert1, vert2;
+  CopyVertex(verts[v0], vert0);
+  CopyVertex(verts[v1], vert1);
+  CopyVertex(verts[v2], vert2);
+  Vector3 e0 = vert1 - vert0;
+  Vector3 e1 = vert2 - vert1;
+  Vector3 normal = e0.Cross(e1);
+  normal.Normalize();
+  SetNormal(verts, v0, normal);
+  SetNormal(verts, v1, normal);
+  SetNormal(verts, v2, normal);
+}
+
+void ConstructVertices( MeshData::VertexContainer& vertices, float sz )
+{
+  // back
+  AddVertex(vertices, Vector3( 0.0f,  -sz, 0.0f), Vector2(0.50f, 0.50f));        // 0a  0
+  AddVertex(vertices, Vector3( 0.0f,  -sz, 0.0f), Vector2(0.50f, 0.50f));        // 0b  1
+  AddVertex(vertices, Vector3( 0.0f,  -sz, 0.0f), Vector2(0.50f, 0.50f));        // 0c  2
+
+  // left
+  AddVertex(vertices, Vector3(-sz*0.5f, sz*0.3f, sz*0.5f), Vector2(0.25f, 0.50f));  // 1a  3
+  AddVertex(vertices, Vector3(-sz*0.5f, sz*0.3f, sz*0.5f), Vector2(0.25f, 0.50f));  // 1b  4
+  AddVertex(vertices, Vector3(-sz*0.5f, sz*0.3f, sz*0.5f), Vector2(0.25f, 0.50f));  // 1c  5
+
+  // right
+  AddVertex(vertices, Vector3( sz*0.5f, sz*0.3f, sz*0.5f), Vector2(0.50f, 0.25f));  // 2a  6
+  AddVertex(vertices, Vector3( sz*0.5f, sz*0.3f, sz*0.5f), Vector2(0.50f, 0.25f));  // 2b  7
+  AddVertex(vertices, Vector3( sz*0.5f, sz*0.3f, sz*0.5f), Vector2(0.50f, 0.25f));  // 2c  8
+
+  // top
+  AddVertex(vertices, Vector3( 0.0f,   sz*0.3f, -sz*0.7f), Vector2(0.25f, 0.25f)); // 3a  9
+  AddVertex(vertices, Vector3( 0.0f,   sz*0.3f, -sz*0.7f), Vector2(0.25f, 0.25f)); // 3b 10
+  AddVertex(vertices, Vector3( 0.0f,   sz*0.3f, -sz*0.7f), Vector2(0.25f, 0.25f)); // 3c 11
+}
+
+void ConstructFaces(MeshData::VertexContainer& vertices, MeshData::FaceIndices& faces)
+{
+  AddTriangle(vertices, faces,  0, 6,  3); // 0, 2, 1  back, right, left (ac)
+  AddTriangle(vertices, faces,  1, 9,  7); // 0, 3, 2  back, top , right (ac)
+  AddTriangle(vertices, faces,  2, 4, 10); // 0, 1, 3  back, left, top   (ac)
+  AddTriangle(vertices, faces, 11, 5,  8); // 3, 1, 2  top, left, right  (ac)
+}
+
+Material ConstructMaterial()
+{
+  Material customMaterial = Material::New("CustomMaterial");
+  customMaterial.SetOpacity(.76f);
+  customMaterial.SetDiffuseColor(Vector4(0.8f, 0.0f, 0.4f, 1.0f));
+  customMaterial.SetAmbientColor(Vector4(0.2f, 1.0f, 0.6f, 1.0f));
+  customMaterial.SetSpecularColor(Vector4(0.5f, 0.6f, 0.7f, 1.0f));
+  return customMaterial;
+}
+
+
+Mesh ConstructMesh( float sz )
+{
+  MeshData::VertexContainer vertices;
+  MeshData::FaceIndices     faces;
+  ConstructVertices( vertices, sz );
+  ConstructFaces(vertices, faces);
+  Material customMaterial = ConstructMaterial();
+
+  MeshData meshData;
+  BoneContainer bones;
+  meshData.SetData(vertices, faces, bones, customMaterial);
+  meshData.SetHasNormals(true);
+  meshData.SetHasTextureCoords(true);
+
+  Mesh mesh = Mesh::New(meshData);
+  return mesh;
+}
+
+
+void AddBone(Dali::BoneContainer& bones, const std::string& name, const Dali::Matrix& offsetMatrix)
+{
+  bones.push_back(Bone(name, offsetMatrix));
+}
+
+void CreateMeshData(MeshData& meshData)
+{
+  MeshData::VertexContainer vertices;
+  MeshData::FaceIndices faces;
+  Dali::BoneContainer bones;
+  AddBone(bones, "trunk",  Matrix::IDENTITY);
+  AddBone(bones, "branch", Matrix::IDENTITY);
+  AddBone(bones, "twig",   Matrix::IDENTITY);
+  ConstructVertices( vertices, 50 );
+  ConstructFaces(vertices, faces);
+  Material customMaterial = ConstructMaterial();
+  meshData.SetData(vertices, faces, bones, customMaterial);
+  meshData.SetHasNormals(true);
+  meshData.SetHasTextureCoords(true);
+}
+
+
+} // namespace Dali
diff --git a/automated-tests/src/dali-internal/mesh-builder.h b/automated-tests/src/dali-internal/mesh-builder.h
new file mode 100644 (file)
index 0000000..7d77806
--- /dev/null
@@ -0,0 +1,44 @@
+#ifndef MESH_BUILDER_H
+#define MESH_BUILDER_H
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <dali/public-api/dali-core.h>
+#include <dali/devel-api/geometry/mesh.h>
+
+namespace Dali
+{
+
+void AddVertex( MeshData::VertexContainer& verts, Vector3 V, Vector2 UV );
+void SetNormal( MeshData::VertexContainer& verts, size_t vertIdx, Vector3 normal );
+void SetBone( MeshData::VertexContainer& verts, size_t vertIdx, size_t index, size_t boneIndex, float weight);
+void SetBones(MeshData::VertexContainer& verts);
+void ConstructBones(BoneContainer& bones);
+void CopyVertex( MeshData::Vertex& vert, Vector3& vector );
+void AddTriangle( MeshData::VertexContainer& verts,
+                  MeshData::FaceIndices& faces,
+                  size_t v0, size_t v1, size_t v2 );
+void ConstructVertices( MeshData::VertexContainer& vertices, float sz );
+void ConstructFaces(MeshData::VertexContainer& vertices, MeshData::FaceIndices& faces);
+Material ConstructMaterial();
+Mesh ConstructMesh( float sz );
+void AddBone(Dali::BoneContainer& bones, const std::string& name, const Dali::Matrix& offsetMatrix);
+void CreateMeshData(MeshData& meshData);
+
+}
+
+#endif // MESH_BUILDER_H
diff --git a/automated-tests/src/dali-internal/utc-Dali-AnimatableMesh.cpp b/automated-tests/src/dali-internal/utc-Dali-AnimatableMesh.cpp
new file mode 100644 (file)
index 0000000..0de8bbb
--- /dev/null
@@ -0,0 +1,463 @@
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+#include <iostream>
+
+#include <stdlib.h>
+#include <dali/public-api/dali-core.h>
+#include <dali/devel-api/geometry/animatable-mesh.h>
+#include <dali/devel-api/actors/mesh-actor.h>
+#include <dali-test-suite-utils.h>
+#include <mesh-builder.h>
+
+using namespace Dali;
+
+
+void utc_dali_animatable_mesh_startup(void)
+{
+  test_return_value = TET_UNDEF;
+}
+
+void utc_dali_animatable_mesh_cleanup(void)
+{
+  test_return_value = TET_PASS;
+}
+
+namespace
+{
+
+void CreateFaces(Dali::AnimatableMesh::Faces& faces, int numVerts)
+{
+  for(int i=0; i<numVerts-3; i++)
+  {
+    faces.push_back(i);
+    faces.push_back(i+1);
+    faces.push_back(i+2);
+  }
+}
+
+void CreateOutOfRangeFaces(Dali::AnimatableMesh::Faces& faces, int numVerts)
+{
+  for(int i=numVerts; i<numVerts*2-3; i++)
+  {
+    faces.push_back(i);
+    faces.push_back(i+1);
+    faces.push_back(i+2);
+  }
+}
+
+AnimatableMesh CreateMesh()
+{
+  AnimatableMesh::Faces faces;
+  CreateFaces(faces, 10);
+  AnimatableMesh mesh = AnimatableMesh::New(10, faces);
+  return mesh;
+}
+
+} // anon namespace
+
+// Negative test case for a method
+int UtcDaliAnimatableMeshConstructor01(void)
+{
+  TestApplication application;
+
+  AnimatableMesh mesh;
+
+  DALI_TEST_CHECK( ! mesh );
+  END_TEST;
+}
+
+int UtcDaliAnimatableMeshConstructor02(void)
+{
+  TestApplication application;
+
+  Dali::AnimatableMesh::Faces faces;
+  CreateFaces(faces, 10);
+
+  AnimatableMesh mesh = AnimatableMesh::New(10, faces);
+  DALI_TEST_CHECK( mesh );
+
+  AnimatableMesh mesh2 = mesh;
+  DALI_TEST_CHECK( mesh2 );
+
+  AnimatableMesh mesh3 ( mesh2 );
+  DALI_TEST_CHECK( mesh3 );
+  END_TEST;
+}
+
+int UtcDaliAnimatableMeshConstructor03(void)
+{
+  TestApplication application;
+
+  // Heap allocate a handle. Don't do this in real code!
+  AnimatableMesh* mesh = new AnimatableMesh();
+  DALI_TEST_CHECK( ! *mesh );
+  delete mesh;
+  END_TEST;
+}
+
+
+// Positive test case for a method
+int UtcDaliAnimatableMeshNew01(void)
+{
+  TestApplication application;
+
+  Dali::AnimatableMesh::Faces faces;
+  CreateFaces(faces, 10);
+
+  AnimatableMesh mesh = AnimatableMesh::New(10, faces);
+  DALI_TEST_CHECK( mesh );
+  END_TEST;
+}
+
+// Positive test case for a method
+int UtcDaliAnimatableMeshNew02(void)
+{
+  TestApplication application;
+
+  Dali::AnimatableMesh::Faces faces;
+  CreateFaces(faces, 10);
+
+  Dali::Material mat = Dali::Material::New("dummy mat");
+  AnimatableMesh mesh = AnimatableMesh::New(10, faces, mat);
+  DALI_TEST_CHECK( mesh );
+  END_TEST;
+}
+
+
+// Negative test case for a method
+int UtcDaliAnimatableMeshNew03(void)
+{
+  TestApplication application;
+  Dali::AnimatableMesh::Faces faces;
+  try
+  {
+    AnimatableMesh mesh = AnimatableMesh::New(0, faces);
+    DALI_TEST_CHECK( !mesh );
+  }
+  catch (Dali::DaliException& e)
+  {
+    DALI_TEST_PRINT_ASSERT( e );
+    DALI_TEST_ASSERT(e, "numVertices > 0", TEST_LOCATION);
+  }
+  END_TEST;
+}
+
+// Negative test case for a method
+int UtcDaliAnimatableMeshNew04(void)
+{
+  TestApplication application;
+
+  Dali::AnimatableMesh::Faces faces;
+
+  try
+  {
+    AnimatableMesh mesh = AnimatableMesh::New(10, faces);
+    DALI_TEST_CHECK( !mesh );
+  }
+  catch (Dali::DaliException& e)
+  {
+    DALI_TEST_PRINT_ASSERT( e );
+    DALI_TEST_ASSERT(e, "faceIndices.size() > 0", TEST_LOCATION);
+  }
+  END_TEST;
+}
+
+// Negative test case for a method
+int UtcDaliAnimatableMeshNew05(void)
+{
+  TestApplication application;
+
+  Dali::AnimatableMesh::Faces faces;
+  CreateOutOfRangeFaces(faces, 10);
+
+  try
+  {
+    AnimatableMesh mesh = AnimatableMesh::New(10, faces);
+    DALI_TEST_CHECK( !mesh );
+  }
+  catch (Dali::DaliException& e)
+  {
+    DALI_TEST_PRINT_ASSERT( e );
+    DALI_TEST_ASSERT(e, "faceIndex < numVertices", TEST_LOCATION);
+  }
+  END_TEST;
+}
+
+// Negative test case for a method
+int UtcDaliAnimatableMeshNew06(void)
+{
+  TestApplication application;
+
+  Dali::AnimatableMesh::Faces faces;
+  CreateFaces(faces, 10);
+
+  try
+  {
+    AnimatableMesh mesh = AnimatableMesh::New(10, faces, Dali::Material() );
+    DALI_TEST_CHECK( !mesh );
+  }
+  catch (Dali::DaliException& e)
+  {
+    DALI_TEST_PRINT_ASSERT( e );
+    DALI_TEST_ASSERT(e, "material", TEST_LOCATION);
+  }
+  END_TEST;
+}
+
+int UtcDaliAnimatableMeshDownCast01(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::AnimatableMesh::DownCast()");
+
+  Dali::AnimatableMesh::Faces faces;
+  CreateFaces(faces, 10);
+
+  AnimatableMesh mesh = AnimatableMesh::New(10, faces);
+  BaseHandle* bh = &mesh;
+
+  AnimatableMesh mesh2 = AnimatableMesh::DownCast(*bh);
+  DALI_TEST_CHECK( mesh2 );
+  END_TEST;
+}
+
+int UtcDaliAnimatableMeshDownCast02(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::AnimatableMesh::DownCast()");
+
+  MeshData meshData;
+  CreateMeshData(meshData);
+  Mesh mesh = Mesh::New(meshData);
+  BaseHandle* bh = &mesh;
+
+  AnimatableMesh mesh2 = AnimatableMesh::DownCast(*bh);
+  DALI_TEST_CHECK( ! mesh2 );
+  END_TEST;
+}
+
+int UtcDaliAnimatableMeshGetPropertyIndex01(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::AnimatableMesh::operator[]");
+  AnimatableMesh mesh = CreateMesh();
+
+  Property::Index i = mesh.GetPropertyIndex(0, AnimatableVertex::Property::POSITION );
+  DALI_TEST_EQUALS( i, 0*3+0, TEST_LOCATION );
+
+  i = mesh.GetPropertyIndex(5, AnimatableVertex::Property::POSITION );
+  DALI_TEST_EQUALS( i, 5*3+0, TEST_LOCATION );
+
+  i = mesh.GetPropertyIndex(7, AnimatableVertex::Property::COLOR );
+  DALI_TEST_EQUALS( i, 7*3+1, TEST_LOCATION );
+
+  i = mesh.GetPropertyIndex(9, AnimatableVertex::Property::TEXTURE_COORDS );
+  DALI_TEST_EQUALS( i, 9*3+2, TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliAnimatableMeshGetPropertyIndex02(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::AnimatableMesh::GetPropertyIndex");
+
+  AnimatableMesh mesh = CreateMesh();
+  try
+  {
+    Property::Index i = mesh.GetPropertyIndex(12, AnimatableVertex::Property::POSITION );
+    DALI_TEST_CHECK( i==0 );
+  }
+  catch (Dali::DaliException& e)
+  {
+    DALI_TEST_PRINT_ASSERT( e );
+    DALI_TEST_ASSERT(e, "index < GetNumberOfVertices()", TEST_LOCATION);
+  }
+  END_TEST;
+}
+
+int UtcDaliAnimatableMeshGetPropertyIndex03(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::AnimatableMesh::GetPropertyIndex");
+
+  AnimatableMesh mesh = CreateMesh();
+  try
+  {
+    Property::Index i = mesh.GetPropertyIndex(12, AnimatableVertex::Property::COLOR );
+    DALI_TEST_CHECK( i==0 );
+  }
+  catch (Dali::DaliException& e)
+  {
+    DALI_TEST_PRINT_ASSERT( e );
+    DALI_TEST_ASSERT(e, "index < GetNumberOfVertices()", TEST_LOCATION);
+  }
+  END_TEST;
+}
+
+int UtcDaliAnimatableMeshGetPropertyIndex04(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::AnimatableMesh::GetPropertyIndexa");
+
+  AnimatableMesh mesh = CreateMesh();
+  try
+  {
+    Property::Index i = mesh.GetPropertyIndex(12342343, AnimatableVertex::Property::TEXTURE_COORDS );
+    DALI_TEST_CHECK( i==0 );
+  }
+  catch (Dali::DaliException& e)
+  {
+    DALI_TEST_PRINT_ASSERT( e );
+    DALI_TEST_ASSERT(e, "index < GetNumberOfVertices()", TEST_LOCATION);
+  }
+  END_TEST;
+}
+
+int UtcDaliAnimatableMeshOperatorArray01(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::AnimatableMesh::operator[]");
+
+  AnimatableMesh mesh = CreateMesh();
+  {
+    Vector3 initialPos1(0.0f, 200.0f, 0.0f);
+    Vector3 initialPos2(100.0f, 300.0f, 0.0f);
+
+    mesh[1].SetPosition(initialPos1);
+    mesh[3].SetPosition(initialPos2);
+
+    application.Render(0);
+    application.SendNotification();
+    application.Render(16);
+    application.SendNotification();
+    DALI_TEST_EQUALS( mesh[1].GetCurrentPosition(), initialPos1, TEST_LOCATION );
+
+    Vector3 pos = mesh[3].GetCurrentPosition();
+    DALI_TEST_EQUALS( pos, initialPos2, TEST_LOCATION );
+  }
+  END_TEST;
+}
+
+int UtcDaliAnimatableMeshOperatorArray02(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::AnimatableMesh::operator[]");
+
+  AnimatableMesh mesh = CreateMesh();
+  try
+  {
+    mesh[20].SetPosition(Vector3(0.0f, 0.0f, 0.0f));
+  }
+  catch (Dali::DaliException& e)
+  {
+    DALI_TEST_PRINT_ASSERT( e );
+    DALI_TEST_ASSERT(e, "index < GetNumberOfVertices()", TEST_LOCATION);
+  }
+  END_TEST;
+}
+
+int UtcDaliAnimatableMeshAnimateVertex01(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::AnimatableMesh Animating properties");
+
+  AnimatableMesh mesh = CreateMesh();
+  MeshActor meshActor = MeshActor::New(mesh);
+  Stage::GetCurrent().Add(meshActor);
+  {
+    mesh[0].SetPosition(Vector3(0.0f, 200.0f, 0.0f));
+    mesh[1].SetPosition(Vector3(100.0f, 300.0f, 0.0f));
+
+    Animation anim = Animation::New(1);
+    anim.AnimateBy(mesh.GetVertexProperty(0, AnimatableVertex::Property::POSITION), Vector3(  0.0f, 100.0f, 0.0f));
+    anim.AnimateTo(mesh.GetVertexProperty(1, AnimatableVertex::Property::POSITION), Vector3(100.0f,   0.0f, 0.0f));
+    anim.Play();
+
+    application.SendNotification();
+    application.Render(0);
+    application.Render(500);
+    application.SendNotification();
+
+    // 50% progress
+    DALI_TEST_EQUALS( mesh[0].GetCurrentPosition(), Vector3(  0.0f, 250.0f, 0.0f), TEST_LOCATION );
+    DALI_TEST_EQUALS( mesh[1].GetCurrentPosition(), Vector3(100.0f, 150.0f, 0.0f), TEST_LOCATION );
+
+    application.SendNotification();
+    application.Render(501);
+    application.SendNotification();
+
+    DALI_TEST_EQUALS( mesh[0].GetCurrentPosition(), Vector3(  0.0f, 300.0f, 0.0f), TEST_LOCATION );
+    DALI_TEST_EQUALS( mesh[1].GetCurrentPosition(), Vector3(100.0f,   0.0f, 0.0f), TEST_LOCATION );
+  }
+  END_TEST;
+}
+
+int UtcDaliAnimatableVertexSettersAndGetters(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::AnimatableVertex constructors");
+  AnimatableMesh mesh = CreateMesh();
+  Vector3 v1Pos(0.0f, 200.0f, 0.0f);
+  Vector3 v2Pos(100.0f, 300.0f, 0.0f);
+  Vector2 uvs(0.1f, 0.2f);
+  mesh[0].SetPosition(v1Pos);
+  mesh[1].SetPosition(v2Pos);
+  mesh[2].SetColor(Color::BLACK);
+  mesh[3].SetTextureCoords(uvs);
+
+  application.SendNotification();
+  application.Render(16);
+  application.SendNotification();
+  application.Render(16);
+  application.SendNotification();
+
+  DALI_TEST_EQUALS(mesh[0].GetCurrentPosition(), v1Pos, TEST_LOCATION);
+  DALI_TEST_EQUALS(mesh[1].GetCurrentPosition(), v2Pos, TEST_LOCATION);
+  DALI_TEST_EQUALS(mesh[2].GetCurrentColor(), Color::BLACK, TEST_LOCATION);
+  DALI_TEST_EQUALS(mesh[3].GetCurrentTextureCoords(), uvs, TEST_LOCATION);
+  END_TEST;
+}
+
+int UtcDaliAnimatableMeshProperties(void)
+{
+  TestApplication application;
+  AnimatableMesh mesh = CreateMesh();
+
+  Property::IndexContainer indices;
+  mesh.GetPropertyIndices( indices );
+  DALI_TEST_CHECK( ! indices.empty() );
+  DALI_TEST_EQUALS( indices.size(), mesh.GetPropertyCount(), TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliAnimatableMeshExceedVertices(void)
+{
+  TestApplication application;
+
+  AnimatableMesh::Faces faces;
+  CreateFaces(faces, 10);
+
+  try
+  {
+    AnimatableMesh mesh = AnimatableMesh::New(3333334, faces);
+    tet_result( TET_FAIL );
+  }
+  catch ( DaliException& e )
+  {
+    DALI_TEST_ASSERT( e, "( numVertices * 3 ) < DEFAULT_PROPERTY_MAX_COUNT", TEST_LOCATION );
+  }
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-internal/utc-Dali-Atlas.cpp b/automated-tests/src/dali-internal/utc-Dali-Atlas.cpp
new file mode 100644 (file)
index 0000000..137f40d
--- /dev/null
@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+#include <algorithm>
+#include <stdlib.h>
+#include <dali/public-api/dali-core.h>
+#include <dali/integration-api/bitmap.h>
+#include <dali/devel-api/images/atlas.h>
+#include <dali-test-suite-utils.h>
+#include <test-native-image.h>
+
+using namespace Dali;
+
+namespace
+{
+static const char* gTestImageFilename = "icon_wrt.png";
+
+void PrepareResourceImage( TestApplication& application, unsigned int imageHeight, unsigned int imageWidth, Pixel::Format pixelFormat )
+{
+  TestPlatformAbstraction& platform = application.GetPlatform();
+  platform.SetClosestImageSize(Vector2( 16, 16));
+
+  Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::RETAIN );
+  Integration::PixelBuffer* pixbuffer = bitmap->GetPackedPixelsProfile()->ReserveBuffer( pixelFormat, imageWidth, imageHeight, imageWidth, imageHeight );
+  unsigned int bytesPerPixel = GetBytesPerPixel(  pixelFormat );
+  unsigned int initialColor = 0xFF;
+  memset( pixbuffer, initialColor, imageHeight*imageWidth*bytesPerPixel);
+
+  Integration::ResourcePointer resourcePtr(bitmap);
+  platform.SetResourceLoaded( 0, Dali::Integration::ResourceBitmap, resourcePtr );
+}
+
+}
+
+void utc_dali_atlas_startup(void)
+{
+  test_return_value = TET_UNDEF;
+}
+
+void utc_dali_atlas_cleanup(void)
+{
+  test_return_value = TET_PASS;
+}
+
+// 1.1
+int UtcDaliAtlasNew01(void)
+{
+  TestApplication application;
+
+  // invoke default handle constructor
+  Atlas atlas;
+
+  DALI_TEST_CHECK( !atlas );
+
+  // initialise handle
+  atlas = Atlas::New( 16, 16 );
+
+  DALI_TEST_CHECK( atlas );
+  END_TEST;
+}
+
+
+// 1.2
+int UtcDaliAtlasUpload01(void)
+{
+  TestApplication application;
+
+  Atlas atlas = Atlas::New( 16, 16, Pixel::RGBA8888 );
+  DALI_TEST_CHECK( atlas );
+
+  // Using correct pixel format
+  PixelBuffer* buffer = new PixelBuffer[16 * 16];
+  BufferImage image = BufferImage::New( buffer, 16, 16, Pixel::RGBA8888 );
+  DALI_TEST_CHECK( atlas.Upload( image, 0, 0 ) );
+
+  PrepareResourceImage( application, 16, 16, Pixel::RGBA8888 );
+  DALI_TEST_CHECK( atlas.Upload( gTestImageFilename, 0, 0 ) );
+
+  END_TEST;
+}
+
+// 1.3
+int UtcDaliAtlasUpload02(void)
+{
+  TestApplication application;
+
+  Atlas atlas = Atlas::New( 10, 10, Pixel::RGBA8888 );
+  DALI_TEST_CHECK( atlas );
+
+  // Using INCORRECT pixel format
+  PixelBuffer* buffer = new PixelBuffer[16 * 16];
+  BufferImage image = BufferImage::New( buffer, 16, 16, Pixel::A8 );
+  DALI_TEST_CHECK( !atlas.Upload( image, 0, 0 ) );
+
+  PrepareResourceImage( application, 16, 16, Pixel::A8 );
+  DALI_TEST_CHECK( !atlas.Upload( gTestImageFilename, 0, 0 ) );
+
+  END_TEST;
+}
+
+// 1.4
+int UtcDaliAtlasUpload03(void)
+{
+  TestApplication application;
+
+  Atlas atlas = Atlas::New( 10, 10, Pixel::RGBA8888 );
+  DALI_TEST_CHECK( atlas );
+
+  // Using image too big for atlas
+  PixelBuffer* buffer = new PixelBuffer[16 * 16];
+  BufferImage image = BufferImage::New( buffer, 16, 16, Pixel::RGBA8888 );
+  DALI_TEST_CHECK( !atlas.Upload( image, 0, 0 ) );
+
+  PrepareResourceImage( application, 16, 16, Pixel::RGBA8888 );
+  DALI_TEST_CHECK( !atlas.Upload( gTestImageFilename, 0, 0 ) );
+
+  END_TEST;
+}
+
+// 1.5
+int UtcDaliAtlasUpload04(void)
+{
+  TestApplication application;
+
+  Atlas atlas = Atlas::New( 32, 32, Pixel::RGBA8888 );
+  DALI_TEST_CHECK( atlas );
+
+  // Using valid offsets
+  PixelBuffer* buffer = new PixelBuffer[16 * 16];
+  BufferImage image = BufferImage::New( buffer, 16, 16, Pixel::RGBA8888 );
+
+  DALI_TEST_CHECK( atlas.Upload( image,  0,  0 ) );
+  DALI_TEST_CHECK( atlas.Upload( image, 16,  0 ) );
+  DALI_TEST_CHECK( atlas.Upload( image,  0, 16 ) );
+  DALI_TEST_CHECK( atlas.Upload( image, 16, 16 ) );
+
+  PrepareResourceImage( application, 16, 16, Pixel::RGBA8888 );
+  DALI_TEST_CHECK( atlas.Upload( gTestImageFilename,  0,  0 ) );
+  DALI_TEST_CHECK( atlas.Upload( gTestImageFilename, 16,  0 ) );
+  DALI_TEST_CHECK( atlas.Upload( gTestImageFilename,  0, 16 ) );
+  DALI_TEST_CHECK( atlas.Upload( gTestImageFilename, 16, 16 ) );
+
+  END_TEST;
+}
+
+// 1.6
+int UtcDaliAtlasUpload05(void)
+{
+  TestApplication application;
+
+  Atlas atlas = Atlas::New( 32, 32, Pixel::RGBA8888 );
+  DALI_TEST_CHECK( atlas );
+
+  // Using invalid offsets
+  PixelBuffer* buffer = new PixelBuffer[16 * 16];
+  BufferImage image = BufferImage::New( buffer, 16, 16, Pixel::RGBA8888 );
+
+  DALI_TEST_CHECK( !atlas.Upload( image,  0, 17 ) );
+  DALI_TEST_CHECK( !atlas.Upload( image, 17,  0 ) );
+  DALI_TEST_CHECK( !atlas.Upload( image, 17, 17 ) );
+  DALI_TEST_CHECK( !atlas.Upload( image, 99,  0 ) );
+  DALI_TEST_CHECK( !atlas.Upload( image,  0, 99 ) );
+  DALI_TEST_CHECK( !atlas.Upload( image, 99, 99 ) );
+
+  PrepareResourceImage( application, 16, 16, Pixel::RGBA8888 );
+
+  DALI_TEST_CHECK( !atlas.Upload( gTestImageFilename,  0, 17 ) );
+  DALI_TEST_CHECK( !atlas.Upload( gTestImageFilename, 17,  0 ) );
+  DALI_TEST_CHECK( !atlas.Upload( gTestImageFilename, 17, 17 ) );
+  DALI_TEST_CHECK( !atlas.Upload( gTestImageFilename, 99,  0 ) );
+  DALI_TEST_CHECK( !atlas.Upload( gTestImageFilename,  0, 99 ) );
+  DALI_TEST_CHECK( !atlas.Upload( gTestImageFilename, 99, 99 ) );
+
+  END_TEST;
+}
+
diff --git a/automated-tests/src/dali-internal/utc-Dali-Constrainer.cpp b/automated-tests/src/dali-internal/utc-Dali-Constrainer.cpp
new file mode 100644 (file)
index 0000000..076a9c2
--- /dev/null
@@ -0,0 +1,546 @@
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+
+#include <stdlib.h>
+#include <dali/public-api/dali-core.h>
+#include <dali/devel-api/animation/path-constrainer.h>
+#include <dali-test-suite-utils.h>
+
+using namespace Dali;
+using namespace Dali::Internal;
+
+namespace
+{
+
+static void SetupPath( Dali::Path& path)
+{
+  path.AddPoint(Vector3( 30.0,  80.0, 0.0));
+  path.AddPoint(Vector3( 70.0, 120.0, 0.0));
+  path.AddPoint(Vector3(100.0, 100.0, 0.0));
+
+  //Control points for first segment
+  path.AddControlPoint( Vector3( 39.0,  90.0, 0.0) );
+  path.AddControlPoint(Vector3( 56.0, 119.0, 0.0) );
+
+  //Control points for second segment
+  path.AddControlPoint(Vector3( 78.0, 120.0, 0.0) );
+  path.AddControlPoint(Vector3( 93.0, 104.0, 0.0) );
+}
+
+static void SetupPathConstrainer( Dali::PathConstrainer& PathConstrainer)
+{
+  PathConstrainer.SetProperty( Dali::PathConstrainer::Property::FORWARD, Vector3(1.0f,0.0f,0.0f) );
+
+  Dali::Property::Array points;
+  points.Resize(3);
+  points[0] = Vector3( 30.0,  80.0, 0.0);
+  points[1] = Vector3( 70.0, 120.0, 0.0);
+  points[2] = Vector3(100.0, 100.0, 0.0);
+  PathConstrainer.SetProperty( Dali::PathConstrainer::Property::POINTS, points );
+
+  points.Resize(4);
+  points[0] = Vector3( 39.0,  90.0, 0.0);
+  points[1] = Vector3( 56.0, 119.0, 0.0);
+  points[2] = Vector3( 78.0, 120.0, 0.0);
+  points[3] = Vector3( 93.0, 104.0, 0.0);
+  PathConstrainer.SetProperty( Dali::PathConstrainer::Property::CONTROL_POINTS, points );
+}
+
+static void SetupLinearConstrainerUniformProgress( Dali::LinearConstrainer& linearConstrainer)
+{
+  Dali::Property::Array points;
+  points.Resize(3);
+  points[0] = 0.0f;
+  points[1] = 1.0f;
+  points[2] = 0.0f;
+  linearConstrainer.SetProperty( Dali::LinearConstrainer::Property::VALUE, points );
+}
+
+static void SetupLinearConstrainerNonUniformProgress( Dali::LinearConstrainer& linearConstrainer)
+{
+  Dali::Property::Array points;
+  points.Resize(3);
+  points[0] = 0.0f;
+  points[1] = 1.0f;
+  points[2] = 0.0f;
+  linearConstrainer.SetProperty( Dali::LinearConstrainer::Property::VALUE, points );
+
+  points[0] = 0.0f;
+  points[1] = 0.25f;
+  points[2] = 1.0f;
+  linearConstrainer.SetProperty( Dali::LinearConstrainer::Property::PROGRESS, points );
+}
+
+} // anonymous namespace
+
+//PathConstrainer test cases
+int UtcPathConstrainerApply(void)
+{
+  TestApplication application;
+
+  Dali::Actor actor = Dali::Actor::New();
+
+  // Register a float property
+  Property::Index index = actor.RegisterProperty( "t", 0.0f );
+
+  Dali::Stage::GetCurrent().Add(actor);
+
+  //Create a Path
+  Dali::Path path = Dali::Path::New();
+  SetupPath(path);
+
+  //Create a PathConstrainer
+  Dali::PathConstrainer pathConstrainer = Dali::PathConstrainer::New();
+  SetupPathConstrainer( pathConstrainer );
+
+  //Apply the path constraint to the actor's position. The source property for the constraint will be the custom property "t"
+  Vector2 range( 0.0f, 1.0f );
+  pathConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION), Property(actor,index), range );
+
+  //Create an animation to animate the custom property
+  float durationSeconds(1.0f);
+  Dali::Animation animation = Dali::Animation::New(durationSeconds);
+  animation.AnimateTo(Dali::Property(actor,index),1.0f);
+  animation.Play();
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
+
+  Vector3 position, tangent;
+  path.Sample(0.2f, position, tangent );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
+  path.Sample(0.4f, position, tangent );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
+  path.Sample(0.6f, position, tangent );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
+  path.Sample(0.8f, position, tangent );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 100% progress */);
+  path.Sample(1.0f, position, tangent );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* beyond the animation duration*/);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcPathConstrainerApplyRange(void)
+{
+  TestApplication application;
+
+  Dali::Actor actor = Dali::Actor::New();
+
+  // Register a float property
+  Property::Index index = actor.RegisterProperty( "t", 0.0f );
+  Dali::Stage::GetCurrent().Add(actor);
+
+  //Create a Path
+  Dali::Path path = Dali::Path::New();
+  SetupPath(path);
+
+  //Create a PathConstrainer
+  Dali::PathConstrainer pathConstrainer = Dali::PathConstrainer::New();
+  SetupPathConstrainer( pathConstrainer );
+
+  //Apply the path constraint to the actor's position. The source property for the constraint will be the custom property "t"
+  Vector2 range( 100.0f, 300.0f );
+  pathConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION), Property(actor,index), range );
+
+
+  //Create an animation to animate the custom property
+  float durationSeconds(1.0f);
+  Dali::Animation animation = Dali::Animation::New(durationSeconds);
+  animation.AnimateTo(Dali::Property(actor,index),400.0f);
+  animation.Play();
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+
+
+  Vector3 position, tangent;
+  float tValue;
+  actor.GetProperty(index).Get(tValue);
+  float currentCursor =  ( tValue - range.x ) / (range.y-range.x);
+  path.Sample(currentCursor, position, tangent );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+  actor.GetProperty(index).Get(tValue);
+  currentCursor =  ( tValue - range.x ) / (range.y-range.x);
+  path.Sample(currentCursor, position, tangent );
+  path.Sample(0.5, position, tangent );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+  actor.GetProperty(index).Get(tValue);
+  currentCursor =  ( tValue - range.x ) / (range.y-range.x);
+  path.Sample(currentCursor, position, tangent );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 100% progress */);
+  actor.GetProperty(index).Get(tValue);
+  currentCursor =  ( tValue - range.x ) / (range.y-range.x);
+  path.Sample(currentCursor, position, tangent );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* beyond the animation duration*/);
+  actor.GetProperty(index).Get(tValue);
+  currentCursor =  ( tValue - range.x ) / (range.y-range.x);
+  path.Sample(currentCursor, position, tangent );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcPathConstrainerDestroy(void)
+{
+  TestApplication application;
+
+  Dali::Actor actor = Dali::Actor::New();
+
+  // Register a float property
+  Property::Index index = actor.RegisterProperty( "t", 0.0f );
+  Dali::Stage::GetCurrent().Add(actor);
+
+  {
+    //Create a Path
+    Dali::Path path = Dali::Path::New();
+    SetupPath(path);
+
+    //Create a PathConstrainer
+    Dali::PathConstrainer pathConstrainer = Dali::PathConstrainer::New();
+    SetupPathConstrainer( pathConstrainer );
+
+    //Apply the path constraint to the actor's position. The source property for the constraint will be the custom property "t"
+    Vector2 range( 0.0f, 1.0f );
+    pathConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION), Property(actor,index), range );
+
+    //Test that the constraint is correctly applied
+    actor.SetProperty(index,0.5f);
+    application.SendNotification();
+    application.Render(static_cast<unsigned int>(1.0f));
+
+    Vector3 position, tangent;
+    path.Sample(0.5f, position, tangent );
+    DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
+
+  }
+
+  //PathConstrainer has been destroyed. Constraint in the actor should have been removed
+  actor.SetProperty(index,0.75f);
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(1.0f));
+
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcPathConstrainerRemove(void)
+{
+  TestApplication application;
+
+  Dali::Actor actor = Dali::Actor::New();
+
+  // Register a float property
+  Property::Index index = actor.RegisterProperty( "t", 0.0f );
+  Dali::Stage::GetCurrent().Add(actor);
+
+  //Create a Path
+  Dali::Path path = Dali::Path::New();
+  SetupPath(path);
+
+  //Create a PathConstrainer
+  Dali::PathConstrainer pathConstrainer = Dali::PathConstrainer::New();
+  SetupPathConstrainer( pathConstrainer );
+
+  //Apply the path constraint to the actor's position. The source property for the constraint will be the custom property "t"
+  Vector2 range( 0.0f, 1.0f );
+  pathConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION), Property(actor,index), range );
+
+  //Test that the constraint is correctly applied
+  actor.SetProperty(index,0.5f);
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(1.0f));
+
+  Vector3 position, tangent;
+  path.Sample(0.5f, position, tangent );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
+
+  //Remove constraint
+  pathConstrainer.Remove( actor );
+  actor.SetProperty(index,0.75f);
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(1.0f));
+
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
+
+  END_TEST;
+}
+
+//LinearConstrainer test cases
+int UtcLinearConstrainerDownCast(void)
+{
+  TestApplication application;
+  Dali::LinearConstrainer linearConstrainer = Dali::LinearConstrainer::New();
+
+  BaseHandle handle( linearConstrainer );
+  Dali::LinearConstrainer linearConstrainer2 = Dali::LinearConstrainer::DownCast( handle );
+  DALI_TEST_EQUALS( (bool)linearConstrainer2, true, TEST_LOCATION );
+
+  BaseHandle handle2;
+  Dali:: LinearConstrainer linearConstrainer3 = Dali::LinearConstrainer::DownCast( handle2 );
+  DALI_TEST_EQUALS( (bool)linearConstrainer3, false, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcLinearConstrainerCopyConstructor(void)
+{
+  TestApplication application;
+  Dali::LinearConstrainer linearConstrainer;
+  DALI_TEST_EQUALS( (bool)linearConstrainer, false, TEST_LOCATION );
+
+  linearConstrainer = Dali::LinearConstrainer::New();
+  DALI_TEST_EQUALS( (bool)linearConstrainer, true, TEST_LOCATION );
+
+  // call the copy constructor
+  Dali::LinearConstrainer linearConstrainer2( linearConstrainer );
+  DALI_TEST_EQUALS( (bool)linearConstrainer2, true, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcLinearConstrainerApply(void)
+{
+  TestApplication application;
+
+  Dali::Actor actor = Dali::Actor::New();
+
+  // Register a float property
+  Property::Index index = actor.RegisterProperty( "t", 0.0f );
+
+  Dali::Stage::GetCurrent().Add(actor);
+
+
+  //Create a LinearConstrainer without specifying progress for values
+  Dali::LinearConstrainer linearConstrainer = Dali::LinearConstrainer::New();
+  SetupLinearConstrainerUniformProgress( linearConstrainer );
+
+  //Apply the linear constraint to the actor's position. The source property for the constraint will be the custom property "t"
+  Vector2 range( 0.0f, 1.0f );
+  linearConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION_X), Property(actor,index), range );
+
+  //Create an animation to animate the custom property
+  float durationSeconds(1.0f);
+  Dali::Animation animation = Dali::Animation::New(durationSeconds);
+  animation.AnimateTo(Dali::Property(actor,index),1.0f);
+  animation.Play();
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+
+  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.5f, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 1.0f, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.5f, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 100% progress */);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.0f, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* beyond the animation duration*/);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.0f, TEST_LOCATION );
+
+  //Setup a LinearConstrainer specifying the progress for each value
+  linearConstrainer.Remove(actor);
+  SetupLinearConstrainerNonUniformProgress( linearConstrainer );
+  linearConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION_X), Property(actor,index), range );
+
+  actor.SetProperty(index,0.0f);
+  animation.Play();
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+
+  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 1.0f, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 2.0f/3.0f, Math::MACHINE_EPSILON_1, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 1.0f/3.0f, Math::MACHINE_EPSILON_1, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 100% progress */);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.0f, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* beyond the animation duration*/);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.0f, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcLinearConstrainerApplyRange(void)
+{
+  TestApplication application;
+
+  Dali::Actor actor = Dali::Actor::New();
+
+  // Register a float property
+  Property::Index index = actor.RegisterProperty( "t", 100.0f );
+  Dali::Stage::GetCurrent().Add(actor);
+
+  //Create a LinearConstrainer
+  Dali::LinearConstrainer linearConstrainer = Dali::LinearConstrainer::New();
+  SetupLinearConstrainerUniformProgress( linearConstrainer );
+
+  //Apply the linear constraint to the actor's position. The source property for the constraint will be the custom property "t"
+  Vector2 range( 100.0f, 300.0f );
+  linearConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION_X), Property(actor,index), range );
+
+
+  //Create an animation to animate the custom property
+  float durationSeconds(1.0f);
+  Dali::Animation animation = Dali::Animation::New(durationSeconds);
+  animation.AnimateTo(Dali::Property(actor,index),300.0f);
+  animation.Play();
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+
+  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.5f, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 1.0f, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.5f, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 100% progress */);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.0f, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* beyond the animation duration*/);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.0f, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcLinearConstrainerDestroy(void)
+{
+  TestApplication application;
+
+  Dali::Actor actor = Dali::Actor::New();
+
+  // Register a float property
+  Property::Index index = actor.RegisterProperty( "t", 0.0f );
+  Dali::Stage::GetCurrent().Add(actor);
+
+  {
+    //Create a LinearConstrainer
+    Dali::LinearConstrainer linearConstrainer = Dali::LinearConstrainer::New();
+    SetupLinearConstrainerUniformProgress( linearConstrainer );
+
+    //Apply the linear constraint to the actor's position. The source property for the constraint will be the custom property "t"
+    Vector2 range( 0.0f, 1.0f );
+    linearConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION_X), Property(actor,index), range );
+
+    //Test that the constraint is correctly applied
+    actor.SetProperty(index,0.5f);
+    application.SendNotification();
+    application.Render(static_cast<unsigned int>(1.0f));
+
+    DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 1.0f, TEST_LOCATION );
+
+  }
+
+  //LinearConstrainer has been destroyed. Constraint in the actor should have been removed
+  actor.SetProperty(index,0.75f);
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(1.0f));
+
+  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.0f, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcLinearConstrainerRemove(void)
+{
+  TestApplication application;
+
+  Dali::Actor actor = Dali::Actor::New();
+
+  // Register a float property
+  Property::Index index = actor.RegisterProperty( "t", 0.0f );
+  Dali::Stage::GetCurrent().Add(actor);
+
+  //Create a LinearConstrainer
+  Dali::LinearConstrainer linearConstrainer = Dali::LinearConstrainer::New();
+  SetupLinearConstrainerUniformProgress( linearConstrainer );
+
+  //Apply the path constraint to the actor's position. The source property for the constraint will be the custom property "t"
+  Vector2 range( 0.0f, 1.0f );
+  linearConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION_X), Property(actor,index), range );
+
+  //Test that the constraint is correctly applied
+  actor.SetProperty(index,0.5f);
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(1.0f));
+
+  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 1.0f, TEST_LOCATION );
+
+  //Remove constraint
+  linearConstrainer.Remove( actor );
+  actor.SetProperty(index,0.75f);
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(1.0f));
+
+  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.0f, TEST_LOCATION );
+
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-internal/utc-Dali-Context.cpp b/automated-tests/src/dali-internal/utc-Dali-Context.cpp
new file mode 100644 (file)
index 0000000..54d35a6
--- /dev/null
@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+
+#include <stdlib.h>
+#include <dali/public-api/dali-core.h>
+#include <dali/devel-api/actors/mesh-actor.h>
+#include <dali-test-suite-utils.h>
+
+using namespace Dali;
+
+#include "mesh-builder.h"
+
+
+namespace
+{
+// Size of the VertexAttributeArray enables
+// GLES specification states that there's minimum of
+const unsigned int TEST_MAX_ATTRIBUTE_CACHE_SIZE = 8;
+
+enum TestAttribType
+{
+  ATTRIB_UNKNOWN = -1,
+  ATTRIB_POSITION,
+  ATTRIB_NORMAL,
+  ATTRIB_TEXCOORD,
+  ATTRIB_COLOR,
+  ATTRIB_BONE_WEIGHTS,
+  ATTRIB_BONE_INDICES,
+  ATTRIB_TYPE_LAST
+};
+
+// Create bitmap image
+static BufferImage CreateBufferImage()
+{
+  BufferImage image = BufferImage::New(4,4,Pixel::RGBA8888);
+
+  return image;
+}
+
+static MeshActor CreateMeshActor()
+{
+  MeshData meshData;
+  MeshData::VertexContainer    vertices;
+  MeshData::FaceIndices        faces;
+  BoneContainer                bones;
+  ConstructVertices(vertices, 60);
+  ConstructFaces(vertices, faces);
+  Material customMaterial = ConstructMaterial();
+  meshData.SetData(vertices, faces, bones, customMaterial);
+  meshData.SetHasNormals(true);
+  meshData.SetHasTextureCoords(true);
+
+  Mesh mesh = Mesh::New(meshData);
+  MeshActor actor = MeshActor::New(mesh);
+
+  actor.SetName("Test MeshActor");
+
+  return actor;
+}
+
+
+static ImageActor CreateImageActor()
+{
+  BufferImage image = CreateBufferImage();
+  ImageActor actor = ImageActor::New( image );
+  actor.SetSize( 100.0f, 100.0f );
+  actor.SetName("Test ImageActor");
+  return actor;
+}
+
+} // anonymous namespace
+
+
+// Positive test case for a method
+int UtcDaliContextVertexAttribStartup(void)
+{
+  tet_infoline("Testing vertex attrib initial state in context");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  // context class should initially set the vertex attrib locations to disable
+  // Make sure it has been modified
+  DALI_TEST_CHECK(application.GetGlAbstraction().GetVertexAttribArrayChanged());
+
+  // check the locations
+  for (unsigned int i = 0; i < TEST_MAX_ATTRIBUTE_CACHE_SIZE; i++)
+  {
+    DALI_TEST_CHECK( application.GetGlAbstraction().GetVertexAttribArrayState(i) == false);
+  }
+
+  tet_result(TET_PASS);
+  END_TEST;
+}
+
+// Tests to make the attribs only get set once when continually rendering an image actor
+int UtcDaliContextVertexAttribImageRendering(void)
+{
+  tet_infoline("Testing vertex attrib rendering state in context with images");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  // the vertex attribs get modified on startup to set them to disabled
+  // clear the flag to say they've changed
+  application.GetGlAbstraction().ClearVertexAttribArrayChanged();
+
+
+  // create a test image actor
+  ImageActor imageActor(CreateImageActor());
+  Stage::GetCurrent().Add(imageActor);
+
+
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  // check to make sure the state has changed (the image renderer will enable some
+  // locations).
+  DALI_TEST_CHECK(application.GetGlAbstraction().GetVertexAttribArrayChanged());
+
+  // Now check to make sure the state is cached, and isn't being set each frame.
+  application.GetGlAbstraction().ClearVertexAttribArrayChanged();
+
+  application.Render();
+  application.Render();
+  application.Render();
+
+  // if it has changed then the caching has failed
+  DALI_TEST_CHECK(application.GetGlAbstraction().GetVertexAttribArrayChanged() == false);
+
+
+  tet_result(TET_PASS);
+  END_TEST;
+}
+
+// test to make sure the attribs change when rendering both image and mode actors
+int UtcDaliContextVertexAttribImageAndModelRendering(void)
+{
+  tet_infoline("Testing vertex attrib rendering state in context with images and models");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  // the vertex attribs get modified on startup to set them to disabled
+  // clear the flag to say they've changed
+  application.GetGlAbstraction().ClearVertexAttribArrayChanged();
+
+  // create a test image and mesh actor.
+
+  MeshActor meshActor(CreateMeshActor());
+  Stage::GetCurrent().Add(meshActor);
+
+  ImageActor imageActor(CreateImageActor());
+  Stage::GetCurrent().Add(imageActor);
+
+
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  // check to make sure the state changes during the rendering of a frame
+  DALI_TEST_CHECK(application.GetGlAbstraction().GetVertexAttribArrayChanged());
+
+  // Now check to make sure the state is changing each frame.
+  application.GetGlAbstraction().ClearVertexAttribArrayChanged();
+
+  application.Render();
+  application.Render();
+  application.Render();
+
+  // make sure the state has changed
+  DALI_TEST_CHECK(application.GetGlAbstraction().GetVertexAttribArrayChanged());
+
+  // depending on the order of drawing, one of the attrib locations should be disabled
+  // Image uses locations 0 & 2  (position, texture)
+  // Model uses locations 0 & 1  (position, normals) -no textures
+  // so either location 1 or location 2 should be disabled after drawing.
+
+  // see if mesh was last to draw
+  if (application.GetGlAbstraction().GetVertexAttribArrayState(ATTRIB_NORMAL))
+  {
+    // texture should be disabled
+    DALI_TEST_CHECK( application.GetGlAbstraction().GetVertexAttribArrayState(ATTRIB_TEXCOORD) == false)
+  }
+  else
+  {
+    // image was to draw so, normals should be disabled
+    DALI_TEST_CHECK( application.GetGlAbstraction().GetVertexAttribArrayState(ATTRIB_NORMAL) == false)
+  }
+
+  tet_result(TET_PASS);
+
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-internal/utc-Dali-DistanceField.cpp b/automated-tests/src/dali-internal/utc-Dali-DistanceField.cpp
new file mode 100644 (file)
index 0000000..b9ab2da
--- /dev/null
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+#include <algorithm>
+
+#include <stdlib.h>
+
+#include <dali/public-api/dali-core.h>
+#include <dali/devel-api/images/distance-field.h>
+#include <dali-test-suite-utils.h>
+
+using std::max;
+using namespace Dali;
+
+namespace
+{
+
+static const float ROTATION_EPSILON = 0.0001f;
+
+static unsigned char sourceImage[] =
+{
+ 0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,
+ 0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,
+ 0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,
+ 0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+ 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
+};
+
+} // anonymous namespace
+
+
+
+int UtcDaliGenerateDistanceField(void)
+{
+  unsigned char distanceField[4*4];
+
+  GenerateDistanceFieldMap(sourceImage, Size(8.0f, 8.0f), distanceField, Size(4.0f, 4.0f), 0, Size(4.0f, 4.0f));
+
+  if(distanceField[0]  <= distanceField[5] &&
+     distanceField[5]  <= distanceField[10] &&
+     distanceField[10] <= distanceField[15])
+  {
+    tet_result(TET_PASS);
+  }
+  else
+  {
+    tet_result(TET_FAIL);
+  }
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-internal/utc-Dali-DynamicsBody.cpp b/automated-tests/src/dali-internal/utc-Dali-DynamicsBody.cpp
new file mode 100644 (file)
index 0000000..3c09a8d
--- /dev/null
@@ -0,0 +1,605 @@
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+#include <stdlib.h>
+#include <dali/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
+#include <dali/devel-api/dynamics/dynamics.h>
+
+int UtcDaliDynamicsBodyConstructor(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsBodyConstructor - DynamicsBody::DynamicsBody()");
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  // Default constructor - create an uninitialized handle
+  DynamicsBody body;
+  DALI_TEST_CHECK( !body );
+
+  // create world and actor
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  Actor actor(Actor::New());
+
+  // enable dynamics on the actor to create the Dynamicsbody
+  actor.EnableDynamics(bodyConfig);
+
+  // initialize handle
+  body = actor.GetDynamicsBody();
+
+  DALI_TEST_CHECK( body );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyGetMass(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  const float testMass = 1.23f;
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  bodyConfig.SetMass(testMass);
+  Actor actor(Actor::New());
+
+  // enable dynamics on the actor to create the Dynamicsbody
+  actor.EnableDynamics(bodyConfig);
+
+  tet_infoline("UtcDaliDynamicsBodyGetMass - DynamicsBody::GetMass");
+  DALI_TEST_EQUALS( testMass, actor.GetDynamicsBody().GetMass(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyGetElasticity(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  const float testElasticity = 1.23f;
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  bodyConfig.SetElasticity(testElasticity);
+  Actor actor(Actor::New());
+
+  // enable dynamics on the actor to create the Dynamicsbody
+  actor.EnableDynamics(bodyConfig);
+
+  tet_infoline("UtcDaliDynamicsBodyGetMass - DynamicsBody::GetElasticity");
+  DALI_TEST_EQUALS( testElasticity, actor.GetDynamicsBody().GetElasticity(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodySetLinearVelocity(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsBodySetLinearVelocity - DynamicsBody::SetLinearVelocity");
+
+  TestApplication application;
+  TraceCallStack& trace( application.GetPlatform().GetTrace() );
+  trace.Enable( true );
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  Actor actor(Actor::New());
+
+  // enable dynamics on the actor to create the Dynamicsbody
+  actor.EnableDynamics(bodyConfig);
+
+  DynamicsBody body(actor.GetDynamicsBody());
+  body.SetLinearVelocity(Vector3::ONE);
+
+  DALI_TEST_CHECK( ! trace.FindMethod( "DynamicsBody::SetLinearVelocity" ) );
+
+  // update
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DALI_TEST_CHECK( trace.FindMethod( "DynamicsBody::SetLinearVelocity" ) );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodySetAngularVelocity(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsBodySetAngularVelocity - DynamicsBody::SetAngularVelocity");
+
+  TestApplication application;
+  TraceCallStack& trace( application.GetPlatform().GetTrace() );
+  trace.Enable( true );
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  Actor actor(Actor::New());
+
+  // enable dynamics on the actor to create the Dynamicsbody
+  actor.EnableDynamics(bodyConfig);
+
+  DynamicsBody body(actor.GetDynamicsBody());
+  body.SetAngularVelocity(Vector3::ONE);
+
+  DALI_TEST_CHECK( ! trace.FindMethod( "DynamicsBody::SetAngularVelocity" ) );
+
+  // update
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DALI_TEST_CHECK( trace.FindMethod( "DynamicsBody::SetAngularVelocity" ) );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodySetKinematic(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  const float testMass = 1.0f;
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  bodyConfig.SetMass(testMass);
+  Actor actor(Actor::New());
+
+  // enable dynamics on the actor to create the Dynamicsbody
+  actor.EnableDynamics(bodyConfig);
+
+  DynamicsBody body(actor.GetDynamicsBody());
+
+  DALI_TEST_EQUALS( testMass, body.GetMass(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  tet_infoline("UtcDaliDynamicsBodySetKinematic - DynamicsBody::SetKinematic(true)");
+  body.SetKinematic(true);
+
+  DALI_TEST_CHECK( body.IsKinematic() );
+  DALI_TEST_EQUALS( 0.0f, body.GetMass(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  tet_infoline("UtcDaliDynamicsBodySetKinematic - DynamicsBody::SetKinematic(false)");
+  body.SetKinematic(false);
+  DALI_TEST_CHECK( !body.IsKinematic() );
+  DALI_TEST_EQUALS( testMass, body.GetMass(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyIsKinematic(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  const float testMass = 1.0f;
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  bodyConfig.SetMass(testMass);
+  Actor actor(Actor::New());
+
+  // enable dynamics on the actor to create the Dynamicsbody
+  actor.EnableDynamics(bodyConfig);
+
+  DynamicsBody body(actor.GetDynamicsBody());
+
+  DALI_TEST_EQUALS( testMass, body.GetMass(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  tet_infoline("UtcDaliDynamicsBodySetKinematic - DynamicsBody::IsSetKinematic");
+  body.SetKinematic(true);
+
+  DALI_TEST_CHECK( body.IsKinematic() );
+  body.SetKinematic(false);
+  DALI_TEST_CHECK( !body.IsKinematic() );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodySetSleepEnabled(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsBodySetSleepEnabled");
+
+  TestApplication application;
+  TraceCallStack& trace( application.GetPlatform().GetTrace() );
+  trace.Enable( true );
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  Actor actor(Actor::New());
+
+  // enable dynamics on the actor to create the Dynamicsbody
+  actor.EnableDynamics(bodyConfig);
+
+  DynamicsBody body(actor.GetDynamicsBody());
+
+  // SleepEnabled true by default
+  DALI_TEST_CHECK( body.GetSleepEnabled() );
+  body.SetSleepEnabled(false);
+
+  DALI_TEST_CHECK( ! trace.FindMethod( "DynamicsBody::SetSleepEnabled" ) );
+
+  // update
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DALI_TEST_CHECK( trace.FindMethod( "DynamicsBody::SetSleepEnabled" ) );
+
+  DALI_TEST_CHECK( ! body.GetSleepEnabled() );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyGetSleepEnabled(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsBodyGetSleepEnabled");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  Actor actor(Actor::New());
+
+  // enable dynamics on the actor to create the Dynamicsbody
+  actor.EnableDynamics(bodyConfig);
+
+  DynamicsBody body(actor.GetDynamicsBody());
+
+  // SleepEnabled true by default
+  DALI_TEST_CHECK( body.GetSleepEnabled() );
+  body.SetSleepEnabled(false);
+  DALI_TEST_CHECK( !body.GetSleepEnabled() );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyWakeUp(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsBodyWakeUp");
+
+  TestApplication application;
+  TraceCallStack& trace( application.GetPlatform().GetTrace() );
+  trace.Enable( true );
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  Actor actor(Actor::New());
+
+  // enable dynamics on the actor to create the Dynamicsbody
+  actor.EnableDynamics(bodyConfig);
+
+  DynamicsBody body(actor.GetDynamicsBody());
+
+  body.WakeUp();
+
+  DALI_TEST_CHECK( ! trace.FindMethod( "DynamicsBody::WakeUp" ) );
+
+  // update
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DALI_TEST_CHECK( trace.FindMethod( "DynamicsBody::WakeUp" ) );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyAddAnchor(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsBodyAddAnchor - DynamicsBody::AddAnchor()");
+
+  TestApplication application;
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  worldConfig.SetType(DynamicsWorldConfig::SOFT);
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  Actor rootActor(Actor::New());
+  world.SetRootActor(rootActor);
+  Stage::GetCurrent().Add(rootActor);
+
+  DynamicsBodyConfig softConfig( DynamicsBodyConfig::New() );
+  softConfig.SetType(DynamicsBodyConfig::SOFT);
+  Cloth mesh(Cloth::New(10.0f, 10.0f, 10, 10));
+  DynamicsShape meshShape(DynamicsShape::NewMesh(mesh));
+  softConfig.SetShape( meshShape );
+  softConfig.SetMass(1.0f);
+  MeshActor softActor(MeshActor::New(mesh));
+
+  rootActor.Add(softActor);
+  softActor.EnableDynamics(softConfig);
+  DynamicsBody softBody(softActor.GetDynamicsBody());
+
+  DynamicsBodyConfig anchorConfig(DynamicsBodyConfig::New());
+  anchorConfig.SetMass(0.0f);
+  Actor anchor(Actor::New());
+  rootActor.Add(anchor);
+  anchor.EnableDynamics(anchorConfig);
+  DynamicsBody anchorBody(anchor.GetDynamicsBody());
+  anchorBody.SetKinematic(true);
+  try
+  {
+    softBody.AddAnchor(0, anchorBody, false);
+
+    DALI_TEST_CHECK(true)
+  }
+  catch(Dali::DaliException& e)
+  {
+    DALI_TEST_PRINT_ASSERT( e );
+    DALI_TEST_CHECK( false );
+  }
+
+  rootActor.Remove(softActor);
+  rootActor.Remove(anchor);
+  Stage::GetCurrent().Remove(rootActor);
+  softActor.DisableDynamics();
+  anchor.DisableDynamics();
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConserveVolume(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsBodyConserveVolume");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  Actor actor(Actor::New());
+
+  // enable dynamics on the actor to create the Dynamicsbody
+  actor.EnableDynamics(bodyConfig);
+
+  DynamicsBody body(actor.GetDynamicsBody());
+
+  body.ConserveVolume(false);
+  DALI_TEST_CHECK( true );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConserveShape(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsBodyConserveShape");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  Actor actor(Actor::New());
+
+  // enable dynamics on the actor to create the Dynamicsbody
+  actor.EnableDynamics(bodyConfig);
+
+  DynamicsBody body(actor.GetDynamicsBody());
+
+  body.ConserveShape(false);
+  DALI_TEST_CHECK( true );
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-internal/utc-Dali-DynamicsBodyConfig.cpp b/automated-tests/src/dali-internal/utc-Dali-DynamicsBodyConfig.cpp
new file mode 100644 (file)
index 0000000..30ae434
--- /dev/null
@@ -0,0 +1,679 @@
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+
+#include <stdlib.h>
+#include <dali/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
+#include <dali/devel-api/dynamics/dynamics.h>
+
+using namespace Dali;
+
+
+int UtcDaliDynamicsBodyConfigNew(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+
+  tet_infoline("UtcDaliDynamicsBodyConfigNew - DynamicsBodyConfig::New()");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig config(DynamicsBodyConfig::New());
+
+  DALI_TEST_CHECK( config );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConfigConstructor(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsBodyConfigConstructor - DynamicsBodyConfig::DynamicsBodyConfig()");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  // Default constructor - create an uninitialized handle
+  DynamicsBodyConfig config;
+
+  DALI_TEST_CHECK( !config );
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  // initialize handle
+  config = DynamicsBodyConfig::New();
+
+  DALI_TEST_CHECK( config );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConfigType(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig config(DynamicsBodyConfig::New());
+
+  tet_infoline("UtcDaliDynamicsBodyConfigType - DynamicsBodyConfig::GetType");
+  DALI_TEST_CHECK( DynamicsBodyConfig::RIGID == config.GetType() );
+
+  tet_infoline("UtcDaliDynamicsBodyConfigType - DynamicsBodyConfig::SetType(const BodyType)");
+  config.SetType( DynamicsBodyConfig::SOFT );
+  DALI_TEST_CHECK( DynamicsBodyConfig::SOFT == config.GetType() );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConfigSetShape01(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsBodyConfigSetShape01 - DynamicsBodyConfig::SetShape(const DynamicsShape::ShapeType,const Vector3&)");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig config(DynamicsBodyConfig::New());
+
+  DALI_TEST_CHECK( DynamicsShape::CUBE == config.GetShape().GetType() );
+
+  const float radius(1.5f);
+  config.SetShape(DynamicsShape::SPHERE, Vector3(radius, 0.0f, 0.0f));
+
+  DALI_TEST_CHECK( DynamicsShape::SPHERE == config.GetShape().GetType() );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConfigSetShape02(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsBodyConfigSetShape02 - DynamicsBodyConfig::SetShape(DynamicsShape)");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig config(DynamicsBodyConfig::New());
+
+  DALI_TEST_CHECK( DynamicsShape::CUBE == config.GetShape().GetType() );
+
+  const float radius(1.5f);
+  DynamicsShape shape(DynamicsShape::NewSphere(radius));
+  config.SetShape(shape);
+
+  DALI_TEST_CHECK( DynamicsShape::SPHERE == config.GetShape().GetType() );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConfigGetShape(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsBodyConfigGetShape - DynamicsBodyConfig::GetShape");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig config(DynamicsBodyConfig::New());
+
+  DALI_TEST_CHECK( DynamicsShape::CUBE == config.GetShape().GetType() );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConfigMass(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  const float testMass = 1.23f;
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig config(DynamicsBodyConfig::New());
+  config.SetMass(testMass);
+
+  tet_infoline("UtcDaliDynamicsBodyConfigMass - DynamicsBodyConfig::GetMass");
+  DALI_TEST_EQUALS( testMass, config.GetMass(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  tet_infoline("UtcDaliDynamicsBodyConfigMass - DynamicsBodyConfig::SetMass");
+  const float mass = config.GetMass() + 0.1f;
+  config.SetMass(mass);
+  DALI_TEST_EQUALS( mass, config.GetMass(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConfigElasticity(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  const float testElasticity = 0.87f;
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig config(DynamicsBodyConfig::New());
+  config.SetElasticity(testElasticity);
+
+  tet_infoline("UtcDaliDynamicsBodyConfigElasticity- DynamicsBodyConfig::GetElasticity");
+  DALI_TEST_EQUALS( testElasticity, config.GetElasticity(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  tet_infoline("UtcDaliDynamicsBodyConfigElasticity - DynamicsBodyConfig::SetElasticity");
+  const float elasticity = config.GetElasticity() + 0.1f;
+  config.SetElasticity(elasticity);
+  DALI_TEST_EQUALS( elasticity, config.GetElasticity(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConfigFriction(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  const float testFriction= 0.87f;
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig config(DynamicsBodyConfig::New());
+  config.SetFriction(testFriction);
+
+  tet_infoline("UtcDaliDynamicsBodyConfigFriction - DynamicsBodyConfig::GetFriction");
+  DALI_TEST_EQUALS( testFriction, config.GetFriction(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  tet_infoline("UtcDaliDynamicsBodyConfigFriction - DynamicsBodyConfig::SetFriction");
+  const float friction = config.GetFriction() + 0.1f;
+  config.SetFriction(friction);
+  DALI_TEST_EQUALS( friction, config.GetFriction(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConfigLinearDamping(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  const float testDamping = 0.123f;
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig config(DynamicsBodyConfig::New());
+  config.SetLinearDamping(testDamping);
+
+  tet_infoline("UtcDaliDynamicsBodyConfigLinearDamping- DynamicsBodyConfig::GetLinearDamping");
+  DALI_TEST_EQUALS( testDamping, config.GetLinearDamping(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  tet_infoline("UtcDaliDynamicsBodyConfigLinearDamping - DynamicsBodyConfig::SetLinearDamping");
+  const float damping = config.GetLinearDamping() + 0.1f;
+  config.SetLinearDamping(damping);
+  DALI_TEST_EQUALS( damping, config.GetLinearDamping(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConfigAngularDamping(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  const float testDamping = 0.123f;
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig config(DynamicsBodyConfig::New());
+  config.SetAngularDamping(testDamping);
+
+  tet_infoline("UtcDaliDynamicsBodyConfigAngularDamping- DynamicsBodyConfig::GetAngularDamping");
+  DALI_TEST_EQUALS( testDamping, config.GetAngularDamping(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  tet_infoline("UtcDaliDynamicsBodyConfigAngularDamping - DynamicsBodyConfig::SetAngularDamping");
+  const float damping = config.GetAngularDamping() + 0.1f;
+  config.SetAngularDamping(damping);
+  DALI_TEST_EQUALS( damping, config.GetAngularDamping(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConfigLinearSleepVelocity(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  const float testSleepVelocity = 0.123f;
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig config(DynamicsBodyConfig::New());
+  config.SetLinearSleepVelocity(testSleepVelocity);
+
+  tet_infoline("UtcDaliDynamicsBodyConfigLinearSleepVelocity - DynamicsBodyConfig::GetLinearSleepVelocity");
+  DALI_TEST_EQUALS( testSleepVelocity, config.GetLinearSleepVelocity(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  tet_infoline("UtcDaliDynamicsBodyConfigLinearSleepVelocity - DynamicsBodyConfig::SetLinearSleepVelocity");
+  const float sleepVelocity = config.GetLinearSleepVelocity() + 0.1f;
+  config.SetLinearSleepVelocity(sleepVelocity);
+  DALI_TEST_EQUALS( sleepVelocity, config.GetLinearSleepVelocity(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConfigAngularSleepVelocity(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  const float testSleepVelocity = 0.123f;
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig config(DynamicsBodyConfig::New());
+  config.SetAngularSleepVelocity(testSleepVelocity);
+
+  tet_infoline("UtcDaliDynamicsBodyConfigAngularSleepVelocity - DynamicsBodyConfig::GetAngularSleepVelocity");
+  DALI_TEST_EQUALS( testSleepVelocity, config.GetAngularSleepVelocity(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  tet_infoline("UtcDaliDynamicsBodyConfigAngularSleepVelocity - DynamicsBodyConfig::SetAngularSleepVelocity");
+  const float sleepVelocity = config.GetAngularSleepVelocity() + 0.1f;
+  config.SetAngularSleepVelocity(sleepVelocity);
+  DALI_TEST_EQUALS( sleepVelocity, config.GetAngularSleepVelocity(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConfigCollisionGroup(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  const short int testGroup = 0x1234;
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig config(DynamicsBodyConfig::New());
+  config.SetCollisionGroup(testGroup);
+
+  tet_infoline("UtcDaliDynamicsBodyConfigCollisionGroup- DynamicsBodyConfig::GetCollisionGroup");
+  DALI_TEST_EQUALS( testGroup, config.GetCollisionGroup(), TEST_LOCATION );
+
+  tet_infoline("UtcDaliDynamicsBodyConfigCollisionGroup - DynamicsBodyConfig::SetCollisionGroup");
+  const short int group = config.GetCollisionGroup() + 1;
+  config.SetCollisionGroup(group);
+  DALI_TEST_EQUALS( group, config.GetCollisionGroup(), TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConfigCollisionMask(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  const short int testMask = 0x7ffe;
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig config(DynamicsBodyConfig::New());
+  config.SetCollisionMask(testMask);
+
+  tet_infoline("UtcDaliDynamicsBodyConfigCollisionMask- DynamicsBodyConfig::GetCollisionMask");
+  DALI_TEST_EQUALS( testMask, config.GetCollisionMask(), TEST_LOCATION );
+
+  tet_infoline("UtcDaliDynamicsBodyConfigCollisionMask - DynamicsBodyConfig::SetCollisionMask");
+  const short int mask = config.GetCollisionMask() + 1;
+  config.SetCollisionMask(mask);
+  DALI_TEST_EQUALS( mask, config.GetCollisionMask(), TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConfigAnchorHardness(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  const float testHardness = 0.87f;
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig config(DynamicsBodyConfig::New());
+  config.SetAnchorHardness(testHardness);
+
+  tet_infoline("UtcDaliDynamicsBodyConfigAnchorHardness - DynamicsBodyConfig::GetAnchorHardness");
+  DALI_TEST_EQUALS( testHardness, config.GetAnchorHardness(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  tet_infoline("UtcDaliDynamicsBodyConfigAnchorHardness - DynamicsBodyConfig::SetAnchorHardness");
+  const float hardness = config.GetAnchorHardness() + 0.1f;
+  config.SetAnchorHardness(hardness);
+  DALI_TEST_EQUALS( hardness, config.GetAnchorHardness(), Math::MACHINE_EPSILON_1, TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConfigVolumeConservation(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsBodyConfigVolumeConservation");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig config(DynamicsBodyConfig::New());
+
+  const float conservation = config.GetVolumeConservation() + 0.1f;
+  config.SetVolumeConservation(conservation);
+  DALI_TEST_EQUALS( conservation, config.GetVolumeConservation(), Math::MACHINE_EPSILON_1, TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliDynamicsBodyConfigShapeConservation(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsBodyConfigShapeConservation");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig config(DynamicsBodyConfig::New());
+
+  const float conservation = config.GetShapeConservation() + 0.1f;
+  config.SetShapeConservation(conservation);
+  DALI_TEST_EQUALS( conservation, config.GetShapeConservation(), Math::MACHINE_EPSILON_1, TEST_LOCATION );
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-internal/utc-Dali-DynamicsJoint.cpp b/automated-tests/src/dali-internal/utc-Dali-DynamicsJoint.cpp
new file mode 100644 (file)
index 0000000..854fd87
--- /dev/null
@@ -0,0 +1,378 @@
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+#include <stdlib.h>
+#include <dali/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
+#include <dali/devel-api/dynamics/dynamics.h>
+
+using namespace Dali;
+
+
+int UtcDaliDynamicsJointConstructor(void)
+{
+  tet_infoline("UtcDaliDynamicsJointConstructor - DynamicsJoint::DynamicsJoint");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsJoint joint;
+
+  DALI_TEST_CHECK( !joint );
+  END_TEST;
+}
+
+int UtcDaliDynamicsJointLinearLimit(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  Actor actor1(Actor::New());
+  actor1.EnableDynamics(bodyConfig);
+  Actor actor2(Actor::New());
+  actor2.EnableDynamics(bodyConfig);
+
+  DynamicsJoint joint( actor1.AddDynamicsJoint(actor2, Vector3() ) );
+
+  if( joint )
+  {
+    tet_infoline("UtcDaliDynamicsJointLinearLimit - DynamicsJoint::SetLinearLimit()");
+    joint.SetLinearLimit(DynamicsJoint::LINEAR_X, 0.0f, 1.0f);
+  }
+  DALI_TEST_CHECK( true );
+  END_TEST;
+}
+
+int UtcDaliDynamicsJointAngularLimit(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  Actor actor1(Actor::New());
+  actor1.EnableDynamics(bodyConfig);
+  Actor actor2(Actor::New());
+  actor2.EnableDynamics(bodyConfig);
+
+  DynamicsJoint joint( actor1.AddDynamicsJoint(actor2, Vector3() ) );
+
+  tet_infoline("UtcDaliDynamicsJointAngularLimit - DynamicsJoint::SetAngularLimit()");
+  joint.SetAngularLimit(DynamicsJoint::ANGULAR_X, Degree(0.0f), Degree(1.0f) );
+  DALI_TEST_CHECK( true );
+  END_TEST;
+}
+
+int UtcDaliDynamicsJointEnableSpring(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  Actor actor1(Actor::New());
+  actor1.EnableDynamics(bodyConfig);
+  Actor actor2(Actor::New());
+  actor2.EnableDynamics(bodyConfig);
+
+  DynamicsJoint joint( actor1.AddDynamicsJoint(actor2, Vector3() ) );
+
+  tet_infoline("UtcDaliDynamicsJointEnableSpring");
+  joint.EnableSpring(DynamicsJoint::LINEAR_X, true );
+  DALI_TEST_CHECK( true );
+  END_TEST;
+}
+
+int UtcDaliDynamicsJointSetSpringStiffness(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  Actor actor1(Actor::New());
+  actor1.EnableDynamics(bodyConfig);
+  Actor actor2(Actor::New());
+  actor2.EnableDynamics(bodyConfig);
+
+  DynamicsJoint joint( actor1.AddDynamicsJoint(actor2, Vector3() ) );
+
+  tet_infoline("UtcDaliDynamicsJointSetSpringStiffness");
+  joint.SetSpringStiffness(DynamicsJoint::LINEAR_X, 1.0f );
+  DALI_TEST_CHECK( true );
+  END_TEST;
+}
+
+int UtcDaliDynamicsJointSetSpringCenterPoint(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  Actor actor1(Actor::New());
+  actor1.EnableDynamics(bodyConfig);
+  Actor actor2(Actor::New());
+  actor2.EnableDynamics(bodyConfig);
+
+  DynamicsJoint joint( actor1.AddDynamicsJoint(actor2, Vector3() ) );
+
+  tet_infoline("UtcDaliDynamicsJointSetSpringCenterPoint");
+  joint.SetSpringCenterPoint(DynamicsJoint::LINEAR_X, 0.5f );
+  DALI_TEST_CHECK( true );
+  END_TEST;
+}
+
+int UtcDaliDynamicsJointEnableMotor(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  Actor actor1(Actor::New());
+  actor1.EnableDynamics(bodyConfig);
+  Actor actor2(Actor::New());
+  actor2.EnableDynamics(bodyConfig);
+
+  DynamicsJoint joint( actor1.AddDynamicsJoint(actor2, Vector3() ) );
+
+  tet_infoline("UtcDaliDynamicsJointEnableMotor");
+  joint.EnableMotor(DynamicsJoint::LINEAR_X, true );
+  DALI_TEST_CHECK( true );
+  END_TEST;
+}
+
+int UtcDaliDynamicsJointSetMotorVelocity(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  Actor actor1(Actor::New());
+  actor1.EnableDynamics(bodyConfig);
+  Actor actor2(Actor::New());
+  actor2.EnableDynamics(bodyConfig);
+
+  DynamicsJoint joint( actor1.AddDynamicsJoint(actor2, Vector3() ) );
+
+  tet_infoline("UtcDaliDynamicsJointSetMotorVelocity");
+  joint.SetMotorVelocity(DynamicsJoint::LINEAR_X, 1.0f );
+  DALI_TEST_CHECK( true );
+  END_TEST;
+}
+
+int UtcDaliDynamicsJointSetMotorForce(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  Actor actor1(Actor::New());
+  actor1.EnableDynamics(bodyConfig);
+  Actor actor2(Actor::New());
+  actor2.EnableDynamics(bodyConfig);
+
+  DynamicsJoint joint( actor1.AddDynamicsJoint(actor2, Vector3() ) );
+
+  tet_infoline("UtcDaliDynamicsJointSetMotorForce");
+  joint.SetMotorForce(DynamicsJoint::LINEAR_X, 0.5f );
+  DALI_TEST_CHECK( true );
+  END_TEST;
+}
+
+int UtcDaliDynamicsJointGetActor(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
+  Actor actor1(Actor::New());
+  actor1.EnableDynamics(bodyConfig);
+  Actor actor2(Actor::New());
+  actor2.EnableDynamics(bodyConfig);
+
+  DynamicsJoint joint( actor1.AddDynamicsJoint(actor2, Vector3() ) );
+
+  tet_infoline("UtcDaliDynamicsJointGetActor");
+  DALI_TEST_CHECK( joint.GetActor(true) == actor1 && joint.GetActor(false) == actor2 );
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-internal/utc-Dali-DynamicsShape.cpp b/automated-tests/src/dali-internal/utc-Dali-DynamicsShape.cpp
new file mode 100644 (file)
index 0000000..43f723d
--- /dev/null
@@ -0,0 +1,298 @@
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+#include <stdlib.h>
+#include <dali/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
+#include <dali/devel-api/dynamics/dynamics.h>
+
+using namespace Dali;
+
+
+int UtcDaliDynamicsShapeConstructor(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsShapeConstructor - DynamicsShape::DynamicsShape");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( world )
+  {
+
+    // Default constructor - create an uninitialized handle
+    DynamicsShape shape;
+    DALI_TEST_CHECK( !shape );
+
+    // initialize handle
+    shape = DynamicsShape::NewCube(Vector3::ONE);
+
+    DALI_TEST_CHECK( shape );
+  }
+  else
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+  }
+
+  END_TEST;
+}
+
+int UtcDaliDynamicsShapeNewCapsule(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsShapeNewCapsule - DynamicsShape::NewCapsule");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( world )
+  {
+
+    DynamicsShape shape( DynamicsShape::NewCapsule( 1.0f, 2.0f ) );
+
+    DALI_TEST_CHECK( shape );
+    DALI_TEST_CHECK( DynamicsShape::CAPSULE == shape.GetType() );
+  }
+  else
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+  }
+
+  END_TEST;
+}
+
+int UtcDaliDynamicsShapeNewCone(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsShapeNewCone - DynamicsShape::NewCone");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( world )
+  {
+    DynamicsShape shape( DynamicsShape::NewCone( 1.0f, 2.0f ) );
+
+    DALI_TEST_CHECK( shape );
+    DALI_TEST_CHECK( DynamicsShape::CONE == shape.GetType() );
+  }
+  else
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+  }
+
+  END_TEST;
+}
+
+int UtcDaliDynamicsShapeNewCube(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsShapeNewCube - DynamicsShape::NewCube");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( world )
+  {
+    DynamicsShape shape( DynamicsShape::NewCube( Vector3::ONE ) );
+
+    DALI_TEST_CHECK( shape );
+    DALI_TEST_CHECK( DynamicsShape::CUBE == shape.GetType() );
+  }
+  else
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+  }
+  END_TEST;
+}
+
+int UtcDaliDynamicsShapeNewCylinder(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsShapeNewCylinder - DynamicsShape::NewCylinder");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( world )
+  {
+    DynamicsShape shape( DynamicsShape::NewCylinder( 1.0f, 2.0f ) );
+
+    DALI_TEST_CHECK( shape );
+    DALI_TEST_CHECK( DynamicsShape::CYLINDER == shape.GetType() );
+  }
+  else
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+  }
+  END_TEST;
+}
+
+int UtcDaliDynamicsShapeNewMesh(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsShapeNewMesh - DynamicsShape::NewMesh");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( world )
+  {
+    DynamicsShape shape( DynamicsShape::NewMesh( Cloth::New(10.0f, 10.0f, 10, 10)) );
+
+    DALI_TEST_CHECK( shape );
+    DALI_TEST_CHECK( DynamicsShape::MESH == shape.GetType() );
+  }
+  else
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+  }
+  END_TEST;
+}
+
+int UtcDaliDynamicsShapeNewSphere(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsShapeNewSphere - DynamicsShape::NewSphere");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( world )
+  {
+    DynamicsShape shape( DynamicsShape::NewSphere( 1.0f ) );
+
+    DALI_TEST_CHECK( shape );
+    DALI_TEST_CHECK( DynamicsShape::SPHERE == shape.GetType() );
+  }
+  else
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+  }
+  END_TEST;
+}
+
+int UtcDaliDynamicsShapeGetType(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsShapeGetType - DynamicsShape::GetType");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( world )
+  {
+    DynamicsShape shape( DynamicsShape::NewSphere( 1.0f ) );
+
+    DALI_TEST_CHECK( shape );
+    DALI_TEST_CHECK( DynamicsShape::SPHERE == shape.GetType() );
+  }
+  else
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+  }
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-internal/utc-Dali-DynamicsWorld.cpp b/automated-tests/src/dali-internal/utc-Dali-DynamicsWorld.cpp
new file mode 100644 (file)
index 0000000..f567f9e
--- /dev/null
@@ -0,0 +1,212 @@
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+#include <stdlib.h>
+#include <dali/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
+#include <test-dynamics.h>
+#include <dali/devel-api/dynamics/dynamics.h>
+
+using namespace Dali;
+
+int UtcDaliStageInitializeDynamics(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  Stage stage = Stage::GetCurrent();
+  TraceCallStack& trace = application.GetPlatform().GetTrace();
+  trace.Enable(true);
+  DALI_TEST_CHECK( stage.InitializeDynamics( DynamicsWorldConfig::New() ) );
+  DALI_TEST_CHECK( trace.FindMethod( "GetDynamicsFactory" ) );
+  DALI_TEST_CHECK( trace.FindMethod( "DynamicsFactory::InitializeDynamics" ) );
+  END_TEST;
+}
+
+int UtcDaliStageGetDynamicsWorld(void)
+{
+  TestApplication application;
+
+  Stage stage = Stage::GetCurrent();
+
+  DALI_TEST_CHECK( !stage.GetDynamicsWorld() );
+  END_TEST;
+}
+
+int UtcDaliStageTerminateDynamics(void)
+{
+  TestApplication application;
+
+  Stage stage = Stage::GetCurrent();
+
+  stage.TerminateDynamics();
+
+  DALI_TEST_CHECK( !stage.GetDynamicsWorld() );
+  END_TEST;
+}
+
+int UtcDaliDynamicsWorldConstructor(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsWorldConstructor - DynamicsWorld::DynamicsWorld");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  // Default constructor - create an uninitialized handle
+  DynamicsWorld world;
+  DALI_TEST_CHECK( !world );
+
+  // initialize handle
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  world = Stage::GetCurrent().InitializeDynamics(worldConfig);
+
+  DALI_TEST_CHECK( world );
+  END_TEST;
+}
+
+int UtcDaliDynamicsWorldGravity(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+  TraceCallStack& trace( application.GetPlatform().GetTrace() );
+  trace.Enable( true );
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  const Vector3 gravity(1.0f, 2.0f, 3.0f);
+
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  tet_infoline("UtcDaliDynamicsWorldGravity - DynamicsWorld::SetGravity");
+  world.SetGravity(gravity);
+
+  // update
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DALI_TEST_CHECK( trace.FindMethod( "DynamicsWorld::SetGravity" ) );
+
+  tet_infoline("UtcDaliDynamicsWorldGravity - DynamicsWorld::GetGravity");
+  DALI_TEST_EQUALS(gravity, world.GetGravity(), TEST_LOCATION);
+  END_TEST;
+}
+
+int UtcDaliDynamicsWorldDebugDrawMode(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+  TraceCallStack& trace( application.GetPlatform().GetTrace() );
+  trace.Enable( true );
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  const Vector3 gravity(1.0f, 2.0f, 3.0f);
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  const int mode(DynamicsWorld::DEBUG_MODE_WIREFRAME | DynamicsWorld::DEBUG_MODE_AABB);
+
+  tet_infoline("UtcDaliDynamicsWorldDebugDrawMode - DynamicsWorld::SetDebugDrawMode");
+  world.SetDebugDrawMode(mode);
+
+  // update
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  DALI_TEST_CHECK( trace.FindMethod( "DynamicsWorld::SetDebugDrawMode" ) );
+
+  tet_infoline("UtcDaliDynamicsWorldDebugDrawMode - DynamicsWorld::GetDebugDrawMode");
+  DALI_TEST_CHECK(mode == world.GetDebugDrawMode());
+  END_TEST;
+}
+
+int UtcDaliDynamicsWorldRootActor(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  const Vector3 gravity(1.0f, 2.0f, 3.0f);
+  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
+  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
+
+  if( !world )
+  {
+    // cannot create dynamics world, log failure and exit
+    DALI_TEST_CHECK( false );
+    END_TEST;
+  }
+
+  Actor rootActor(Actor::New());
+
+  tet_infoline("UtcDaliDynamicsWorldDebugDrawMode - DynamicsWorld::GetRootActor");
+  Actor actor(world.GetRootActor());
+  DALI_TEST_CHECK( !actor );
+
+  tet_infoline("UtcDaliDynamicsWorldSetRootActor - DynamicsWorld::SetRootActor");
+  world.SetRootActor(rootActor);
+  DALI_TEST_CHECK(rootActor == world.GetRootActor());
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-internal/utc-Dali-DynamicsWorldConfig.cpp b/automated-tests/src/dali-internal/utc-Dali-DynamicsWorldConfig.cpp
new file mode 100644 (file)
index 0000000..372ed66
--- /dev/null
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+#include <stdlib.h>
+#include <dali/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
+#include <dali/devel-api/dynamics/dynamics.h>
+
+using namespace Dali;
+
+
+int UtcDaliDynamicsWorldConfigConstructor(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsWorldConfigConstructor - DynamicsWorldConfig::DynamicsWorldConfig");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  // Default constructor - create an uninitialized handle
+  DynamicsWorldConfig worldConfig;
+  DALI_TEST_CHECK( !worldConfig );
+
+  // initialize handle
+  worldConfig = DynamicsWorldConfig::New();
+
+  DALI_TEST_CHECK( worldConfig );
+  END_TEST;
+}
+
+int UtcDaliDynamicsWorldConfigNew(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  tet_infoline("UtcDaliDynamicsWorldConfigNew - DynamicsWorldConfig::New");
+
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  // Default constructor - create an uninitialized handle
+  DynamicsWorldConfig worldConfig( DynamicsWorldConfig::New() );
+
+  DALI_TEST_CHECK( worldConfig );
+  END_TEST;
+}
+
+int UtcDaliDynamicsWorldConfigType(void)
+{
+#if !defined(DYNAMICS_SUPPORT)
+  tet_infoline("No dynamics support compiled\n");
+  return 0;
+#endif
+  TestApplication application;
+
+  // start up
+  application.SendNotification();
+  application.Render();
+  application.Render();
+
+  // Default constructor - create an uninitialized handle
+  DynamicsWorldConfig worldConfig( DynamicsWorldConfig::New() );
+
+  tet_infoline("UtcDaliDynamicsWorldConfigNew - DynamicsWorldConfig::GetType");
+  DALI_TEST_CHECK(DynamicsWorldConfig::RIGID == worldConfig.GetType());
+
+  tet_infoline("UtcDaliDynamicsWorldConfigNew - DynamicsWorldConfig::SetType");
+  worldConfig.SetType(DynamicsWorldConfig::SOFT);
+  DALI_TEST_CHECK(DynamicsWorldConfig::SOFT == worldConfig.GetType());
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-internal/utc-Dali-Hash.cpp b/automated-tests/src/dali-internal/utc-Dali-Hash.cpp
new file mode 100644 (file)
index 0000000..79c3881
--- /dev/null
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2015 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <string>
+#include <stdlib.h>
+#include <dali/devel-api/common/hash.h>
+#include <dali-test-suite-utils.h>
+
+void utc_dali_hash_startup(void)
+{
+  test_return_value = TET_UNDEF;
+}
+
+void utc_dali_hash_cleanup(void)
+{
+  test_return_value = TET_PASS;
+}
+
+
+int UtcDaliHash(void)
+{
+  // To fully test the Hash distribution we need to use a tool like http://code.google.com/p/smhasher/
+  // DALi currently uses the hash for variable length strings which come from:
+  // shader vert+frag source, font family + style, image filename.
+  TestApplication application;
+
+  tet_infoline("UtcDaliHash");
+
+  const std::string testString1( "highp vec4 glowColor = vec4( uGlowColor.rgb, uGlowColor.a * clampedColor.a );");
+  const std::string testString2( "lowp vec4 glowColor = vec4( uGlowColor.rgb, uGlowColor.a * clampedColor.a );");
+
+  DALI_TEST_CHECK( Dali::CalculateHash( testString1 ) != Dali::CalculateHash( testString2 ) );
+  DALI_TEST_CHECK( Dali::CalculateHash( testString1, testString2 ) != Dali::CalculateHash( testString2, testString1 ) );
+
+  END_TEST;
+}
+
+int UtcDaliHashNegative(void)
+{
+  // negative test, check hash value == initial value
+  const std::string emptyString;
+
+  DALI_TEST_CHECK( Dali::CalculateHash( emptyString ) != 0 );
+  DALI_TEST_CHECK( Dali::CalculateHash( emptyString, emptyString ) != 0 );
+
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-internal/utc-Dali-HitTestAlgorithm.cpp b/automated-tests/src/dali-internal/utc-Dali-HitTestAlgorithm.cpp
new file mode 100644 (file)
index 0000000..891d6c7
--- /dev/null
@@ -0,0 +1,418 @@
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+
+#include <stdlib.h>
+#include <dali/public-api/dali-core.h>
+#include <dali/devel-api/events/hit-test-algorithm.h>
+#include <dali/integration-api/events/touch-event-integ.h>
+#include <dali-test-suite-utils.h>
+
+using namespace Dali;
+
+namespace
+{
+
+/**
+ * The functor to be used in the hit-test algorithm to check whether the actor is hittable.
+ */
+bool IsActorHittableFunction(Actor actor, Dali::HitTestAlgorithm::TraverseType type)
+{
+  bool hittable = false;
+
+  switch (type)
+  {
+    case Dali::HitTestAlgorithm::CHECK_ACTOR:
+    {
+      // Check whether the actor is visible and not fully transparent.
+      if( actor.IsVisible()
+       && actor.GetCurrentWorldColor().a > 0.01f) // not FULLY_TRANSPARENT
+      {
+        // Check whether the actor has the specific name "HittableActor"
+        if(actor.GetName() == "HittableActor")
+        {
+          hittable = true;
+        }
+      }
+      break;
+    }
+    case Dali::HitTestAlgorithm::DESCEND_ACTOR_TREE:
+    {
+      if( actor.IsVisible() ) // Actor is visible, if not visible then none of its children are visible.
+      {
+        hittable = true;
+      }
+      break;
+    }
+    default:
+    {
+      break;
+    }
+  }
+
+  return hittable;
+};
+
+
+bool DefaultIsActorTouchableFunction(Dali::Actor actor, Dali::HitTestAlgorithm::TraverseType type)
+{
+  bool hittable = false;
+
+  switch (type)
+  {
+    case Dali::HitTestAlgorithm::CHECK_ACTOR:
+    {
+      if( actor.IsVisible() &&
+          actor.IsSensitive() &&
+          actor.GetCurrentWorldColor().a > 0.01f)
+      {
+        hittable = true;
+      }
+      break;
+    }
+    case Dali::HitTestAlgorithm::DESCEND_ACTOR_TREE:
+    {
+      if( actor.IsVisible() && // Actor is visible, if not visible then none of its children are visible.
+          actor.IsSensitive()) // Actor is sensitive, if insensitive none of its children should be hittable either.
+      {
+        hittable = true;
+      }
+      break;
+    }
+    default:
+    {
+      break;
+    }
+  }
+
+  return hittable;
+};
+
+} // anonymous namespace
+
+
+// Positive test case for a method
+int UtcDaliHitTestAlgorithmWithFunctor(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::HitTestAlgorithm functor");
+
+  Stage stage = Stage::GetCurrent();
+
+  Actor actor = Actor::New();
+  actor.SetSize(100.0f, 100.0f);
+  actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
+  actor.SetName("NonHittableActor");
+  stage.Add(actor);
+
+  // Render and notify
+  application.SendNotification();
+  application.Render();
+
+  Vector2 screenCoordinates( 10.0f, 10.0f );
+  Vector2 localCoordinates;
+  actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
+
+  // Perform a hit-test at the given screen coordinates
+  Dali::HitTestAlgorithm::Results results;
+  Dali::HitTestAlgorithm::HitTest( stage, screenCoordinates, results, IsActorHittableFunction );
+  DALI_TEST_CHECK( results.actor != actor );
+
+  actor.SetName("HittableActor");
+
+  results.actor = Actor();
+  results.actorCoordinates = Vector2::ZERO;
+
+  // Perform a hit-test at the given screen coordinates
+  Dali::HitTestAlgorithm::HitTest( stage, screenCoordinates, results, IsActorHittableFunction );
+  DALI_TEST_CHECK( results.actor == actor );
+  DALI_TEST_EQUALS( localCoordinates, results.actorCoordinates, 0.1f, TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliHitTestAlgorithmWithFunctorOnRenderTask(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::HitTestAlgorithm functor, specific to a given render task");
+
+  Stage stage = Stage::GetCurrent();
+  Size stageSize = stage.GetSize();
+  RenderTaskList taskList = stage.GetRenderTaskList();
+
+  Actor actor[2];
+
+  for( int i=0; i<2; i++ )
+  {
+    actor[i] = Actor::New();
+    actor[i].SetSize(100.f, 100.f);
+    actor[i].SetParentOrigin(ParentOrigin::TOP_LEFT);
+    actor[i].SetAnchorPoint(AnchorPoint::TOP_LEFT);
+    actor[i].SetName("HittableActor");
+    stage.Add(actor[i]);
+  }
+  Vector2 position( 50.f, 40.f );
+  actor[1].SetPosition( position.x, position.y );
+
+  RenderTask renderTask[2];
+  renderTask[0] = taskList.GetTask( 0u );
+
+  FrameBufferImage frameBufferImage =  FrameBufferImage::New(stageSize.width, stageSize.height, Pixel::A8, Image::NEVER);
+  renderTask[1] = taskList.CreateTask();
+  renderTask[1].SetSourceActor( actor[1] );
+  renderTask[1].SetExclusive( true );
+  renderTask[1].SetInputEnabled( true );
+  renderTask[1].SetTargetFrameBuffer( frameBufferImage );
+  renderTask[1].SetRefreshRate( RenderTask::REFRESH_ONCE );
+  renderTask[1].SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
+  application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+
+  // Render and notify
+  application.SendNotification();
+  application.Render();
+  application.Render();
+  application.SendNotification();
+
+  // Perform a hit-test at the given screen coordinates with different render tasks
+
+  Dali::HitTestAlgorithm::Results results;
+  Vector2 screenCoordinates( 25.f, 25.f );
+
+  Dali::HitTestAlgorithm::HitTest( renderTask[0], screenCoordinates, results, IsActorHittableFunction );
+  DALI_TEST_CHECK( results.actor == actor[0] );
+  DALI_TEST_EQUALS( screenCoordinates, results.actorCoordinates, 0.1f, TEST_LOCATION );
+
+  results.actor = Actor();
+  results.actorCoordinates = Vector2::ZERO;
+  Dali::HitTestAlgorithm::HitTest( renderTask[1], screenCoordinates, results, IsActorHittableFunction );
+  DALI_TEST_CHECK( !results.actor );
+  DALI_TEST_EQUALS( Vector2::ZERO, results.actorCoordinates, 0.1f, TEST_LOCATION );
+
+  screenCoordinates.x = 80.f;
+  screenCoordinates.y = 70.f;
+
+  results.actor = Actor();
+  results.actorCoordinates = Vector2::ZERO;
+  Dali::HitTestAlgorithm::HitTest( renderTask[0], screenCoordinates, results, IsActorHittableFunction );
+  DALI_TEST_CHECK( results.actor == actor[0] );
+  DALI_TEST_EQUALS( screenCoordinates, results.actorCoordinates, 0.1f, TEST_LOCATION );
+
+  results.actor = Actor();
+  results.actorCoordinates = Vector2::ZERO;
+  Dali::HitTestAlgorithm::HitTest( renderTask[1], screenCoordinates, results, IsActorHittableFunction );
+  DALI_TEST_CHECK( results.actor == actor[1]);
+  DALI_TEST_EQUALS( screenCoordinates - position, results.actorCoordinates, 0.1f, TEST_LOCATION );
+
+
+  screenCoordinates.x = 120.f;
+  screenCoordinates.y = 130.f;
+
+  results.actor = Actor();
+  results.actorCoordinates = Vector2::ZERO;
+  Dali::HitTestAlgorithm::HitTest( renderTask[0], screenCoordinates, results, IsActorHittableFunction );
+  DALI_TEST_CHECK( results.actor == actor[1] );
+  DALI_TEST_EQUALS( screenCoordinates - position, results.actorCoordinates, 0.1f, TEST_LOCATION );
+
+  results.actor = Actor();
+  results.actorCoordinates = Vector2::ZERO;
+  Dali::HitTestAlgorithm::HitTest( renderTask[1], screenCoordinates, results, IsActorHittableFunction );
+  DALI_TEST_CHECK( results.actor == actor[1]);
+  DALI_TEST_EQUALS( screenCoordinates - position, results.actorCoordinates, 0.1f, TEST_LOCATION );
+  END_TEST;
+}
+
+
+int UtcDaliHitTestAlgorithmOrtho01(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::HitTestAlgorithm with parallel Ortho camera()");
+
+  Stage stage = Stage::GetCurrent();
+  RenderTaskList renderTaskList = stage.GetRenderTaskList();
+  RenderTask defaultRenderTask = renderTaskList.GetTask(0u);
+  Dali::CameraActor cameraActor = defaultRenderTask.GetCameraActor();
+
+  Vector2 stageSize ( stage.GetSize() );
+  cameraActor.SetOrthographicProjection( stageSize );
+  cameraActor.SetPosition(0.0f, 0.0f, 1600.0f);
+
+  Vector2 actorSize( stageSize * 0.5f );
+  // Create two actors with half the size of the stage and set them to be partially overlapping
+  Actor blue = Actor::New();
+  blue.SetName( "Blue" );
+  blue.SetAnchorPoint( AnchorPoint::CENTER );
+  blue.SetParentOrigin( Vector3(1.0f/3.0f, 1.0f/3.0f, 0.5f) );
+  blue.SetSize( actorSize );
+  blue.SetZ(30.0f);
+
+  Actor green = Actor::New( );
+  green.SetName( "Green" );
+  green.SetAnchorPoint( AnchorPoint::CENTER );
+  green.SetParentOrigin( Vector3(2.0f/3.0f, 2.0f/3.0f, 0.5f) );
+  green.SetSize( actorSize );
+
+  // Add the actors to the view
+  stage.Add( blue );
+  stage.Add( green );
+
+  // Render and notify
+  application.SendNotification();
+  application.Render(0);
+  application.Render(10);
+
+  HitTestAlgorithm::Results results;
+  HitTest(stage, Vector2( 240.0f, 400.0f ), results, &DefaultIsActorTouchableFunction);
+  DALI_TEST_CHECK( results.actor == blue );
+  DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 5.0f/6.0f, TEST_LOCATION );
+
+  HitTest(stage, stageSize / 3.0f, results, &DefaultIsActorTouchableFunction);
+  DALI_TEST_CHECK( results.actor == blue );
+  DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 0.5f, TEST_LOCATION );
+
+  HitTest(stage, stageSize * 2.0f / 3.0f, results, &DefaultIsActorTouchableFunction);
+  DALI_TEST_CHECK( results.actor == green );
+  DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 0.5f, TEST_LOCATION );
+  END_TEST;
+}
+
+
+int UtcDaliHitTestAlgorithmOrtho02(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::HitTestAlgorithm with offset Ortho camera()");
+
+  Stage stage = Stage::GetCurrent();
+  RenderTaskList renderTaskList = stage.GetRenderTaskList();
+  RenderTask defaultRenderTask = renderTaskList.GetTask(0u);
+  Dali::CameraActor cameraActor = defaultRenderTask.GetCameraActor();
+
+  Vector2 stageSize ( stage.GetSize() );
+  cameraActor.SetOrthographicProjection(-stageSize.x * 0.3f,  stageSize.x * 0.7f,
+                                         stageSize.y * 0.3f, -stageSize.y * 0.7f,
+                                         800.0f, 4895.0f);
+  cameraActor.SetPosition(0.0f, 0.0f, 1600.0f);
+
+  Vector2 actorSize( stageSize * 0.5f );
+  // Create two actors with half the size of the stage and set them to be partially overlapping
+  Actor blue = Actor::New();
+  blue.SetName( "Blue" );
+  blue.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+  blue.SetParentOrigin( Vector3(0.2f, 0.2f, 0.5f) );
+  blue.SetSize( actorSize );
+  blue.SetZ(30.0f);
+
+  Actor green = Actor::New( );
+  green.SetName( "Green" );
+  green.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+  green.SetParentOrigin( Vector3(0.4f, 0.4f, 0.5f) );
+  green.SetSize( actorSize );
+
+  // Add the actors to the view
+  stage.Add( blue );
+  stage.Add( green );
+
+  // Render and notify
+  application.SendNotification();
+  application.Render(0);
+  application.Render(10);
+
+  {
+    HitTestAlgorithm::Results results;
+    HitTest(stage, Vector2( 240.0f, 400.0f ), results, &DefaultIsActorTouchableFunction);
+    DALI_TEST_CHECK( results.actor == green );
+    DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 0.6f, 0.01f, TEST_LOCATION );
+  }
+
+  {
+    HitTestAlgorithm::Results results;
+    HitTest(stage, Vector2( 0.001f, 0.001f ), results, &DefaultIsActorTouchableFunction);
+    DALI_TEST_CHECK( results.actor == blue );
+    DALI_TEST_EQUALS( results.actorCoordinates, Vector2( 0.001f, 0.001f ), 0.001f, TEST_LOCATION );
+  }
+
+  {
+    HitTestAlgorithm::Results results;
+    HitTest(stage, stageSize, results, &DefaultIsActorTouchableFunction);
+    DALI_TEST_CHECK( ! results.actor );
+    DALI_TEST_EQUALS( results.actorCoordinates, Vector2::ZERO, TEST_LOCATION );
+  }
+
+  // Just inside green
+  {
+    HitTestAlgorithm::Results results;
+    HitTest(stage, stageSize*0.69f, results, &DefaultIsActorTouchableFunction);
+    DALI_TEST_CHECK( results.actor == green );
+    DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 0.98f, 0.01f, TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int UtcDaliHitTestAlgorithmStencil(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::HitTestAlgorithm with a stencil");
+
+  Stage stage = Stage::GetCurrent();
+  Actor rootLayer = stage.GetRootLayer();
+  rootLayer.SetName( "RootLayer" );
+
+  // Create a layer
+  Layer layer = Layer::New();
+  layer.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+  layer.SetParentOrigin( ParentOrigin::TOP_LEFT );
+  layer.SetName( "layer" );
+  stage.Add( layer );
+
+  // Create a stencil and add that to the layer
+  Actor stencil = ImageActor::New(Dali::BufferImage::WHITE() );
+  stencil.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+  stencil.SetParentOrigin( ParentOrigin::TOP_LEFT );
+  stencil.SetSize( 50.0f, 50.0f );
+  stencil.SetDrawMode( DrawMode::STENCIL );
+  stencil.SetName( "stencil" );
+  layer.Add( stencil );
+
+  // Create a renderable actor and add that to the layer
+  Actor layerHitActor = ImageActor::New();
+  layerHitActor.SetSize( 100.0f, 100.0f );
+  layerHitActor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+  layerHitActor.SetParentOrigin( ParentOrigin::TOP_LEFT );
+  layerHitActor.SetName( "layerHitActor" );
+  layer.Add( layerHitActor );
+
+  // Render and notify
+  application.SendNotification();
+  application.Render();
+
+  // Hit within stencil and actor
+  {
+    HitTestAlgorithm::Results results;
+    HitTest(stage, Vector2( 10.0f, 10.0f ), results, &DefaultIsActorTouchableFunction);
+    DALI_TEST_CHECK( results.actor == layerHitActor );
+    tet_printf( "Hit: %s\n", ( results.actor ? results.actor.GetName().c_str() : "NULL" ) );
+  }
+
+  // Hit within actor but outside of stencil, should hit the root-layer
+  {
+    HitTestAlgorithm::Results results;
+    HitTest(stage, Vector2( 60.0f, 60.0f ), results, &DefaultIsActorTouchableFunction);
+    DALI_TEST_CHECK( results.actor == rootLayer );
+    tet_printf( "Hit: %s\n", ( results.actor ? results.actor.GetName().c_str() : "NULL" ) );
+  }
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-internal/utc-Dali-Internal-Constraint.cpp b/automated-tests/src/dali-internal/utc-Dali-Internal-Constraint.cpp
deleted file mode 100644 (file)
index 5af885d..0000000
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-
-#include <dali-test-suite-utils.h>
-#include <dali/internal/update/animation/scene-graph-constraint-base.h>
-
-using namespace Dali;
-
-using Dali::Internal::SceneGraph::ConstraintBase;
-
-int UtcDaliConstraintNewInput1OffStage(void)
-{
-  /**
-   * Test that the Constraint is correctly added/removed when an object
-   * providing the input property is added/removed from the stage
-   */
-  TestApplication application;
-
-  Actor parent = Actor::New();
-  Stage::GetCurrent().Add( parent );
-
-  Actor actor = Actor::New();
-  parent.Add( actor );
-
-  Actor sibling1 = Actor::New();
-  sibling1.SetPosition( Vector3(1.0f, 2.0f, 3.0f) );
-  parent.Add( sibling1 );
-
-  Vector3 startValue( 0.0f, 0.0f, 0.0f );
-  DALI_TEST_EQUALS( 0u, ConstraintBase::GetCurrentInstanceCount(), TEST_LOCATION );
-  DALI_TEST_EQUALS( 0u, ConstraintBase::GetTotalInstanceCount(),   TEST_LOCATION );
-
-  /**
-   * Test that the Constraint is correctly applied on a clean Node
-   */
-  application.SendNotification();
-  application.Render(0);
-  DALI_TEST_EQUALS( actor.GetProperty<Vector3>( Actor::Property::POSITION ), startValue, TEST_LOCATION );
-
-  // Apply constraint with a parent input property
-
-  Constraint constraint = Constraint::New<Vector3>( Actor::Property::POSITION,
-                                                    Source( sibling1, Actor::Property::POSITION ),
-                                                    EqualToConstraint() );
-
-  actor.ApplyConstraint( constraint );
-  DALI_TEST_EQUALS( actor.GetProperty<Vector3>( Actor::Property::POSITION ), startValue, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(0);
-  DALI_TEST_EQUALS( actor.GetProperty<Vector3>( Actor::Property::POSITION ), Vector3(1.0f, 2.0f, 3.0f)/*from sibling1*/, TEST_LOCATION );
-  DALI_TEST_EQUALS( 1u, ConstraintBase::GetCurrentInstanceCount(), TEST_LOCATION );
-  DALI_TEST_EQUALS( 1u, ConstraintBase::GetTotalInstanceCount(),   TEST_LOCATION );
-
-  // Remove sibling1 providing the input property
-
-  parent.Remove( sibling1 );
-  actor.SetPosition( Vector3(2.0f, 2.0f, 2.0f) ); // This should be effective
-
-  application.SendNotification();
-  application.Render(0);
-  DALI_TEST_EQUALS( actor.GetProperty<Vector3>( Actor::Property::POSITION ), Vector3(2.0f, 2.0f, 2.0f)/*from SetPosition*/, TEST_LOCATION );
-  DALI_TEST_EQUALS( 0u/*should have been removed*/, ConstraintBase::GetCurrentInstanceCount(), TEST_LOCATION );
-  DALI_TEST_EQUALS( 1u, ConstraintBase::GetTotalInstanceCount(), TEST_LOCATION );
-
-  // Add sibling1 back again (re-enables constraint)
-
-  parent.Add( sibling1 );
-  actor.SetPosition( Vector3(3.0f, 3.0f, 3.0f) ); // This should NOT be effective
-
-  application.SendNotification();
-  application.Render(0);
-  DALI_TEST_EQUALS( actor.GetProperty<Vector3>( Actor::Property::POSITION ), Vector3(1.0f, 2.0f, 3.0f)/*from sibling1*/, TEST_LOCATION );
-  DALI_TEST_EQUALS( 1u, ConstraintBase::GetCurrentInstanceCount(), TEST_LOCATION );
-  DALI_TEST_EQUALS( 2u/*recreated once*/, ConstraintBase::GetTotalInstanceCount(), TEST_LOCATION );
-
-  END_TEST;
-}
diff --git a/automated-tests/src/dali-internal/utc-Dali-Material.cpp b/automated-tests/src/dali-internal/utc-Dali-Material.cpp
new file mode 100644 (file)
index 0000000..848d0f3
--- /dev/null
@@ -0,0 +1,333 @@
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+
+#include <stdlib.h>
+#include <dali/public-api/dali-core.h>
+#include <dali/devel-api/actors/mesh-actor.h>
+#include <dali/devel-api/geometry/mesh.h>
+#include <dali/devel-api/geometry/animatable-mesh.h>
+#include <dali-test-suite-utils.h>
+
+using namespace Dali;
+
+
+void utc_dali_material_startup(void)
+{
+  test_return_value = TET_UNDEF;
+}
+
+void utc_dali_material_cleanup(void)
+{
+  test_return_value = TET_PASS;
+}
+
+namespace
+{
+
+static AnimatableMesh CreateMeshData(Material material)
+{
+  AnimatableMesh::Faces faces;
+  for(int i=0; i<10-3; i++)
+  {
+    faces.push_back(i);
+    faces.push_back(i+1);
+    faces.push_back(i+2);
+  }
+  return AnimatableMesh::New(10, faces, material);
+}
+
+}// anonymous namespace
+
+
+// Positive test case for a method
+int UtcDaliMaterialNew01(void)
+{
+  TestApplication application;
+  tet_infoline("Testing constructors, New and destructors");
+
+  Material material;
+  DALI_TEST_CHECK( ! material );
+
+  material = Material::New("material");
+  DALI_TEST_CHECK( material );
+
+  Material* material2 = new Material();
+  DALI_TEST_CHECK( ! *material2 );
+  delete material2;
+
+  Material material3 = material;
+  Material material4;
+  material4 = material;
+  Material material5 = material;
+  END_TEST;
+}
+
+
+int UtcDaliMaterialDownCast(void)
+{
+  TestApplication application;
+
+  Material material = Material::New("material");
+  BaseHandle handle(material);
+
+  Material mat2 = Material::DownCast( handle );
+  DALI_TEST_CHECK( mat2 );
+  END_TEST;
+}
+
+int UtcDaliMaterialSettersAndGetters(void)
+{
+  TestApplication application;
+  Material material = Material::New("material");
+  DALI_TEST_EQUALS( material.GetName(), "material", TEST_LOCATION );
+  material.SetName( "AnotherMaterial" );
+  DALI_TEST_EQUALS( material.GetName(), "AnotherMaterial", TEST_LOCATION );
+
+  DALI_TEST_EQUALS( material.GetOpacity(), Material::DEFAULT_OPACITY, 0.001, TEST_LOCATION);
+  material.SetOpacity(0.38f);
+  DALI_TEST_EQUALS( material.GetOpacity(), 0.38f, 0.001, TEST_LOCATION);
+
+  DALI_TEST_EQUALS( material.GetShininess(), Material::DEFAULT_SHININESS, 0.001, TEST_LOCATION);
+  material.SetShininess(0.47f);
+  DALI_TEST_EQUALS( material.GetShininess(), 0.47f, 0.001, TEST_LOCATION);
+
+  DALI_TEST_EQUALS( material.GetAmbientColor(), Material::DEFAULT_AMBIENT_COLOR, 0.001, TEST_LOCATION);
+  material.SetAmbientColor(Color::BLACK);
+  DALI_TEST_EQUALS( material.GetAmbientColor(), Color::BLACK, 0.001, TEST_LOCATION);
+
+  DALI_TEST_EQUALS( material.GetDiffuseColor(), Material::DEFAULT_DIFFUSE_COLOR, 0.001, TEST_LOCATION);
+  material.SetDiffuseColor(Color::BLUE);
+  DALI_TEST_EQUALS( material.GetDiffuseColor(), Color::BLUE, 0.001, TEST_LOCATION);
+
+  DALI_TEST_EQUALS( material.GetSpecularColor(), Material::DEFAULT_SPECULAR_COLOR, 0.001, TEST_LOCATION);
+  material.SetSpecularColor(Color::GREEN);
+  DALI_TEST_EQUALS( material.GetSpecularColor(), Color::GREEN, 0.001, TEST_LOCATION);
+
+  DALI_TEST_EQUALS( material.GetEmissiveColor(), Material::DEFAULT_EMISSIVE_COLOR, 0.001, TEST_LOCATION);
+  material.SetEmissiveColor(Color::MAGENTA);
+  DALI_TEST_EQUALS( material.GetEmissiveColor(), Color::MAGENTA, 0.001, TEST_LOCATION);
+
+  material.SetDiffuseTextureFileName("diffuse-texture.png");
+  DALI_TEST_EQUALS( material.GetDiffuseFileName(), "diffuse-texture.png", TEST_LOCATION);
+
+  material.SetOpacityTextureFileName("opacity-texture.png");
+  DALI_TEST_EQUALS( material.GetOpacityTextureFileName(), "opacity-texture.png", TEST_LOCATION);
+
+  material.SetNormalMapFileName("normal-map.png");
+  DALI_TEST_EQUALS( material.GetNormalMapFileName(), "normal-map.png", TEST_LOCATION);
+
+  Image diffuseTexture = ResourceImage::New("diffuse-texture.png");
+  material.SetDiffuseTexture(diffuseTexture);
+  DALI_TEST_EQUALS( material.GetDiffuseTexture(), diffuseTexture, TEST_LOCATION );
+
+  Image opacityTexture = ResourceImage::New("opacity-texture.png");
+  material.SetOpacityTexture(opacityTexture);
+  DALI_TEST_EQUALS( material.GetOpacityTexture(), opacityTexture, TEST_LOCATION);
+
+  Image normalMap = ResourceImage::New("normal-map.png");
+  material.SetNormalMap(normalMap);
+  DALI_TEST_EQUALS( material.GetNormalMap(), normalMap, TEST_LOCATION);
+
+  DALI_TEST_EQUALS( material.GetMapU(), (unsigned int)Material::DEFAULT_MAPPING_MODE, TEST_LOCATION );
+  DALI_TEST_EQUALS( material.GetMapV(), (unsigned int)Material::DEFAULT_MAPPING_MODE, TEST_LOCATION );
+  material.SetMapU( Material::MAPPING_MODE_WRAP );
+  material.SetMapV( Material::MAPPING_MODE_MIRROR );
+  DALI_TEST_EQUALS( material.GetMapU(), (unsigned int)Material::MAPPING_MODE_WRAP, TEST_LOCATION );
+  DALI_TEST_EQUALS( material.GetMapV(), (unsigned int)Material::MAPPING_MODE_MIRROR, TEST_LOCATION );
+
+  DALI_TEST_EQUALS( material.GetDiffuseUVIndex(), Material::DEFAULT_DIFFUSE_UV_INDEX, TEST_LOCATION );
+  material.SetDiffuseUVIndex( 1u );
+  DALI_TEST_EQUALS( material.GetDiffuseUVIndex(), 1u, TEST_LOCATION );
+
+  DALI_TEST_EQUALS( material.GetOpacityUVIndex(), Material::DEFAULT_OPACITY_UV_INDEX, TEST_LOCATION );
+  material.SetOpacityUVIndex( 1u );
+  DALI_TEST_EQUALS( material.GetOpacityUVIndex(), 1u, TEST_LOCATION );
+
+  DALI_TEST_EQUALS( material.GetNormalUVIndex(), Material::DEFAULT_NORMAL_UV_INDEX, TEST_LOCATION );
+  material.SetNormalUVIndex( 1u );
+  DALI_TEST_EQUALS( material.GetNormalUVIndex(), 1u, TEST_LOCATION );
+
+  DALI_TEST_EQUALS( material.GetHasHeightMap(), Material::DEFAULT_HAS_HEIGHT_MAP, TEST_LOCATION );
+  material.SetHasHeightMap(true);
+  DALI_TEST_EQUALS( material.GetHasHeightMap(), true, TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliMaterialStage01(void)
+{
+  TestApplication application;
+  TraceCallStack& textureTrace = application.GetGlAbstraction().GetTextureTrace();
+  textureTrace.Enable(true);
+  TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+
+  {
+    Material material = Material::New("material");
+    Image image = ResourceImage::New( "image.png", ResourceImage::IMMEDIATE, Image::NEVER );
+    DALI_TEST_CHECK(image);
+    application.SendNotification();
+    application.Render(16);
+
+    std::vector<GLuint> ids;
+    ids.push_back( 23 );
+    application.GetGlAbstraction().SetNextTextureIds( ids );
+    Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::DISCARD );
+    Integration::ResourcePointer resource(bitmap);
+    bitmap->GetPackedPixelsProfile()->ReserveBuffer(Pixel::RGBA8888, 80, 80, 80, 80);
+    DALI_TEST_CHECK( application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) );
+    Integration::ResourceRequest* request = application.GetPlatform().GetRequest();
+    DALI_TEST_CHECK( request != NULL );
+    if(request)
+    {
+      application.GetPlatform().SetResourceLoaded(request->GetId(), request->GetType()->id, resource);
+    }
+
+    material.SetDiffuseTexture(image);
+    application.SendNotification();
+    application.Render();
+
+    AnimatableMesh mesh = CreateMeshData(material);
+
+    application.SendNotification();
+    application.Render();
+    {
+      MeshActor meshActor = MeshActor::New(mesh);
+      meshActor.SetSize(100, 100);
+      Stage::GetCurrent().Add(meshActor);
+      application.SendNotification();
+      application.Render();
+
+      material.SetOpacity(0.5f);
+      application.SendNotification();
+      application.Render();
+      DALI_TEST_EQUALS( material.GetOpacity(), 0.5f, 0.001f, TEST_LOCATION );
+
+      Stage::GetCurrent().Remove(meshActor);
+      application.SendNotification();
+      application.Render();
+
+      DALI_TEST_CHECK( glAbstraction.CheckNoTexturesDeleted() );
+      DALI_TEST_CHECK( ! textureTrace.FindMethod( "DeleteTextures" ) );
+    }
+    application.SendNotification();
+    application.Render();
+
+    // Mesh should be destroyed, reducing connection count on material to zero.
+    // This should also reduce connection count on image to zero
+    DALI_TEST_EQUALS( material.GetOpacity(), 0.5f, 0.001f, TEST_LOCATION );
+  }
+  // SceneGraph::Material & SceneGraph::RenderMaterial should be destroyed
+  // Image should be destroyed
+  application.SendNotification();
+  application.Render();
+
+  application.Render();
+  DALI_TEST_CHECK( textureTrace.FindMethod( "DeleteTextures" ) );
+  DALI_TEST_CHECK( glAbstraction.CheckTextureDeleted( 23 ) );
+  END_TEST;
+}
+
+
+int UtcDaliMaterialStage01MemCheck(void)
+{
+  TestApplication application;
+  tet_result(TET_PASS);
+  END_TEST;
+}
+
+int UtcDaliMaterialStage02(void)
+{
+  TestApplication application;
+  TraceCallStack& textureTrace = application.GetGlAbstraction().GetTextureTrace();
+  textureTrace.Enable(true);
+  TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+
+  {
+    Material material = Material::New("material");
+
+    Image image = ResourceImage::New( "image.png", ResourceImage::ON_DEMAND, Image::UNUSED );
+    DALI_TEST_CHECK(image);
+    application.SendNotification();
+    application.Render(16);
+    DALI_TEST_CHECK( !application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) );
+    DALI_TEST_CHECK( application.GetPlatform().GetRequest() == NULL );
+
+    std::vector<GLuint> ids;
+    ids.push_back( 23 );
+    application.GetGlAbstraction().SetNextTextureIds( ids );
+
+    material.SetDiffuseTexture(image);
+    application.SendNotification();
+    application.Render();
+    DALI_TEST_CHECK( !application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) );
+    DALI_TEST_CHECK( application.GetPlatform().GetRequest() == NULL );
+
+    AnimatableMesh mesh = CreateMeshData(material);
+
+    application.SendNotification();
+    application.Render();
+    DALI_TEST_CHECK( !application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) );
+    DALI_TEST_CHECK( application.GetPlatform().GetRequest() == NULL );
+
+    {
+      MeshActor meshActor = MeshActor::New(mesh);
+      meshActor.SetSize(100, 100);
+      Stage::GetCurrent().Add(meshActor);
+      application.SendNotification();
+      application.Render();
+
+      // Image connection count should go to one - image should get loaded
+      DALI_TEST_CHECK( application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) );
+      Integration::ResourceRequest* request = application.GetPlatform().GetRequest();
+      DALI_TEST_CHECK( request != NULL );
+
+      Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::DISCARD );
+      Integration::ResourcePointer resource(bitmap);
+      bitmap->GetPackedPixelsProfile()->ReserveBuffer(Pixel::RGBA8888, 80, 80, 80, 80);
+      if(request)
+      {
+        application.GetPlatform().SetResourceLoaded(request->GetId(), request->GetType()->id, resource);
+      }
+      application.Render();
+
+      material.SetOpacity(0.5f);
+      application.SendNotification();
+      application.Render();
+      DALI_TEST_EQUALS( material.GetOpacity(), 0.5f, 0.001f, TEST_LOCATION );
+
+      Stage::GetCurrent().Remove(meshActor);
+      application.SendNotification();
+      application.Render();
+
+      // This should reduce connection count on material to zero, freeing the texture:
+      DALI_TEST_CHECK( textureTrace.FindMethod( "DeleteTextures" ) );
+      DALI_TEST_CHECK( glAbstraction.CheckTextureDeleted( 23 ) );
+    }
+    application.SendNotification();
+    application.Render();
+
+    // Mesh should be destroyed, reducing connection count on material to zero.
+    // This should also reduce connection count on image to zero, freeing it
+    DALI_TEST_EQUALS( material.GetOpacity(), 0.5f, 0.001f, TEST_LOCATION );
+  }
+  application.SendNotification();
+  application.Render();
+
+  // SceneGraph::Material & SceneGraph::RenderMaterial should be destroyed
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-internal/utc-Dali-MeshActor.cpp b/automated-tests/src/dali-internal/utc-Dali-MeshActor.cpp
new file mode 100644 (file)
index 0000000..3a36f3d
--- /dev/null
@@ -0,0 +1,748 @@
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+
+#include <stdlib.h>
+#include <dali/public-api/dali-core.h>
+#include <dali/devel-api/actors/mesh-actor.h>
+#include <dali/devel-api/geometry/mesh.h>
+#include <dali/devel-api/geometry/animatable-mesh.h>
+#include <dali-test-suite-utils.h>
+
+using namespace Dali;
+
+#include <mesh-builder.h>
+
+void mesh_actor_test_startup(void)
+{
+  test_return_value = TET_UNDEF;
+}
+
+void mesh_actor_test_cleanup(void)
+{
+  test_return_value = TET_PASS;
+}
+
+namespace
+{
+
+static Mesh NewMesh()
+{
+  MeshData meshData;
+  MeshData::VertexContainer    vertices;
+  MeshData::FaceIndices        faces;
+  BoneContainer                bones;
+  ConstructVertices(vertices, 60);
+  ConstructFaces(vertices, faces);
+  Material customMaterial = ConstructMaterial();
+  meshData.SetData(vertices, faces, bones, customMaterial);
+  Mesh mesh = Mesh::New(meshData);
+  return mesh;
+}
+
+static AnimatableMesh NewAnimatableMesh()
+{
+  AnimatableMesh::Faces faces;
+  faces.push_back(0);
+  faces.push_back(1);
+  faces.push_back(2);
+
+  Material customMaterial = Material::New("CustomMaterial");
+  customMaterial.SetOpacity(.76f);
+  customMaterial.SetDiffuseColor(Vector4(0.8f, 0.0f, 0.4f, 1.0f));
+  customMaterial.SetAmbientColor(Vector4(0.2f, 1.0f, 0.6f, 1.0f));
+  customMaterial.SetSpecularColor(Vector4(0.5f, 0.6f, 0.7f, 1.0f));
+
+  AnimatableMesh mesh = AnimatableMesh::New( 10u, faces, customMaterial );
+  return mesh;
+}
+} // anonymous namespace
+
+int UtcDaliMeshActorConstructorVoid(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::MeshActor()");
+
+  MeshActor actor;
+  DALI_TEST_CHECK(!actor);
+  END_TEST;
+}
+
+int UtcDaliMeshActorNew01(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::New()");
+
+  AnimatableMesh mesh = NewAnimatableMesh();
+  MeshActor actor = MeshActor::New(mesh);
+  application.SendNotification();
+  application.Render();
+  application.Render();
+  application.SendNotification();
+
+  DALI_TEST_CHECK(actor);
+  END_TEST;
+}
+
+
+int UtcDaliMeshActorNew03(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::Mesh::New() - Create with no mesh");
+
+  try
+  {
+    MeshActor actor = MeshActor::New(); // Shouldn't assert
+    tet_result(TET_PASS);
+  }
+  catch (Dali::DaliException& e)
+  {
+    tet_result(TET_FAIL);
+  }
+
+  END_TEST;
+}
+
+int UtcDaliMeshActorCreateNoMeshData(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::Mesh::New() - Create with no mesh data");
+
+  try
+  {
+    MeshData meshData;
+    Mesh mesh = Mesh::New(meshData);
+    MeshActor actor1 = MeshActor::New(mesh);
+  }
+  catch(Dali::DaliException& e)
+  {
+    DALI_TEST_PRINT_ASSERT( e );
+    DALI_TEST_ASSERT(e, "object", TEST_LOCATION);
+  }
+  END_TEST;
+}
+
+
+int UtcDaliMeshActorCreateSetData01(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshData::SetData() - Create with no verts");
+  try
+  {
+    MeshData meshData;
+    MeshData::VertexContainer vertices;
+    MeshData::FaceIndices     faces;
+    BoneContainer             bones;
+    Material                  customMaterial;
+    meshData.SetData(vertices, faces, bones, customMaterial);
+    Mesh mesh = Mesh::New(meshData);
+    MeshActor actor1 = MeshActor::New(mesh);
+  }
+  catch(Dali::DaliException& e)
+  {
+    DALI_TEST_PRINT_ASSERT( e );
+    DALI_TEST_ASSERT(e, "!vertices.empty()", TEST_LOCATION );
+  }
+  END_TEST;
+}
+
+int UtcDaliMeshActorCreateSetData02(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshData::SetData - Create with no faces");
+  try
+  {
+    MeshData meshData;
+    MeshData::VertexContainer    vertices;
+    MeshData::FaceIndices        faces;
+    BoneContainer                bones;
+    Material                     customMaterial;
+    ConstructVertices(vertices, 60);
+    meshData.SetData(vertices, faces, bones, customMaterial);
+    Mesh mesh = Mesh::New(meshData);
+    MeshActor actor1 = MeshActor::New(mesh);
+  }
+  catch(Dali::DaliException& e)
+  {
+    DALI_TEST_PRINT_ASSERT( e );
+    DALI_TEST_ASSERT(e, "!faceIndices.empty", TEST_LOCATION );
+  }
+  END_TEST;
+}
+
+int UtcDaliMeshActorCreateSetData03(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshData::SetData - Create with no mats");
+  try
+  {
+    MeshData meshData;
+    MeshData::VertexContainer    vertices;
+    MeshData::FaceIndices        faces;
+    BoneContainer                bones;
+    Material                     customMaterial;
+    ConstructVertices(vertices, 60);
+    ConstructFaces(vertices, faces);
+    meshData.SetData(vertices, faces, bones, customMaterial);
+    Mesh mesh = Mesh::New(meshData);
+    MeshActor actor1 = MeshActor::New(mesh);
+  }
+  catch(Dali::DaliException& e)
+  {
+    DALI_TEST_PRINT_ASSERT( e );
+    DALI_TEST_ASSERT(e, "material", TEST_LOCATION );
+  }
+  END_TEST;
+}
+
+int UtcDaliMeshActorCreateSetData04(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::SetData()");
+
+  MeshData meshData;
+  MeshData::VertexContainer    vertices;
+  MeshData::FaceIndices        faces;
+  BoneContainer                bones;
+  ConstructVertices(vertices, 60);
+  ConstructFaces(vertices, faces);
+  Material customMaterial = ConstructMaterial();
+  meshData.SetData(vertices, faces, bones, customMaterial);
+
+  Mesh mesh = Mesh::New(meshData);
+  MeshActor actor1 = MeshActor::New(mesh);
+  DALI_TEST_CHECK(actor1);
+  END_TEST;
+}
+
+
+int UtcDaliMeshActorDownCast(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::DownCast()");
+
+  MeshData meshData;
+  MeshData::VertexContainer    vertices;
+  MeshData::FaceIndices        faces;
+  BoneContainer                bones;
+  ConstructVertices(vertices, 60);
+  ConstructFaces(vertices, faces);
+  Material customMaterial = ConstructMaterial();
+  meshData.SetData(vertices, faces, bones, customMaterial);
+  Mesh mesh = Mesh::New(meshData);
+
+  MeshActor actor1 = MeshActor::New(mesh);
+  Actor anActor = Actor::New();
+  anActor.Add(actor1);
+
+  Actor child = anActor.GetChildAt(0);
+  MeshActor meshActor = MeshActor::DownCast(child);
+
+  DALI_TEST_CHECK(meshActor);
+  END_TEST;
+}
+
+int UtcDaliMeshActorDownCast2(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::DownCast()");
+
+  Actor actor1 = Actor::New();
+  Actor anActor = Actor::New();
+  anActor.Add(actor1);
+
+  Actor child = anActor.GetChildAt(0);
+  MeshActor meshActor = MeshActor::DownCast(child);
+  DALI_TEST_CHECK(!meshActor);
+
+  Actor unInitialzedActor;
+  meshActor = DownCast< MeshActor >( unInitialzedActor );
+  DALI_TEST_CHECK(!meshActor);
+  END_TEST;
+}
+
+int UtcDaliMeshActorSetMaterial01(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::SetMaterial()");
+
+  Mesh mesh = NewMesh();
+
+  MeshActor actor = MeshActor::New(mesh);
+  std::string name = "AMeshActor";
+  Stage::GetCurrent().Add(actor);
+  actor.SetName(name);
+  application.SendNotification();
+  application.Render();
+  application.Render();
+  application.SendNotification();
+
+  Material customMaterial = Material::New("CustomMaterial");
+  customMaterial.SetDiffuseColor(Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+
+  MeshActor::SetMaterial(actor, name, customMaterial);
+  application.SendNotification();
+  application.Render();
+  application.Render();
+  application.SendNotification();
+
+  DALI_TEST_CHECK( actor.GetMaterial() == customMaterial );
+  END_TEST;
+}
+
+int UtcDaliMeshActorSetMaterial01b(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::SetMaterial()");
+
+  Mesh mesh = NewMesh();
+
+  Actor rootActor = Actor::New();
+  MeshActor meshActor = MeshActor::New(mesh);
+  rootActor.Add(meshActor);
+
+  std::string name = "AMeshActor";
+  meshActor.SetName(name);
+
+  Stage::GetCurrent().Add(rootActor);
+  application.SendNotification();
+  application.Render();
+  application.Render();
+  application.SendNotification();
+
+  Material customMaterial = Material::New("CustomMaterial");
+  customMaterial.SetDiffuseColor(Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+
+  MeshActor::SetMaterial(rootActor, name, customMaterial);
+  application.SendNotification();
+  application.Render();
+  application.Render();
+  application.SendNotification();
+
+  DALI_TEST_CHECK(meshActor.GetMaterial() == customMaterial );
+  END_TEST;
+}
+
+
+int UtcDaliMeshActorSetMaterial02(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::SetMaterial()");
+
+  Mesh mesh = NewMesh();
+  MeshActor actor = MeshActor::New(mesh);
+
+  std::string name = "AMeshActor";
+  actor.SetName(name);
+  Stage::GetCurrent().Add(actor);
+  application.SendNotification();
+  application.Render();
+  application.Render();
+  application.SendNotification();
+
+  Material baseMat = actor.GetMaterial();
+  Material customMaterial = Material::New("CustomMaterial");
+  customMaterial.SetDiffuseColor(Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+
+  MeshActor::SetMaterial(actor, "NoName", customMaterial);
+  application.SendNotification();
+  application.Render();
+  application.Render();
+  application.SendNotification();
+
+  DALI_TEST_CHECK( actor.GetMaterial() == baseMat );
+  DALI_TEST_CHECK( actor.GetMaterial() != customMaterial );
+  END_TEST;
+}
+
+int UtcDaliMeshActorSetMaterial02b(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::SetMaterial()");
+
+  Mesh mesh = NewMesh();
+
+  MeshActor actor = MeshActor::New(mesh);
+  Stage::GetCurrent().Add(actor);
+
+  std::string name = "AMeshActor";
+  actor.SetName(name);
+  application.SendNotification();
+  application.Render();
+  application.Render();
+  application.SendNotification();
+
+  Material baseMat = actor.GetMaterial();
+  Material customMaterial = Material::New("CustomMaterial");
+  customMaterial.SetDiffuseColor(Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+
+  MeshActor::SetMaterial(actor, "NoName", customMaterial);
+  application.SendNotification();
+  application.Render();
+  application.Render();
+  application.SendNotification();
+
+  DALI_TEST_CHECK( actor.GetMaterial() == baseMat );
+  DALI_TEST_CHECK( actor.GetMaterial() != customMaterial );
+  END_TEST;
+}
+
+
+int UtcDaliMeshActorSetMaterial03(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::SetMaterial()");
+
+  Mesh mesh = NewMesh();
+
+  MeshActor actor = MeshActor::New(mesh);
+  std::string name = "AMeshActor";
+  actor.SetName(name);
+  Stage::GetCurrent().Add(actor);
+
+  Material customMaterial = Material::New("CustomMaterial");
+  customMaterial.SetDiffuseColor(Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+
+  actor.SetMaterial(customMaterial);
+  application.SendNotification();
+  application.Render(0);
+  application.Render(16);
+  application.SendNotification();
+
+  DALI_TEST_CHECK(actor.GetMaterial() == customMaterial );
+  END_TEST;
+}
+
+int UtcDaliMeshActorSetMaterial03b(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::SetMaterial()");
+
+  Mesh mesh = NewMesh();
+
+  MeshActor actor = MeshActor::New(mesh);
+  std::string name = "AMeshActor";
+  actor.SetName(name);
+  Stage::GetCurrent().Add(actor);
+
+  Material customMaterial = Material::New("CustomMaterial");
+  customMaterial.SetDiffuseColor(Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+
+  actor.SetMaterial(customMaterial);
+  application.SendNotification();
+  application.Render(0);
+  application.Render(16);
+  application.SendNotification();
+  DALI_TEST_CHECK(actor.GetMaterial() == customMaterial );
+  END_TEST;
+}
+
+
+
+int UtcDaliMeshActorGetMaterial01(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::SetMaterial()");
+
+  MeshData meshData;
+  MeshData::VertexContainer vertices;
+  MeshData::FaceIndices faces;
+  BoneContainer bones;
+  ConstructVertices(vertices, 60);
+  ConstructFaces(vertices, faces);
+  Material material = ConstructMaterial();
+  meshData.SetData(vertices, faces, bones, material);
+  Mesh mesh = Mesh::New(meshData);
+
+  MeshActor actor = MeshActor::New(mesh);
+  std::string name = "AMeshActor";
+  actor.SetName(name);
+  application.SendNotification();
+  application.Render();
+  application.Render();
+  application.SendNotification();
+
+  Material gotMaterial = actor.GetMaterial();
+
+  DALI_TEST_EQUALS( material.GetOpacity(), gotMaterial.GetOpacity(), TEST_LOCATION );
+  DALI_TEST_EQUALS( material.GetAmbientColor(), gotMaterial.GetAmbientColor(), TEST_LOCATION );
+  DALI_TEST_EQUALS( material.GetDiffuseColor(), gotMaterial.GetDiffuseColor(), TEST_LOCATION );
+  DALI_TEST_EQUALS( material.GetSpecularColor(), gotMaterial.GetSpecularColor(), TEST_LOCATION );
+  END_TEST;
+}
+
+
+int UtcDaliMeshActorGetMaterial02(void)
+{
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::SetMaterial()");
+
+  MeshData meshData;
+  MeshData::VertexContainer vertices;
+  MeshData::FaceIndices faces;
+  BoneContainer bones;
+  ConstructVertices(vertices, 60);
+  ConstructFaces(vertices, faces);
+  Material material = ConstructMaterial();
+  meshData.SetData(vertices, faces, bones, material);
+  Mesh mesh = Mesh::New(meshData);
+
+  MeshActor actor = MeshActor::New(mesh);
+  std::string name = "AMeshActor";
+  actor.SetName(name);
+  application.SendNotification();
+  application.Render();
+  application.Render();
+  application.SendNotification();
+
+  Material gotMaterial = actor.GetMaterial();
+
+  DALI_TEST_EQUALS( material.GetOpacity(), gotMaterial.GetOpacity(), TEST_LOCATION );
+  DALI_TEST_EQUALS( material.GetAmbientColor(), gotMaterial.GetAmbientColor(), TEST_LOCATION );
+  DALI_TEST_EQUALS( material.GetDiffuseColor(), gotMaterial.GetDiffuseColor(), TEST_LOCATION );
+  DALI_TEST_EQUALS( material.GetSpecularColor(), gotMaterial.GetSpecularColor(), TEST_LOCATION );
+  END_TEST;
+}
+
+
+namespace
+{
+
+Material ConstructMaterial(float opacity, float diffuseOpacity)
+{
+  Material customMaterial = Material::New("CustomMaterial");
+  customMaterial.SetOpacity(opacity);
+  customMaterial.SetDiffuseColor(Vector4(0.8f, 0.0f, 0.4f, diffuseOpacity));
+  customMaterial.SetAmbientColor(Vector4(0.2f, 1.0f, 0.6f, 1.0f));
+  customMaterial.SetSpecularColor(Vector4(0.5f, 0.6f, 0.7f, 1.0f));
+  return customMaterial;
+}
+
+static void TestBlending( TestApplication& application, Material material, float actorOpacity, BlendingMode::Type blendingMode, bool expectedBlend )
+{
+  MeshData meshData;
+  MeshData::VertexContainer vertices;
+  MeshData::FaceIndices faces;
+  BoneContainer bones;
+  ConstructVertices(vertices, 60);
+  ConstructFaces(vertices, faces);
+  meshData.SetData(vertices, faces, bones, material);
+  Mesh mesh = Mesh::New(meshData);
+
+  application.SendNotification();
+  application.Render(0);
+  application.Render();
+  application.SendNotification();
+
+  MeshActor actor = MeshActor::New(mesh);
+  Stage::GetCurrent().Add(actor);
+
+  actor.SetBlendMode(blendingMode);
+  actor.SetOpacity(actorOpacity);
+
+  TraceCallStack& cullFaceTrace = application.GetGlAbstraction().GetCullFaceTrace();
+  cullFaceTrace.Enable(true);
+  application.SendNotification();
+  application.Render();
+  DALI_TEST_EQUALS( BlendEnabled( cullFaceTrace ), expectedBlend, TEST_LOCATION );
+}
+} //anonymous namespace
+
+
+int UtcDaliMeshActorBlend01(void)
+{
+  // Set Material with translucent color, actor color opaque, Set Use image alpha to true
+  // Expect blending
+
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::Blend01()");
+
+  TestBlending( application, ConstructMaterial(0.5f, 0.5f), 1.0f, BlendingMode::AUTO, true );
+  END_TEST;
+}
+
+
+int UtcDaliMeshActorBlend02(void)
+{
+  // Set material to translucent, set use image alpha to false, set actor opacity to 1.0f
+  // Expect no blending
+
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::Blend02()");
+  TestBlending( application, ConstructMaterial(0.5f, 0.5f), 1.0f, BlendingMode::OFF, false );
+  END_TEST;
+}
+
+int UtcDaliMeshActorBlend03(void)
+{
+  // Set material to opaque, set use image alpha to true, set actor opacity to 1.0f
+  // Expect no blending
+
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::Blend03()");
+  TestBlending( application, ConstructMaterial(1.0f, 1.0f), 1.0f, BlendingMode::AUTO, false );
+  END_TEST;
+}
+
+
+int UtcDaliMeshActorBlend04(void)
+{
+  // Set material to have image with alpha, set use image alpha to true, set actor opacity to 1.0f
+  // Expect blending
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::Blend04()");
+
+  Material material = ConstructMaterial(1.0f, 1.0f);
+  BufferImage image = BufferImage::New( 100, 50, Pixel::RGBA8888 );
+  material.SetDiffuseTexture( image );
+  application.SendNotification();
+  application.Render(0);
+
+  TestBlending( application, material, 1.0f, BlendingMode::AUTO, true );
+  END_TEST;
+}
+
+int UtcDaliMeshActorBlend05(void)
+{
+  // Set material to have image with alpha, set use image alpha to false, set actor opacity to 1.0f
+  // Expect no blending
+
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::Blend05()");
+
+  Material material = ConstructMaterial(1.0f, 1.0f);
+  BufferImage image = BufferImage::New( 100, 50, Pixel::RGBA8888 );
+  material.SetDiffuseTexture( image );
+  application.SendNotification();
+  application.Render(0);
+
+  TestBlending( application, material, 1.0f, BlendingMode::ON, true );
+  END_TEST;
+}
+
+
+int UtcDaliMeshActorBlend06(void)
+{
+  // Set material to have image without alpha, set use image alpha to true, set actor opacity to 1.0f
+  // Expect no blending
+
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::Blend()");
+
+  Material material = ConstructMaterial(1.0f, 1.0f);
+  BufferImage image = BufferImage::New( 100, 50, Pixel::RGB888 );
+  material.SetDiffuseTexture( image );
+  application.SendNotification();
+  application.Render(0);
+
+  TestBlending( application, material, 1.0f, BlendingMode::AUTO, false );
+  END_TEST;
+}
+
+int UtcDaliMeshActorBlend07(void)
+{
+  // Set material to have framebuffer with alpha, set use image alpha to true, set actor opacity to 1.0f
+  // Expect blending
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::Blend07()");
+  application.Render(0);
+
+  Material material = ConstructMaterial(1.0f, 1.0f);
+  FrameBufferImage image = FrameBufferImage::New( 100, 50, Pixel::RGBA8888 );
+  RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
+  RenderTask task = taskList.GetTask( 0u );
+  task.SetTargetFrameBuffer( image ); // To ensure frame buffer is connected
+  application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+  application.SendNotification();
+  application.Render();
+
+  material.SetDiffuseTexture( image ); // (to render from)
+  application.SendNotification();
+  application.Render();
+  application.Render();
+  application.SendNotification();
+
+  TestBlending( application, material, 1.0f, BlendingMode::AUTO, true );
+  END_TEST;
+}
+
+int UtcDaliMeshActorBlend08(void)
+{
+  // Set material to have image with alpha, set use image alpha to false, set actor opacity to 0.5f
+  // Expect blending
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::Blend08()");
+
+  Material material = ConstructMaterial(1.0f, 1.0f);
+  BufferImage image = BufferImage::New( 100, 50, Pixel::RGBA8888 );
+  material.SetDiffuseTexture( image );
+  application.SendNotification();
+  application.Render(0);
+
+  TestBlending( application, material, 0.5f, BlendingMode::AUTO, true );
+  END_TEST;
+}
+
+int UtcDaliMeshActorBlend09(void)
+{
+  // Set material to have image with no alpha, set material opacity to 0.5, set use image alpha to true, set actor opacity to 1.0f
+  // Expect blending
+  TestApplication application;
+  tet_infoline("Testing Dali::MeshActor::Blend08()");
+
+  Material material = ConstructMaterial(0.5f, 1.0f);
+  BufferImage image = BufferImage::New( 100, 50, Pixel::RGB888 );
+  material.SetDiffuseTexture( image );
+  application.SendNotification();
+  application.Render(0);
+
+  TestBlending( application, material, 1.0f, BlendingMode::AUTO, true );
+  END_TEST;
+}
+
+// Test that bones update the mesh's bone transform uniforms
+// (Removed old test - wasn't checking the above information, but instead the property
+// info, which is tested elsewhere)
+
+int UtcDaliMeshActorIndices(void)
+{
+  TestApplication application;
+  Actor basicActor = Actor::New();
+  Mesh mesh = NewMesh();
+  MeshActor meshActor = MeshActor::New(mesh);
+
+  Property::IndexContainer indices;
+  meshActor.GetPropertyIndices( indices );
+  DALI_TEST_CHECK( indices.size() == basicActor.GetPropertyCount() ); // Mesh Actor does not have any properties
+  DALI_TEST_EQUALS( indices.size(), meshActor.GetPropertyCount(), TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliAnimatableMeshActorIndices(void)
+{
+  TestApplication application;
+  Actor basicActor = Actor::New();
+  AnimatableMesh mesh = NewAnimatableMesh();
+  MeshActor meshActor = MeshActor::New(mesh);
+
+  Property::IndexContainer indices;
+  meshActor.GetPropertyIndices( indices );
+  DALI_TEST_CHECK( indices.size() == basicActor.GetPropertyCount() ); // Mesh Actor does not have any properties
+  DALI_TEST_EQUALS( indices.size(), meshActor.GetPropertyCount(), TEST_LOCATION );
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-internal/utc-Dali-MeshData.cpp b/automated-tests/src/dali-internal/utc-Dali-MeshData.cpp
new file mode 100644 (file)
index 0000000..273bd27
--- /dev/null
@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+
+#include <stdlib.h>
+#include <dali/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
+
+using namespace Dali;
+
+#include "mesh-builder.h"
+
+
+
+int UtcDaliMeshDataNew(void)
+{
+  TestApplication application;
+  MeshData meshData;
+
+  DALI_TEST_EQUALS(meshData.HasNormals(), false, TEST_LOCATION);
+  DALI_TEST_EQUALS(meshData.HasTextureCoords(), false, TEST_LOCATION);
+  END_TEST;
+}
+
+
+int UtcDaliMeshDataSetData(void)
+{
+  TestApplication application;
+
+  MeshData meshData;
+  MeshData::VertexContainer    vertices;
+  MeshData::FaceIndices        faces;
+  BoneContainer                bones;
+  ConstructVertices(vertices, 60);
+  ConstructFaces(vertices, faces);
+  Material customMaterial = ConstructMaterial();
+  meshData.SetData(vertices, faces, bones, customMaterial);
+
+  DALI_TEST_GREATER(meshData.GetVertexCount(), size_t(0), TEST_LOCATION);
+  DALI_TEST_GREATER(meshData.GetFaceCount(), size_t(0), TEST_LOCATION);
+
+  const MeshData::FaceIndices& faces2 = meshData.GetFaces();
+  const MeshData::VertexContainer& verts2 = meshData.GetVertices();
+  DALI_TEST_EQUALS(faces.at(0), faces2.at(0), TEST_LOCATION);
+  DALI_TEST_EQUALS(vertices.at(1).y, verts2.at(1).y, TEST_LOCATION);
+  DALI_TEST_EQUALS(meshData.GetBoneCount(), static_cast<size_t>(0), TEST_LOCATION);
+  END_TEST;
+}
+
+int UtcDaliMeshDataAddToBoundingVolume(void)
+{
+  TestApplication application;
+
+  float sz=40.0f;
+
+  MeshData meshData;
+  MeshData::VertexContainer    vertices;
+  MeshData::FaceIndices        faces;
+  BoneContainer                bones;
+  ConstructVertices(vertices, sz);
+  ConstructFaces(vertices, faces);
+  Material customMaterial = ConstructMaterial();
+  meshData.SetData(vertices, faces, bones, customMaterial);
+
+  Vector4 upper(-1e10f, -1e10f, -1e10f, 0.0f);
+  Vector4 lower(1e10f, 1e10f, 1e10f, 0.0f);
+  Matrix f(false);
+  f.SetIdentityAndScale(Vector3(2.0f, 2.0f, 2.0f));
+  meshData.AddToBoundingVolume(lower, upper, f);
+
+  Vector4 min(-sz*0.5f, -sz,      -sz*0.7f, 0.0f);
+  Vector4 max( sz*0.5f,  sz*0.3f,  sz*0.5f, 0.0f);
+
+  // Test that upper and lower bounds are set and transformed
+  DALI_TEST_EQUALS(lower, min*2.0f, 0.001, TEST_LOCATION);
+  DALI_TEST_EQUALS(upper, max*2.0f, 0.001, TEST_LOCATION);
+
+  // Test that mesh's upper and lower bounds are set and not transformed
+  DALI_TEST_EQUALS(meshData.GetBoundingBoxMin(), min, 0.001, TEST_LOCATION);
+  DALI_TEST_EQUALS(meshData.GetBoundingBoxMax(), max, 0.001, TEST_LOCATION);
+  END_TEST;
+}
+
+int UtcDaliMeshDataBoundingBox(void)
+{
+  TestApplication application;
+
+  float sz=40.0f;
+  MeshData meshData;
+  Vector4 min(-1.0f, -2.0f, -3.0f, 0.0f);
+  Vector4 max(1.0f, 2.0f, 3.0f, 0.0f);
+  meshData.SetBoundingBoxMin(min);
+  meshData.SetBoundingBoxMax(max);
+  DALI_TEST_EQUALS(meshData.GetBoundingBoxMin(), min, 0.001, TEST_LOCATION);
+  DALI_TEST_EQUALS(meshData.GetBoundingBoxMax(), max, 0.001, TEST_LOCATION);
+
+  MeshData::VertexContainer    vertices;
+  MeshData::FaceIndices        faces;
+  BoneContainer                bones;
+  ConstructVertices(vertices, sz);
+  ConstructFaces(vertices, faces);
+  Material customMaterial = ConstructMaterial();
+  meshData.SetData(vertices, faces, bones, customMaterial);
+
+  // Check bounding box hasn't changed
+  DALI_TEST_EQUALS(meshData.GetBoundingBoxMin(), min, 0.001, TEST_LOCATION);
+  DALI_TEST_EQUALS(meshData.GetBoundingBoxMax(), max, 0.001, TEST_LOCATION);
+
+  Vector4 upper(-1e10f, -1e10f, -1e10f, 0.0f);
+  Vector4 lower(1e10f, 1e10f, 1e10f, 0.0f);
+  meshData.AddToBoundingVolume(lower, upper, Matrix::IDENTITY);
+
+  // Bounding box should have been update
+  Vector4 bbMin(-sz*0.5f, -sz,      -sz*0.7f, 0.0f);
+  Vector4 bbMax( sz*0.5f,  sz*0.3f,  sz*0.5f, 0.0f);
+
+  // Test that upper and lower bounds are set and transformed
+  DALI_TEST_EQUALS(lower, bbMin, 0.001, TEST_LOCATION);
+  DALI_TEST_EQUALS(upper, bbMax, 0.001, TEST_LOCATION);
+
+  // Test that mesh's upper and lower bounds are set and not transformed
+  DALI_TEST_EQUALS(meshData.GetBoundingBoxMin(), bbMin, 0.001, TEST_LOCATION);
+  DALI_TEST_EQUALS(meshData.GetBoundingBoxMax(), bbMax, 0.001, TEST_LOCATION);
+  END_TEST;
+}
+
+int UtcDaliMeshDataGetVertexCount(void)
+{
+  TestApplication application;
+
+  MeshData meshData;
+  MeshData::VertexContainer    vertices;
+  MeshData::FaceIndices        faces;
+  BoneContainer                bones;
+  ConstructVertices(vertices, 30);
+  ConstructFaces(vertices, faces);
+  Material customMaterial = ConstructMaterial();
+
+  DALI_TEST_EQUALS(meshData.GetVertexCount(), static_cast<size_t>(0), TEST_LOCATION);
+
+  meshData.SetData(vertices, faces, bones, customMaterial);
+  DALI_TEST_EQUALS(meshData.GetVertexCount(), vertices.size(), TEST_LOCATION);
+
+  END_TEST;
+}
+
+int UtcDaliMeshDataGetVertices(void)
+{
+  TestApplication application;
+  MeshData meshData;
+  const Dali::MeshData::VertexContainer& verts1 = meshData.GetVertices();
+  DALI_TEST_CHECK(verts1.size() == 0);
+
+  MeshData::VertexContainer    vertices;
+  MeshData::FaceIndices        faces;
+  BoneContainer                bones;
+  ConstructVertices(vertices, 30);
+  ConstructFaces(vertices, faces);
+  Material customMaterial = ConstructMaterial();
+  meshData.SetData(vertices, faces, bones, customMaterial);
+
+  const Dali::MeshData::VertexContainer& verts2 = meshData.GetVertices();
+  DALI_TEST_CHECK(verts2.size() != 0);
+  DALI_TEST_CHECK(verts2.size() == meshData.GetVertexCount());
+  END_TEST;
+}
+
+int UtcDaliMeshDataGetFaceCount(void)
+{
+  TestApplication application;
+  MeshData meshData;
+  DALI_TEST_EQUALS(meshData.GetFaceCount(), static_cast<size_t>(0), TEST_LOCATION);
+
+  MeshData::VertexContainer    vertices;
+  MeshData::FaceIndices        faces;
+  BoneContainer                bones;
+  ConstructVertices(vertices, 30);
+  ConstructFaces(vertices, faces);
+  Material customMaterial = ConstructMaterial();
+  meshData.SetData(vertices, faces, bones, customMaterial);
+
+  DALI_TEST_EQUALS(meshData.GetFaceCount(), faces.size() / 3, TEST_LOCATION);
+  END_TEST;
+}
+
+int UtcDaliMeshDataGetFaces(void)
+{
+  TestApplication application;
+  MeshData meshData;
+  const Dali::MeshData::FaceIndices& faces1 = meshData.GetFaces();
+  DALI_TEST_CHECK(faces1.size() == 0);
+
+  MeshData::VertexContainer    vertices;
+  MeshData::FaceIndices        faces;
+  BoneContainer                bones;
+  ConstructVertices(vertices, 30);
+  ConstructFaces(vertices, faces);
+  Material customMaterial = ConstructMaterial();
+  meshData.SetData(vertices, faces, bones, customMaterial);
+
+  const Dali::MeshData::FaceIndices& faces2 = meshData.GetFaces();
+  DALI_TEST_CHECK(faces2.size() != 0);
+  END_TEST;
+}
+
+int UtcDaliMeshDataTextureCoords(void)
+{
+  TestApplication application;
+  MeshData meshData;
+  DALI_TEST_EQUALS(meshData.HasTextureCoords(), false, TEST_LOCATION);
+  meshData.SetHasTextureCoords(true);
+  DALI_TEST_EQUALS(meshData.HasTextureCoords(), true, TEST_LOCATION);
+  END_TEST;
+}
+
+int UtcDaliMeshDataNormals(void)
+{
+  TestApplication application;
+  MeshData meshData;
+  DALI_TEST_EQUALS(meshData.HasNormals(), false, TEST_LOCATION);
+  meshData.SetHasNormals(true);
+  DALI_TEST_EQUALS(meshData.HasNormals(), true, TEST_LOCATION);
+  END_TEST;
+}
+
+int UtcDaliMeshDataGetMaterial(void)
+{
+  TestApplication application;
+  MeshData meshData;
+  Material aMat = meshData.GetMaterial();
+  DALI_TEST_CHECK(!aMat);
+
+  MeshData::VertexContainer    vertices;
+  MeshData::FaceIndices        faces;
+  BoneContainer                bones;
+  ConstructVertices(vertices, 30);
+  ConstructFaces(vertices, faces);
+  Material customMaterial = ConstructMaterial();
+  meshData.SetData(vertices, faces, bones, customMaterial);
+
+  aMat = meshData.GetMaterial();
+  DALI_TEST_CHECK(aMat);
+  END_TEST;
+}
+
+int UtcDaliMeshDataSetMaterial(void)
+{
+  TestApplication application;
+  MeshData meshData;
+
+  Material aMat = meshData.GetMaterial();
+  DALI_TEST_CHECK(!aMat);
+
+  Material mat1 = ConstructMaterial();
+  meshData.SetMaterial(mat1);
+  aMat = meshData.GetMaterial();
+  DALI_TEST_CHECK(mat1 == aMat);
+
+  MeshData::VertexContainer    vertices;
+  MeshData::FaceIndices        faces;
+  BoneContainer                bones;
+  ConstructVertices(vertices, 30);
+  ConstructFaces(vertices, faces);
+  Material customMaterial = ConstructMaterial();
+  meshData.SetData(vertices, faces, bones, customMaterial);
+
+  aMat = meshData.GetMaterial();
+
+  DALI_TEST_CHECK(aMat == customMaterial);
+  DALI_TEST_CHECK(aMat != mat1);
+
+  END_TEST;
+}
+
+int UtcDaliMeshDataGetBoneCount(void)
+{
+  TestApplication application;
+  MeshData meshData;
+  DALI_TEST_EQUALS(meshData.GetBoneCount(), static_cast<size_t>(0), TEST_LOCATION);
+  DALI_TEST_EQUALS(meshData.HasBones(), false, TEST_LOCATION);
+
+  MeshData::VertexContainer    vertices;
+  MeshData::FaceIndices        faces;
+  BoneContainer                bones;
+  ConstructVertices(vertices, 30);
+  ConstructFaces(vertices, faces);
+  ConstructBones(bones);
+  Material customMaterial = ConstructMaterial();
+  meshData.SetData(vertices, faces, bones, customMaterial);
+
+  DALI_TEST_EQUALS(meshData.GetBoneCount(), static_cast<size_t>(3), TEST_LOCATION);
+  DALI_TEST_EQUALS(meshData.HasBones(), true, TEST_LOCATION);
+  END_TEST;
+}
+
+
+int UtcDaliMeshDataGetBones(void)
+{
+  TestApplication application;
+  MeshData meshData;
+  DALI_TEST_EQUALS(meshData.GetBoneCount(), static_cast<size_t>(0), TEST_LOCATION);
+  const BoneContainer& bones1 = meshData.GetBones();
+  DALI_TEST_CHECK(bones1.empty());
+
+  MeshData::VertexContainer    vertices;
+  MeshData::FaceIndices        faces;
+  BoneContainer                bones;
+  ConstructVertices(vertices, 30);
+  ConstructFaces(vertices, faces);
+  ConstructBones(bones);
+  Material customMaterial = ConstructMaterial();
+  meshData.SetData(vertices, faces, bones, customMaterial);
+  const BoneContainer& bones3 = meshData.GetBones();
+  DALI_TEST_CHECK( ! bones3.empty() );
+  END_TEST;
+}
diff --git a/automated-tests/src/dali-internal/utc-Dali-Mutex.cpp b/automated-tests/src/dali-internal/utc-Dali-Mutex.cpp
new file mode 100644 (file)
index 0000000..2911d6c
--- /dev/null
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2015 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+#include <stdlib.h>
+#include <unistd.h>
+#include <dali/public-api/dali-core.h>
+#include <dali/devel-api/common/mutex.h>
+#include <dali-test-suite-utils.h>
+
+using Dali::Mutex;
+
+int UtcDaliMutexSingleThread(void)
+{
+  tet_infoline("Testing Dali::Mutex in a single thread");
+
+  {
+    Mutex mutex1;
+    DALI_TEST_EQUALS( false, mutex1.IsLocked(), TEST_LOCATION );
+  }
+
+  {
+    Mutex mutex2;
+    Mutex::ScopedLock lock( mutex2 );
+    DALI_TEST_EQUALS( true, mutex2.IsLocked(), TEST_LOCATION );
+  }
+
+  Mutex mutex3;
+  {
+    Mutex::ScopedLock lock( mutex3 );
+  }
+  DALI_TEST_EQUALS( false, mutex3.IsLocked(), TEST_LOCATION );
+
+  END_TEST;
+}
+
+namespace // for local variables to avoid name clashes
+{
+int gGlobalValue = 0;
+Mutex* gGlobalValueMutex;
+bool gWorkerThreadWait = true;
+enum ThreadState { INIT, RUN, LOCKING, TERMINATE } gWorkerThreadState = INIT;
+}
+void* WorkerThread1( void* ptr )
+{
+  gWorkerThreadState = RUN;
+  {
+    Mutex::ScopedLock lock( *gGlobalValueMutex );
+    gWorkerThreadState = LOCKING;
+    gGlobalValue = -1;
+    while( gWorkerThreadWait ) // wait till we can exit
+    {
+      usleep( 1 ); // 1 microsecond
+    }
+  }
+  gWorkerThreadState = TERMINATE;
+  return NULL;
+}
+
+int UtcDaliMutexMultiThread(void)
+{
+  tet_infoline("Testing Dali::Mutex multithreaded");
+
+  gGlobalValueMutex = new Dali::Mutex;
+
+  pthread_t thread1;
+  // initialize values
+  gGlobalValue = 0;
+  gWorkerThreadWait = true;
+  DALI_TEST_EQUALS( INIT, gWorkerThreadState, TEST_LOCATION );
+  DALI_TEST_EQUALS( 0, gGlobalValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( false, gGlobalValueMutex->IsLocked(), TEST_LOCATION );
+
+  // lock the mutex
+  {
+    Mutex::ScopedLock lock( *gGlobalValueMutex );
+    DALI_TEST_EQUALS( true, gGlobalValueMutex->IsLocked(), TEST_LOCATION );
+    pthread_create( &thread1, NULL, &WorkerThread1, NULL );
+    // wait till the thread is in run state
+    while( RUN != gWorkerThreadState )
+    {
+      usleep( 1 ); // 1 microsecond
+    }
+    // now the thread is running and mutex is still locked by this thread so value is not changed
+    DALI_TEST_EQUALS( true, gGlobalValueMutex->IsLocked(), TEST_LOCATION );
+    DALI_TEST_EQUALS( 0, gGlobalValue, TEST_LOCATION );
+    // drop out of scope, releases our lock
+  }
+  // now child thread is allowed to change the value
+  // wait till the thread is in locking state
+  while( LOCKING != gWorkerThreadState )
+  {
+    usleep( 1 ); // 1 microsecond
+  }
+  // mutex is locked, but not by us, by the child thread
+  DALI_TEST_EQUALS( true, gGlobalValueMutex->IsLocked(), TEST_LOCATION );
+  // value is changed
+  DALI_TEST_EQUALS( -1, gGlobalValue, TEST_LOCATION );
+  // let worker finish
+  gWorkerThreadWait = false;
+  // wait till the thread is terminated state
+  while( TERMINATE != gWorkerThreadState )
+  {
+    usleep( 1 ); // 1 microsecond
+  }
+  DALI_TEST_EQUALS( false, gGlobalValueMutex->IsLocked(), TEST_LOCATION );
+  void* exitValue;
+  pthread_join( thread1, &exitValue );
+
+  END_TEST;
+}
+
+int UtcDaliMutexNonCopyable(void)
+{
+  // we want to make sure that mutex is not copyable (its copy constructor is not defined)
+  // this test will stop compiling if Mutex has compiler generated copy constructor
+  DALI_COMPILE_TIME_ASSERT( !__has_trivial_copy( Mutex ) );
+
+  DALI_TEST_CHECK( true );
+  END_TEST;
+}
+
+
diff --git a/automated-tests/src/dali-internal/utc-Dali-Scripting.cpp b/automated-tests/src/dali-internal/utc-Dali-Scripting.cpp
new file mode 100644 (file)
index 0000000..981e506
--- /dev/null
@@ -0,0 +1,1012 @@
+/*
+ * Copyright (c) 2014 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+
+#include <stdlib.h>
+#include <dali/public-api/dali-core.h>
+#include <dali/devel-api/scripting/scripting.h>
+#include <dali-test-suite-utils.h>
+
+using namespace Dali;
+using namespace Dali::Scripting;
+
+namespace
+{
+
+const StringEnum< int > COLOR_MODE_VALUES[] =
+{
+    { "USE_OWN_COLOR", USE_OWN_COLOR },
+    { "USE_PARENT_COLOR", USE_PARENT_COLOR },
+    { "USE_OWN_MULTIPLY_PARENT_COLOR", USE_OWN_MULTIPLY_PARENT_COLOR },
+    { "USE_OWN_MULTIPLY_PARENT_ALPHA", USE_OWN_MULTIPLY_PARENT_ALPHA },
+};
+const unsigned int COLOR_MODE_VALUES_COUNT = sizeof( COLOR_MODE_VALUES ) / sizeof( COLOR_MODE_VALUES[0] );
+
+const StringEnum< int > POSITION_INHERITANCE_MODE_VALUES[] =
+{
+    { "INHERIT_PARENT_POSITION", INHERIT_PARENT_POSITION },
+    { "USE_PARENT_POSITION", USE_PARENT_POSITION },
+    { "USE_PARENT_POSITION_PLUS_LOCAL_POSITION", USE_PARENT_POSITION_PLUS_LOCAL_POSITION },
+    { "DONT_INHERIT_POSITION", DONT_INHERIT_POSITION },
+};
+const unsigned int POSITION_INHERITANCE_MODE_VALUES_COUNT = sizeof( POSITION_INHERITANCE_MODE_VALUES ) / sizeof( POSITION_INHERITANCE_MODE_VALUES[0] );
+
+const StringEnum< int > DRAW_MODE_VALUES[] =
+{
+    { "NORMAL", DrawMode::NORMAL },
+    { "OVERLAY", DrawMode::OVERLAY },
+    { "STENCIL", DrawMode::STENCIL },
+};
+const unsigned int DRAW_MODE_VALUES_COUNT = sizeof( DRAW_MODE_VALUES ) / sizeof( DRAW_MODE_VALUES[0] );
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Helpers for string to enum comparisons for Image and Image loading parameters
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Template to check enumerations of type T, with a class of type X
+ */
+template< typename T, typename X >
+void TestEnumStrings(
+  Property::Map& map,                       // The map used to create instance of type X
+  const StringEnum< int >* values,          // An array of string values
+  unsigned int num,                         // Number of items in the array
+  T ( X::*method )() const,                 // The member method of X to call to get the enum
+  X ( *creator ) ( const Property::Value& ) // The method which creates an instance of type X
+)
+{
+  const unsigned int lastIndex( map.Count() - 1 );
+  const std::string& key = map.GetKey( lastIndex );
+  Property::Value& value = map.GetValue( lastIndex );
+
+  for ( unsigned int i = 0; i < num; ++i )
+  {
+    value = values[i].string;
+    tet_printf("Checking: %s: %s\n", key.c_str(), values[i].string );
+    X instance = creator( map );
+    DALI_TEST_EQUALS( values[i].value, ( instance.*method )(), TEST_LOCATION );
+  }
+}
+
+/// Helper method to create ResourceImage using property
+ResourceImage NewResourceImage( const Property::Value& map )
+{
+  ResourceImage image = ResourceImage::DownCast( NewImage( map ) );
+  return image;
+}
+
+/// Helper method to create ResourceImage using property
+BufferImage NewBufferImage( const Property::Value& map )
+{
+  BufferImage image = BufferImage::DownCast( NewImage( map ) );
+  return image;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Helpers for string to enum comparisons for Actor to Property::Map
+//////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Template to check enumerations of type T
+ */
+template< typename T >
+void TestEnumStrings(
+  const char * const keyName,               // The name of the key to check
+  TestApplication& application,             // Reference to the application class
+  const StringEnum< int >* values,          // An array of string values
+  unsigned int num,                         // Number of items in the array
+  void ( Actor::*method )( T )              // The Actor member method to set the enumeration
+)
+{
+  for ( unsigned int i = 0; i < num; ++i )
+  {
+    tet_printf("Checking: %s: %s\n", keyName, values[i].string );
+
+    Actor actor = Actor::New();
+    (actor.*method)( ( T ) values[i].value );
+
+    Stage::GetCurrent().Add( actor );
+    application.SendNotification();
+    application.Render();
+
+    Property::Map map;
+    CreatePropertyMap( actor, map );
+
+    DALI_TEST_CHECK( map.Count() );
+    Property::Value value( map );
+    DALI_TEST_CHECK( value.HasKey( keyName ) );
+    DALI_TEST_EQUALS( value.GetValue( keyName ).Get< std::string >(), values[i].string, TEST_LOCATION );
+
+    Stage::GetCurrent().Remove( actor );
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+
+} // anon namespace
+
+
+
+int UtcDaliScriptingGetColorMode(void)
+{
+  TestApplication application;
+
+  for ( unsigned int i = 0; i < COLOR_MODE_VALUES_COUNT; ++i )
+  {
+    tet_printf( "Checking %s == %d\n", COLOR_MODE_VALUES[i].string, COLOR_MODE_VALUES[i].value );
+    DALI_TEST_EQUALS( COLOR_MODE_VALUES[i].value, GetColorMode( COLOR_MODE_VALUES[i].string ), TEST_LOCATION );
+    DALI_TEST_EQUALS( COLOR_MODE_VALUES[i].string, GetColorMode( (ColorMode) COLOR_MODE_VALUES[i].value ), TEST_LOCATION );
+  }
+
+  try
+  {
+    (void)GetColorMode("INVALID_ARG");
+    tet_result( TET_FAIL );
+  }
+  catch ( DaliException& e )
+  {
+    DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
+  }
+  END_TEST;
+}
+
+int UtcDaliScriptingGetPositionInheritanceMode(void)
+{
+  TestApplication application;
+
+  for ( unsigned int i = 0; i < POSITION_INHERITANCE_MODE_VALUES_COUNT; ++i )
+  {
+    tet_printf( "Checking %s == %d\n", POSITION_INHERITANCE_MODE_VALUES[i].string, POSITION_INHERITANCE_MODE_VALUES[i].value );
+    DALI_TEST_EQUALS( POSITION_INHERITANCE_MODE_VALUES[i].value, GetPositionInheritanceMode( POSITION_INHERITANCE_MODE_VALUES[i].string ), TEST_LOCATION );
+    DALI_TEST_EQUALS( POSITION_INHERITANCE_MODE_VALUES[i].string, GetPositionInheritanceMode( (PositionInheritanceMode) POSITION_INHERITANCE_MODE_VALUES[i].value ), TEST_LOCATION );
+  }
+
+  try
+  {
+    (void)GetPositionInheritanceMode("INVALID_ARG");
+    tet_result( TET_FAIL );
+  }
+  catch ( DaliException& e )
+  {
+    DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
+  }
+  END_TEST;
+}
+
+
+int UtcDaliScriptingGetDrawMode(void)
+{
+  TestApplication application;
+
+  for ( unsigned int i = 0; i < DRAW_MODE_VALUES_COUNT; ++i )
+  {
+    tet_printf( "Checking %s == %d\n", DRAW_MODE_VALUES[i].string, DRAW_MODE_VALUES[i].value );
+    DALI_TEST_EQUALS( DRAW_MODE_VALUES[i].value, GetDrawMode( DRAW_MODE_VALUES[i].string ), TEST_LOCATION );
+    DALI_TEST_EQUALS( DRAW_MODE_VALUES[i].string, GetDrawMode( (DrawMode::Type) DRAW_MODE_VALUES[i].value ), TEST_LOCATION );
+  }
+
+  try
+  {
+    (void)GetDrawMode("INVALID_ARG");
+    tet_result( TET_FAIL );
+  }
+  catch ( DaliException& e )
+  {
+    DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
+  }
+  END_TEST;
+}
+
+int UtcDaliScriptingGetAnchorConstant(void)
+{
+  TestApplication application;
+
+  DALI_TEST_EQUALS( Dali::ParentOrigin::TOP_LEFT, GetAnchorConstant( "TOP_LEFT" ), TEST_LOCATION );
+  DALI_TEST_EQUALS( Dali::ParentOrigin::TOP_CENTER, GetAnchorConstant( "TOP_CENTER" ), TEST_LOCATION );
+  DALI_TEST_EQUALS( Dali::ParentOrigin::TOP_RIGHT, GetAnchorConstant( "TOP_RIGHT" ), TEST_LOCATION );
+  DALI_TEST_EQUALS( Dali::ParentOrigin::CENTER_LEFT, GetAnchorConstant( "CENTER_LEFT" ), TEST_LOCATION );
+  DALI_TEST_EQUALS( Dali::ParentOrigin::CENTER, GetAnchorConstant( "CENTER" ), TEST_LOCATION );
+  DALI_TEST_EQUALS( Dali::ParentOrigin::CENTER_RIGHT, GetAnchorConstant( "CENTER_RIGHT" ), TEST_LOCATION );
+  DALI_TEST_EQUALS( Dali::ParentOrigin::BOTTOM_LEFT, GetAnchorConstant( "BOTTOM_LEFT" ), TEST_LOCATION );
+  DALI_TEST_EQUALS( Dali::ParentOrigin::BOTTOM_CENTER, GetAnchorConstant( "BOTTOM_CENTER" ), TEST_LOCATION );
+  DALI_TEST_EQUALS( Dali::ParentOrigin::BOTTOM_RIGHT, GetAnchorConstant( "BOTTOM_RIGHT" ), TEST_LOCATION );
+
+  try
+  {
+    (void)GetAnchorConstant("INVALID_ARG");
+    tet_result( TET_FAIL );
+  }
+  catch ( DaliException& e )
+  {
+    DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
+  }
+  END_TEST;
+}
+
+int UtcDaliScriptingNewImageNegative(void)
+{
+  TestApplication application;
+
+  // Invalid filename
+  try
+  {
+    Property::Map map;
+    map[ "filename" ] = Vector3::ZERO;
+    Image image = NewImage( map );
+    tet_result( TET_FAIL );
+  }
+  catch ( DaliException& e )
+  {
+    DALI_TEST_ASSERT( e, "map.GetValue(field).GetType()", TEST_LOCATION );
+  }
+
+  // Invalid load-policy
+  try
+  {
+    Property::Map map;
+    map[ "load-policy" ] = Vector3::ZERO;
+    Image image = NewImage( map );
+    tet_result( TET_FAIL );
+  }
+  catch ( DaliException& e )
+  {
+    DALI_TEST_ASSERT( e, "map.GetValue(field).GetType()", TEST_LOCATION );
+
+    // Invalid value
+    try
+    {
+      Property::Map map;
+      map[ "load-policy" ] = "INVALID";
+      Image image = NewImage( map );
+      tet_result( TET_FAIL );
+    }
+    catch ( DaliException& e )
+    {
+      DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
+    }
+  }
+
+  // Invalid release-policy
+  try
+  {
+    Property::Map map;
+    map[ "release-policy" ] = Vector3::ZERO;
+    Image image = NewImage( map );
+    tet_result( TET_FAIL );
+  }
+  catch ( DaliException& e )
+  {
+    DALI_TEST_ASSERT( e, "map.GetValue(field).GetType()", TEST_LOCATION );
+
+    // Invalid value
+    try
+    {
+      Property::Map map;
+      map[ "release-policy" ] = "INVALID";
+      Image image = NewImage( map );
+      tet_result( TET_FAIL );
+    }
+    catch ( DaliException& e )
+    {
+      DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
+    }
+  }
+
+  // Invalid width
+  try
+  {
+    Property::Map map;
+    map[ "width" ] = "Invalid";
+    map[ "height" ] = "Invalid";
+    Image image = NewImage( map );
+    tet_result( TET_FAIL );
+  }
+  catch ( DaliException& e )
+  {
+    DALI_TEST_ASSERT( e, "value.GetType()", TEST_LOCATION );
+  }
+
+  // Invalid height
+  try
+  {
+    Property::Map map;
+    map[ "width" ] = 10;
+    map[ "height" ] = "Invalid";
+    Image image = NewImage( map );
+    tet_result( TET_FAIL );
+  }
+  catch ( DaliException& e )
+  {
+    DALI_TEST_ASSERT( e, "value.GetType()", TEST_LOCATION );
+  }
+
+  // Invalid fitting-mode
+  try
+  {
+    Property::Map map;
+    map[ "fitting-mode" ] = Vector3::ZERO;
+    Image image = NewImage( map );
+    DALI_TEST_EQUALS( "Expected exception to be thrown", "But exception was not thrown", TEST_LOCATION );
+  }
+  catch ( DaliException& e )
+  {
+    DALI_TEST_ASSERT( e, "value.GetType() == Property::STRING", TEST_LOCATION );
+
+    // Invalid value
+    try
+    {
+      Property::Map map;
+      map[ "fitting-mode" ] = "INVALID";
+      Image image = NewImage( map );
+      DALI_TEST_EQUALS( "Expected exception to be thrown", "But exception was not thrown", TEST_LOCATION );
+    }
+    catch ( DaliException& e )
+    {
+      DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
+    }
+  }
+
+  // Invalid scaling-mode
+  try
+  {
+    Property::Map map;
+    map[ "sampling-mode" ] = Vector3::ZERO;
+    Image image = NewImage( map );
+    DALI_TEST_EQUALS( "Expected exception to be thrown", "But exception was not thrown", TEST_LOCATION );
+  }
+  catch ( DaliException& e )
+  {
+    DALI_TEST_ASSERT( e, "value.GetType() == Property::STRING", TEST_LOCATION );
+
+    // Invalid value
+    try
+    {
+      Property::Map map;
+      map[ "sampling-mode" ] = "INVALID";
+      Image image = NewImage( map );
+      DALI_TEST_EQUALS( "Expected exception to be thrown", "But exception was not thrown", TEST_LOCATION );
+    }
+    catch ( DaliException& e )
+    {
+      DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
+    }
+  }
+
+  // Invalid orientation-correction
+  try
+  {
+    Property::Map map;
+    map[ "orientation" ] = Vector3::ZERO;
+    Image image = NewImage( map );
+    DALI_TEST_EQUALS( "Expected exception to be thrown", "But exception was not thrown", TEST_LOCATION );
+  }
+  catch ( DaliException& e )
+  {
+    DALI_TEST_ASSERT( e, "value.GetType() == Property::BOOLEAN", TEST_LOCATION );
+  }
+
+  // Invalid type
+  try
+  {
+    Property::Map map;
+    map[ "type" ] = Vector3::ZERO;
+    Image image = NewImage( map );
+    tet_result( TET_FAIL );
+  }
+  catch ( DaliException& e )
+  {
+    DALI_TEST_ASSERT( e, "map.GetValue(\"type\").GetType()", TEST_LOCATION );
+
+    // Invalid value
+    try
+    {
+      Property::Map map;
+      map[ "type" ] = "INVALID";
+      Image image = NewImage( map );
+      tet_result( TET_FAIL );
+    }
+    catch ( DaliException& e )
+    {
+      DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
+    }
+  }
+
+  // Invalid pixel-format
+  try
+  {
+    Property::Map map;
+    map[ "pixel-format" ] = Vector3::ZERO;
+    Image image = NewImage( map );
+    tet_result( TET_FAIL );
+  }
+  catch ( DaliException& e )
+  {
+    DALI_TEST_ASSERT( e, "map.GetValue(field).GetType()", TEST_LOCATION );
+
+    // Invalid value
+    try
+    {
+      Property::Map map;
+      map[ "pixel-format" ] = "INVALID";
+      Image image = NewImage( map );
+      tet_result( TET_FAIL );
+    }
+    catch ( DaliException& e )
+    {
+      DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
+    }
+  }
+
+  END_TEST;
+}
+
+
+int UtcDaliScriptingNewImage(void)
+{
+  TestApplication application;
+
+  Property::Map map;
+  map[ "filename" ] = "TEST_FILE";
+
+  // Filename only
+  {
+    ResourceImage image = ResourceImage::DownCast( NewImage( map ) );
+    DALI_TEST_EQUALS( "TEST_FILE", image.GetUrl(), TEST_LOCATION );
+  }
+
+  // load-policy
+  map[ "load-policy" ] = "";
+  {
+    const StringEnum< int > values[] =
+    {
+        { "IMMEDIATE", ResourceImage::IMMEDIATE },
+        { "ON_DEMAND", ResourceImage::ON_DEMAND }
+    };
+   TestEnumStrings< ResourceImage::LoadPolicy, ResourceImage >( map, values, ( sizeof( values ) / sizeof ( values[0] ) ), &ResourceImage::GetLoadPolicy, &NewResourceImage );
+  }
+
+  // release-policy
+  map[ "release-policy" ] = "";
+  {
+    const StringEnum< int > values[] =
+    {
+        { "UNUSED", Image::UNUSED },
+        { "NEVER", Image::NEVER }
+    };
+    TestEnumStrings< Image::ReleasePolicy, Image >( map, values, ( sizeof( values ) / sizeof ( values[0] ) ), &Image::GetReleasePolicy, &NewImage );
+  }
+
+  // float width and height
+  map[ "width" ] = (float) 10.0f;
+  map[ "height" ] = (float) 20.0f;
+  {
+    Image image = NewImage( map );
+    DALI_TEST_EQUALS( image.GetWidth(), 10.0f, TEST_LOCATION );
+    DALI_TEST_EQUALS( image.GetHeight(), 20.0f, TEST_LOCATION );
+  }
+
+  // int width and height
+  map[ "width"] = (int) 50;
+  map[ "height" ] = (int) 70;
+  {
+    Image image = NewImage( map );
+    DALI_TEST_EQUALS( image.GetWidth(), 50u, TEST_LOCATION );
+    DALI_TEST_EQUALS( image.GetHeight(), 70u, TEST_LOCATION );
+  }
+
+  //map.erase( map.end() - 2, map.end() );
+
+  // type FrameBufferImage
+  map[ "type" ] = "FrameBufferImage";
+  {
+    Image image = NewImage( map );
+    DALI_TEST_CHECK( FrameBufferImage::DownCast( image ) );
+  }
+  // type BufferImage
+   map[ "type" ] = "BufferImage";
+   {
+     Image image = NewImage( map );
+     DALI_TEST_CHECK( BufferImage::DownCast( image ) );
+     DALI_TEST_CHECK((BufferImage::DownCast( image )).GetPixelFormat()== Pixel::RGBA8888);
+   }
+
+   // pixel-format
+   map[ "pixel-format" ] = "";
+   {
+     const StringEnum< int > values[] =
+     {
+         { "A8", Pixel::A8 },
+         { "L8", Pixel::L8 },
+         { "LA88", Pixel::LA88 },
+         { "RGB565", Pixel::RGB565 },
+         { "BGR565", Pixel::BGR565 },
+         { "RGBA4444", Pixel::RGBA4444 },
+         { "BGRA4444", Pixel::BGRA4444 },
+         { "RGBA5551", Pixel::RGBA5551 },
+         { "BGRA5551", Pixel::BGRA5551 },
+         { "RGB888", Pixel::RGB888 },
+         { "RGB8888", Pixel::RGB8888 },
+         { "BGR8888", Pixel::BGR8888 },
+         { "RGBA8888", Pixel::RGBA8888 },
+         { "BGRA8888", Pixel::BGRA8888 },
+       /*{ "COMPRESSED_R11_EAC", Pixel::COMPRESSED_R11_EAC },
+         { "COMPRESSED_SIGNED_R11_EAC", Pixel::COMPRESSED_SIGNED_R11_EAC },
+         { "COMPRESSED_RG11_EAC", Pixel::COMPRESSED_RG11_EAC },
+         { "COMPRESSED_SIGNED_RG11_EAC", Pixel::COMPRESSED_SIGNED_RG11_EAC },
+         { "COMPRESSED_RGB8_ETC2", Pixel::COMPRESSED_RGB8_ETC2 },
+         { "COMPRESSED_SRGB8_ETC2", Pixel::COMPRESSED_SRGB8_ETC2 },
+         { "COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2", Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 },
+         { "COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2", Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 },
+         { "COMPRESSED_RGBA8_ETC2_EAC", Pixel::COMPRESSED_RGBA8_ETC2_EAC },
+         { "COMPRESSED_SRGB8_ALPHA8_ETC2_EAC", Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC },
+         { "COMPRESSED_RGB8_ETC1", Pixel::COMPRESSED_RGB8_ETC1 },
+         { "COMPRESSED_RGB_PVRTC_4BPPV1", Pixel::COMPRESSED_RGB_PVRTC_4BPPV1 },*/
+         // BufferImage does not support compressed formats
+     };
+
+     TestEnumStrings< Pixel::Format, BufferImage >( map, values, ( sizeof( values ) / sizeof ( values[0] ) ), &BufferImage::GetPixelFormat, &NewBufferImage );
+   }
+
+  // type Image
+  map[ "type" ] = "ResourceImage";
+  {
+    Image image = NewImage( map );
+    DALI_TEST_CHECK( ResourceImage::DownCast( image ) );
+    DALI_TEST_CHECK( !FrameBufferImage::DownCast( image ) );
+    DALI_TEST_CHECK( !BufferImage::DownCast( image ) );
+  }
+  END_TEST;
+}
+
+int UtcDaliScriptingNewShaderEffect(void)
+{
+  TestApplication application;
+
+  Property::Map programMap;
+  programMap[ "vertex-filename" ] = "bump.vert";
+  programMap[ "fragment-filename" ] = "bump.frag";
+
+  Property::Map imageMap;
+  imageMap[ "filename" ] = "image.png";
+
+  Property::Map map;
+  map[ "image" ] = imageMap;
+  map[ "program" ] = programMap;
+  map[ "uLightPosition" ] = Vector3( 0.0, 0.0, -1.5);
+  map[ "uAmbientLight" ] = (int)10;
+
+  ShaderEffect shader = NewShaderEffect( map );
+
+  DALI_TEST_CHECK( shader );
+  END_TEST;
+}
+
+int UtcDaliScriptingNewActorNegative(void)
+{
+  TestApplication application;
+
+  // Empty map
+  {
+    Actor handle = NewActor( Property::Map() );
+    DALI_TEST_CHECK( !handle );
+  }
+
+  // Map with only properties
+  {
+    Property::Map map;
+    map[ "parent-origin" ] = ParentOrigin::TOP_CENTER;
+    map[ "anchor-point" ] = AnchorPoint::TOP_CENTER;
+    Actor handle = NewActor( map );
+    DALI_TEST_CHECK( !handle );
+  }
+
+  // Add some signals to the map, we should have no signal connections as its not yet supported
+  {
+    Property::Map map;
+    map[ "type" ] = "Actor";
+    map[ "signals" ] = Property::MAP;
+    Actor handle = NewActor( map );
+    DALI_TEST_CHECK( handle );
+    DALI_TEST_CHECK( !handle.MouseWheelEventSignal().GetConnectionCount() );
+    DALI_TEST_CHECK( !handle.OffStageSignal().GetConnectionCount() );
+    DALI_TEST_CHECK( !handle.OnStageSignal().GetConnectionCount() );
+    DALI_TEST_CHECK( !handle.TouchedSignal().GetConnectionCount() );
+  }
+  END_TEST;
+}
+
+int UtcDaliScriptingNewActorProperties(void)
+{
+  TestApplication application;
+
+  Property::Map map;
+  map[ "type" ] = "Actor";
+  map[ "size" ] = Vector3::ONE;
+  map[ "position" ] = Vector3::XAXIS;
+  map[ "scale" ] = Vector3::ONE;
+  map[ "visible" ] = false;
+  map[ "color" ] = Color::MAGENTA;
+  map[ "name" ] = "MyActor";
+  map[ "color-mode" ] = "USE_PARENT_COLOR";
+  map[ "inherit-shader-effect" ] = false;
+  map[ "sensitive" ] = false;
+  map[ "leave-required" ] = true;
+  map[ "position-inheritance" ] = "DONT_INHERIT_POSITION";
+  map[ "draw-mode" ] = "STENCIL";
+  map[ "inherit-orientation" ] = false;
+  map[ "inherit-scale" ] = false;
+
+  // Default properties
+  {
+    Actor handle = NewActor( map );
+    DALI_TEST_CHECK( handle );
+
+    Stage::GetCurrent().Add( handle );
+    application.SendNotification();
+    application.Render();
+
+    DALI_TEST_EQUALS( handle.GetCurrentSize(), Vector3::ONE, TEST_LOCATION );
+    DALI_TEST_EQUALS( handle.GetCurrentPosition(), Vector3::XAXIS, TEST_LOCATION );
+    DALI_TEST_EQUALS( handle.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
+    DALI_TEST_EQUALS( handle.IsVisible(), false, TEST_LOCATION );
+    DALI_TEST_EQUALS( handle.GetCurrentColor(), Color::MAGENTA, TEST_LOCATION );
+    DALI_TEST_EQUALS( handle.GetName(), "MyActor", TEST_LOCATION );
+    DALI_TEST_EQUALS( handle.GetColorMode(), USE_PARENT_COLOR, TEST_LOCATION );
+    DALI_TEST_EQUALS( handle.IsSensitive(), false, TEST_LOCATION );
+    DALI_TEST_EQUALS( handle.GetLeaveRequired(), true, TEST_LOCATION );
+    DALI_TEST_EQUALS( handle.GetPositionInheritanceMode(), DONT_INHERIT_POSITION, TEST_LOCATION );
+    DALI_TEST_EQUALS( handle.GetDrawMode(), DrawMode::STENCIL, TEST_LOCATION );
+    DALI_TEST_EQUALS( handle.IsOrientationInherited(), false, TEST_LOCATION );
+    DALI_TEST_EQUALS( handle.IsScaleInherited(), false, TEST_LOCATION );
+
+    Stage::GetCurrent().Remove( handle );
+  }
+
+  // Check Anchor point and parent origin vector3s
+  map[ "parent-origin" ] = ParentOrigin::TOP_CENTER;
+  map[ "anchor-point" ] = AnchorPoint::TOP_LEFT;
+  {
+    Actor handle = NewActor( map );
+    DALI_TEST_CHECK( handle );
+
+    Stage::GetCurrent().Add( handle );
+    application.SendNotification();
+    application.Render();
+
+    DALI_TEST_EQUALS( handle.GetCurrentParentOrigin(), ParentOrigin::TOP_CENTER, TEST_LOCATION );
+    DALI_TEST_EQUALS( handle.GetCurrentAnchorPoint(), AnchorPoint::TOP_LEFT, TEST_LOCATION );
+
+    Stage::GetCurrent().Remove( handle );
+  }
+
+  // Check Anchor point and parent origin STRINGS
+  map[ "parent-origin" ] = "TOP_LEFT";
+  map[ "anchor-point" ] = "CENTER_LEFT";
+  {
+    Actor handle = NewActor( map );
+    DALI_TEST_CHECK( handle );
+
+    Stage::GetCurrent().Add( handle );
+    application.SendNotification();
+    application.Render();
+
+    DALI_TEST_EQUALS( handle.GetCurrentParentOrigin(), ParentOrigin::TOP_LEFT, TEST_LOCATION );
+    DALI_TEST_EQUALS( handle.GetCurrentAnchorPoint(), AnchorPoint::CENTER_LEFT, TEST_LOCATION );
+
+    Stage::GetCurrent().Remove( handle );
+  }
+  END_TEST;
+}
+
+int UtcDaliScriptingNewActorChildren(void)
+{
+  TestApplication application;
+
+  Property::Map map;
+  map[ "type" ] = "Actor";
+  map[ "position" ] = Vector3::XAXIS;
+
+  Property::Map child1Map;
+  child1Map[ "type" ] = "ImageActor";
+  child1Map[ "position" ] = Vector3::YAXIS;
+
+  Property::Array childArray;
+  childArray.PushBack( child1Map );
+  map[ "actors" ] = childArray;
+
+  // Create
+  Actor handle = NewActor( map );
+  DALI_TEST_CHECK( handle );
+
+  Stage::GetCurrent().Add( handle );
+  application.SendNotification();
+  application.Render();
+
+  DALI_TEST_EQUALS( handle.GetCurrentPosition(), Vector3::XAXIS, TEST_LOCATION );
+  DALI_TEST_EQUALS( handle.GetChildCount(), 1u, TEST_LOCATION );
+
+  Actor child1 = handle.GetChildAt(0);
+  DALI_TEST_CHECK( child1 );
+  DALI_TEST_CHECK( ImageActor::DownCast( child1 ) );
+  DALI_TEST_EQUALS( child1.GetCurrentPosition(), Vector3::YAXIS, TEST_LOCATION );
+  DALI_TEST_EQUALS( child1.GetChildCount(), 0u, TEST_LOCATION );
+
+  Stage::GetCurrent().Remove( handle );
+  END_TEST;
+}
+
+
+int UtcDaliScriptingCreatePropertyMapActor(void)
+{
+  TestApplication application;
+
+  // Actor Type
+  {
+    Actor actor = Actor::New();
+
+    Property::Map map;
+    CreatePropertyMap( actor, map );
+    DALI_TEST_CHECK( !map.Empty() );
+    Property::Value value( map );
+    DALI_TEST_CHECK( value.HasKey( "type" ) );
+    DALI_TEST_EQUALS( value.GetValue( "type").Get< std::string >(), "Actor", TEST_LOCATION );
+
+    Stage::GetCurrent().Remove( actor );
+  }
+
+  // ImageActor Type
+  {
+    Actor actor = ImageActor::New();
+
+    Property::Map map;
+    CreatePropertyMap( actor, map );
+    DALI_TEST_CHECK( !map.Empty() );
+    Property::Value value( map );
+    DALI_TEST_CHECK( value.HasKey( "type" ) );
+    DALI_TEST_EQUALS( value.GetValue( "type").Get< std::string >(), "ImageActor", TEST_LOCATION );
+
+    Stage::GetCurrent().Remove( actor );
+  }
+
+  // Default properties
+  {
+    Actor actor = Actor::New();
+    actor.SetSize( Vector3::ONE );
+    actor.SetPosition( Vector3::XAXIS );
+    actor.SetScale( Vector3::ZAXIS );
+    actor.SetVisible( false );
+    actor.SetColor( Color::MAGENTA );
+    actor.SetName( "MyActor" );
+    actor.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
+    actor.SetParentOrigin( ParentOrigin::TOP_RIGHT );
+    actor.SetSensitive( false );
+    actor.SetLeaveRequired( true );
+    actor.SetInheritOrientation( false );
+    actor.SetInheritScale( false );
+    actor.SetSizeModeFactor( Vector3::ONE );
+
+    Stage::GetCurrent().Add( actor );
+    application.SendNotification();
+    application.Render();
+
+    Property::Map map;
+    CreatePropertyMap( actor, map );
+
+    DALI_TEST_CHECK( !map.Empty() );
+    Property::Value value( map );
+    DALI_TEST_CHECK( value.HasKey( "size" ) );
+    DALI_TEST_EQUALS( value.GetValue( "size" ).Get< Vector3 >(), Vector3::ONE, TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "position" ) );
+    DALI_TEST_EQUALS( value.GetValue( "position" ).Get< Vector3 >(), Vector3::XAXIS, TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "scale" ) );
+    DALI_TEST_EQUALS( value.GetValue( "scale" ).Get< Vector3 >(), Vector3::ZAXIS, TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "visible" ) );
+    DALI_TEST_EQUALS( value.GetValue( "visible" ).Get< bool >(), false, TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "color" ) );
+    DALI_TEST_EQUALS( value.GetValue( "color" ).Get< Vector4 >(), Color::MAGENTA, TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "name" ) );
+    DALI_TEST_EQUALS( value.GetValue( "name").Get< std::string >(), "MyActor", TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "anchor-point" ) );
+    DALI_TEST_EQUALS( value.GetValue( "anchor-point" ).Get< Vector3 >(), AnchorPoint::CENTER_LEFT, TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "parent-origin" ) );
+    DALI_TEST_EQUALS( value.GetValue( "parent-origin" ).Get< Vector3 >(), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "sensitive" ) );
+    DALI_TEST_EQUALS( value.GetValue( "sensitive" ).Get< bool >(), false, TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "leave-required" ) );
+    DALI_TEST_EQUALS( value.GetValue( "leave-required" ).Get< bool >(), true, TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "inherit-orientation" ) );
+    DALI_TEST_EQUALS( value.GetValue( "inherit-orientation" ).Get< bool >(), false, TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "inherit-scale" ) );
+    DALI_TEST_EQUALS( value.GetValue( "inherit-scale" ).Get< bool >(), false, TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "size-mode-factor" ) );
+    DALI_TEST_EQUALS( value.GetValue( "size-mode-factor" ).Get< Vector3 >(), Vector3::ONE, TEST_LOCATION );
+
+    Stage::GetCurrent().Remove( actor );
+  }
+
+  // ColorMode
+  TestEnumStrings< ColorMode >( "color-mode", application, COLOR_MODE_VALUES, COLOR_MODE_VALUES_COUNT, &Actor::SetColorMode );
+
+  // PositionInheritanceMode
+  TestEnumStrings< PositionInheritanceMode >( "position-inheritance", application, POSITION_INHERITANCE_MODE_VALUES, POSITION_INHERITANCE_MODE_VALUES_COUNT, &Actor::SetPositionInheritanceMode );
+
+  // DrawMode
+  TestEnumStrings< DrawMode::Type >( "draw-mode", application, DRAW_MODE_VALUES, DRAW_MODE_VALUES_COUNT, &Actor::SetDrawMode );
+
+  // Children
+  {
+    Actor actor = Actor::New();
+    Actor child = ImageActor::New();
+    actor.Add( child );
+
+    Stage::GetCurrent().Add( actor );
+    application.SendNotification();
+    application.Render();
+
+    Property::Map map;
+    CreatePropertyMap( actor, map );
+    DALI_TEST_CHECK( !map.Empty() );
+
+    Property::Value value( map );
+    DALI_TEST_CHECK( value.HasKey( "type" ) );
+    DALI_TEST_EQUALS( value.GetValue( "type" ).Get< std::string >(), "Actor", TEST_LOCATION );
+
+    DALI_TEST_CHECK( value.HasKey( "actors" ) );
+    Property::Array children( value.GetValue( "actors").Get< Property::Array >() );
+    DALI_TEST_CHECK( !children.Empty() );
+    Property::Map childMap( children[0].Get< Property::Map >() );
+    DALI_TEST_CHECK( !childMap.Empty() );
+    Property::Value childValue( childMap );
+    DALI_TEST_CHECK( childValue.HasKey( "type" ) );
+    DALI_TEST_EQUALS( childValue.GetValue( "type" ).Get< std::string >(), "ImageActor", TEST_LOCATION );
+
+    Stage::GetCurrent().Remove( actor );
+  }
+  END_TEST;
+}
+
+int UtcDaliScriptingCreatePropertyMapImage(void)
+{
+  TestApplication application;
+
+  // Empty
+  {
+    Image image;
+    Property::Map map;
+    CreatePropertyMap( image, map );
+    DALI_TEST_CHECK( map.Empty() );
+  }
+
+  // Default
+  {
+    Image image = ResourceImage::New( "MY_PATH" );
+
+    Property::Map map;
+    CreatePropertyMap( image, map );
+    DALI_TEST_CHECK( !map.Empty() );
+
+    Property::Value value( map );
+    DALI_TEST_CHECK( value.HasKey( "type" ) );
+    DALI_TEST_EQUALS( value.GetValue( "type" ).Get< std::string >(), "ResourceImage", TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "filename" ) );
+    DALI_TEST_EQUALS( value.GetValue( "filename" ).Get< std::string >(), "MY_PATH", TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "load-policy") );
+    DALI_TEST_EQUALS( value.GetValue( "load-policy" ).Get< std::string >(), "IMMEDIATE", TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "release-policy") );
+    DALI_TEST_EQUALS( value.GetValue( "release-policy" ).Get< std::string >(), "NEVER", TEST_LOCATION );
+    DALI_TEST_CHECK( !value.HasKey( "width" ) );
+    DALI_TEST_CHECK( !value.HasKey( "height" ) );
+  }
+
+  // Change values
+  {
+    ResourceImage image = ResourceImage::New( "MY_PATH", ResourceImage::ON_DEMAND, Image::UNUSED, ImageDimensions( 300, 400 ), FittingMode::FIT_WIDTH );
+
+    Property::Map map;
+    CreatePropertyMap( image, map );
+    DALI_TEST_CHECK( !map.Empty() );
+
+    Property::Value value( map );
+    DALI_TEST_CHECK( value.HasKey( "type" ) );
+    DALI_TEST_EQUALS( value.GetValue( "type" ).Get< std::string >(), "ResourceImage", TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "filename" ) );
+    DALI_TEST_EQUALS( value.GetValue( "filename" ).Get< std::string >(), "MY_PATH", TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "load-policy") );
+    DALI_TEST_EQUALS( value.GetValue( "load-policy" ).Get< std::string >(), "ON_DEMAND", TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "release-policy") );
+    DALI_TEST_EQUALS( value.GetValue( "release-policy" ).Get< std::string >(), "UNUSED", TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "width" ) );
+    DALI_TEST_EQUALS( value.GetValue( "width" ).Get< int >(), 300, TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "height" ) );
+    DALI_TEST_EQUALS( value.GetValue( "height" ).Get< int >(), 400, TEST_LOCATION );
+  }
+
+  // BufferImage
+  {
+    Image image = BufferImage::New( 200, 300, Pixel::A8 );
+    Property::Map map;
+    CreatePropertyMap( image, map );
+    Property::Value value( map );
+    DALI_TEST_CHECK( value.HasKey( "type" ) );
+    DALI_TEST_EQUALS( value.GetValue( "type" ).Get< std::string >(), "BufferImage", TEST_LOCATION );
+    DALI_TEST_CHECK( value.HasKey( "pixel-format") );
+    DALI_TEST_EQUALS( value.GetValue( "pixel-format" ).Get< std::string >(), "A8", TEST_LOCATION );
+  }
+
+  // FrameBufferImage
+  {
+    Image image = FrameBufferImage::New( 200, 300, Pixel::RGBA8888 );
+    Property::Map map;
+    CreatePropertyMap( image, map );
+    Property::Value value( map );
+    DALI_TEST_CHECK( value.HasKey( "type" ) );
+    DALI_TEST_EQUALS( value.GetValue( "type" ).Get< std::string >(), "FrameBufferImage", TEST_LOCATION );
+  }
+  END_TEST;
+}
+
+int UtcDaliScriptingGetEnumerationTemplates(void)
+{
+  TestApplication application;
+
+  const Scripting::StringEnum< int > myTable[] =
+  {
+    { "ONE",    1 },
+    { "TWO",    2 },
+    { "THREE",  3 },
+    { "FOUR",   4 },
+    { "FIVE",   5 },
+  };
+  const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
+
+  for ( unsigned int i = 0; i < myTableCount; ++i )
+  {
+    tet_printf("Checking: %s\n", myTable[ i ].string );
+    DALI_TEST_EQUALS( myTable[ i ].value, GetEnumeration( myTable[ i ].string, myTable, myTableCount ), TEST_LOCATION );
+  }
+
+  for ( unsigned int i = 0; i < myTableCount; ++i )
+  {
+    tet_printf("Checking: %d\n", myTable[ i ].value );
+    DALI_TEST_EQUALS( myTable[ i ].string, GetEnumerationName( myTable[ i ].value, myTable, myTableCount ), TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int UtcDaliScriptingCompareEnums(void)
+{
+  // EQUAL
+  DALI_TEST_CHECK( CompareEnums( "", "" ) );
+  DALI_TEST_CHECK( CompareEnums( "HELLO", "HELLO" ) );
+  DALI_TEST_CHECK( CompareEnums( "HELLO", "hello" ) );
+  DALI_TEST_CHECK( CompareEnums( "hello", "HELLO" ) );
+  DALI_TEST_CHECK( CompareEnums( "hello-world", "HELLO_WORLD" ) );
+  DALI_TEST_CHECK( CompareEnums( "hello_WORLD", "HELLO-world" ) );
+  DALI_TEST_CHECK( CompareEnums( "hello_WORLD-", "HELLO-world_" ) );
+  DALI_TEST_CHECK( CompareEnums( "_hello_WORLD-", "-HELLO-world_" ) );
+  DALI_TEST_CHECK( CompareEnums( "-hello_WORLD-", "_HELLO-world_" ) );
+  DALI_TEST_CHECK( CompareEnums( "hello123", "HELLO123" ) );
+
+  // NOT EQUAL
+  DALI_TEST_CHECK( ! CompareEnums( "hello", "HELLOWORLD" ) );
+
+  END_TEST;
+}
index a726b6d9c926c216d1d4635a61dcb4150ac39079..5bdc6fbe47e9b4f33cdc7bb4d4de63c723c3e673 100644 (file)
@@ -9,34 +9,23 @@ SET(TC_SOURCES
         utc-Dali-Actor.cpp
         utc-Dali-AlphaFunction.cpp
         utc-Dali-AngleAxis.cpp
-        utc-Dali-AnimatableMesh.cpp
         utc-Dali-Animation.cpp
         utc-Dali-Any.cpp
-        utc-Dali-Atlas.cpp
         utc-Dali-BaseHandle.cpp
         utc-Dali-BufferImage.cpp
         utc-Dali-CameraActor.cpp
-        utc-Dali-Constrainer.cpp
         utc-Dali-Constraint.cpp
         utc-Dali-ConstraintFunction.cpp
         utc-Dali-Constraints.cpp
         utc-Dali-ConstraintSource.cpp
-        utc-Dali-Context.cpp
         utc-Dali-ConnectionTracker.cpp
         utc-Dali-CustomActor.cpp
         utc-Dali-Degree.cpp
-        utc-Dali-DistanceField.cpp
-        utc-Dali-DynamicsBodyConfig.cpp
-        utc-Dali-DynamicsShape.cpp
-        utc-Dali-DynamicsWorld.cpp
-        utc-Dali-DynamicsWorldConfig.cpp
         utc-Dali-EncodedBufferImage.cpp
         utc-Dali-FrameBufferImage.cpp
         utc-Dali-Gesture.cpp
         utc-Dali-GestureDetector.cpp
         utc-Dali-Handle.cpp
-        utc-Dali-Hash.cpp
-        utc-Dali-HitTestAlgorithm.cpp
         utc-Dali-HoverProcessing.cpp
         utc-Dali-Image.cpp
         utc-Dali-ImageActor.cpp
@@ -46,14 +35,10 @@ SET(TC_SOURCES
         utc-Dali-LocklessBuffer.cpp
         utc-Dali-LongPressGesture.cpp
         utc-Dali-LongPressGestureDetector.cpp
-        utc-Dali-Material.cpp
         utc-Dali-MathUtils.cpp
         utc-Dali-Matrix.cpp
         utc-Dali-Matrix3.cpp
-        utc-Dali-MeshActor.cpp
-        utc-Dali-MeshData.cpp
         utc-Dali-MouseWheelEvent.cpp
-        utc-Dali-Mutex.cpp
         utc-Dali-NativeImage.cpp
         utc-Dali-NinePatchImages.cpp
         utc-Dali-ObjectRegistry.cpp
@@ -77,7 +62,6 @@ SET(TC_SOURCES
         utc-Dali-RenderableActor.cpp
         utc-Dali-ResourceImage.cpp
         utc-Dali-ShaderEffect.cpp
-        utc-Dali-Scripting.cpp
         utc-Dali-SignalTemplatesFunctors.cpp
         utc-Dali-SignalTemplates.cpp
         utc-Dali-Stage.cpp
@@ -94,7 +78,6 @@ SET(TC_SOURCES
 )
 
 LIST(APPEND TC_SOURCES
-        dali-test-suite-utils/mesh-builder.cpp
         dali-test-suite-utils/test-harness.cpp
         dali-test-suite-utils/dali-test-suite-utils.cpp
         dali-test-suite-utils/test-application.cpp
@@ -127,7 +110,6 @@ INCLUDE_DIRECTORIES(
 ADD_EXECUTABLE(${EXEC_NAME} ${EXEC_NAME}.cpp ${TC_SOURCES})
 TARGET_LINK_LIBRARIES(${EXEC_NAME}
     ${${CAPI_LIB}_LIBRARIES}
-    -lpthread
 )
 
 INSTALL(PROGRAMS ${EXEC_NAME}
diff --git a/automated-tests/src/dali/dali-test-suite-utils/mesh-builder.cpp b/automated-tests/src/dali/dali-test-suite-utils/mesh-builder.cpp
deleted file mode 100644 (file)
index 772c892..0000000
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-#include "mesh-builder.h"
-
-namespace Dali
-{
-
-void AddVertex( MeshData::VertexContainer& verts, Vector3 V, Vector2 UV )
-{
-  MeshData::Vertex meshVertex;
-  meshVertex.x = V.x;
-  meshVertex.y = V.y;
-  meshVertex.z = V.z;
-  meshVertex.u = UV.x;
-  meshVertex.v = UV.y;
-  verts.push_back(meshVertex);
-}
-
-void SetNormal( MeshData::VertexContainer& verts, size_t vertIdx, Vector3 normal )
-{
-  verts[vertIdx].nX = normal.x;
-  verts[vertIdx].nY = normal.y;
-  verts[vertIdx].nZ = normal.z;
-}
-
-void SetBone( MeshData::VertexContainer& verts, size_t vertIdx, size_t index, size_t boneIndex, float weight)
-{
-  verts[vertIdx].boneIndices[index] = boneIndex;
-  verts[vertIdx].boneWeights[index] = weight;
-}
-
-void SetBones(MeshData::VertexContainer& verts)
-{
-  // Set all verts in one corner to be affected fully by bone 0
-  SetBone(verts, 0, 0, 0, 1.0f);
-  SetBone(verts, 1, 0, 0, 1.0f);
-  SetBone(verts, 2, 0, 0, 1.0f);
-
-  // Set all verts in next corner to be affected by bone 1 and bone 2 equally
-  SetBone(verts, 3, 0, 1, 0.5f);
-  SetBone(verts, 4, 0, 1, 0.5f);
-  SetBone(verts, 5, 0, 1, 0.5f);
-
-  SetBone(verts, 3, 1, 2, 0.5f);
-  SetBone(verts, 4, 1, 2, 0.5f);
-  SetBone(verts, 5, 1, 2, 0.5f);
-}
-
-void ConstructBones(BoneContainer& bones)
-{
-  bones.push_back(Bone("Bone1", Matrix::IDENTITY));
-  bones.push_back(Bone("Bone2", Matrix::IDENTITY));
-  bones.push_back(Bone("Bone3", Matrix::IDENTITY));
-}
-
-void CopyVertex( MeshData::Vertex& vert, Vector3& vector )
-{
-  vector.x = vert.x;
-  vector.y = vert.y;
-  vector.z = vert.z;
-}
-
-void AddTriangle( MeshData::VertexContainer& verts,
-                  MeshData::FaceIndices& faces,
-                  size_t v0, size_t v1, size_t v2 )
-{
-  faces.push_back(v0);
-  faces.push_back(v1);
-  faces.push_back(v2);
-
-  // Calculate normal...
-  Vector3 vert0, vert1, vert2;
-  CopyVertex(verts[v0], vert0);
-  CopyVertex(verts[v1], vert1);
-  CopyVertex(verts[v2], vert2);
-  Vector3 e0 = vert1 - vert0;
-  Vector3 e1 = vert2 - vert1;
-  Vector3 normal = e0.Cross(e1);
-  normal.Normalize();
-  SetNormal(verts, v0, normal);
-  SetNormal(verts, v1, normal);
-  SetNormal(verts, v2, normal);
-}
-
-void ConstructVertices( MeshData::VertexContainer& vertices, float sz )
-{
-  // back
-  AddVertex(vertices, Vector3( 0.0f,  -sz, 0.0f), Vector2(0.50f, 0.50f));        // 0a  0
-  AddVertex(vertices, Vector3( 0.0f,  -sz, 0.0f), Vector2(0.50f, 0.50f));        // 0b  1
-  AddVertex(vertices, Vector3( 0.0f,  -sz, 0.0f), Vector2(0.50f, 0.50f));        // 0c  2
-
-  // left
-  AddVertex(vertices, Vector3(-sz*0.5f, sz*0.3f, sz*0.5f), Vector2(0.25f, 0.50f));  // 1a  3
-  AddVertex(vertices, Vector3(-sz*0.5f, sz*0.3f, sz*0.5f), Vector2(0.25f, 0.50f));  // 1b  4
-  AddVertex(vertices, Vector3(-sz*0.5f, sz*0.3f, sz*0.5f), Vector2(0.25f, 0.50f));  // 1c  5
-
-  // right
-  AddVertex(vertices, Vector3( sz*0.5f, sz*0.3f, sz*0.5f), Vector2(0.50f, 0.25f));  // 2a  6
-  AddVertex(vertices, Vector3( sz*0.5f, sz*0.3f, sz*0.5f), Vector2(0.50f, 0.25f));  // 2b  7
-  AddVertex(vertices, Vector3( sz*0.5f, sz*0.3f, sz*0.5f), Vector2(0.50f, 0.25f));  // 2c  8
-
-  // top
-  AddVertex(vertices, Vector3( 0.0f,   sz*0.3f, -sz*0.7f), Vector2(0.25f, 0.25f)); // 3a  9
-  AddVertex(vertices, Vector3( 0.0f,   sz*0.3f, -sz*0.7f), Vector2(0.25f, 0.25f)); // 3b 10
-  AddVertex(vertices, Vector3( 0.0f,   sz*0.3f, -sz*0.7f), Vector2(0.25f, 0.25f)); // 3c 11
-}
-
-void ConstructFaces(MeshData::VertexContainer& vertices, MeshData::FaceIndices& faces)
-{
-  AddTriangle(vertices, faces,  0, 6,  3); // 0, 2, 1  back, right, left (ac)
-  AddTriangle(vertices, faces,  1, 9,  7); // 0, 3, 2  back, top , right (ac)
-  AddTriangle(vertices, faces,  2, 4, 10); // 0, 1, 3  back, left, top   (ac)
-  AddTriangle(vertices, faces, 11, 5,  8); // 3, 1, 2  top, left, right  (ac)
-}
-
-Material ConstructMaterial()
-{
-  Material customMaterial = Material::New("CustomMaterial");
-  customMaterial.SetOpacity(.76f);
-  customMaterial.SetDiffuseColor(Vector4(0.8f, 0.0f, 0.4f, 1.0f));
-  customMaterial.SetAmbientColor(Vector4(0.2f, 1.0f, 0.6f, 1.0f));
-  customMaterial.SetSpecularColor(Vector4(0.5f, 0.6f, 0.7f, 1.0f));
-  return customMaterial;
-}
-
-
-Mesh ConstructMesh( float sz )
-{
-  MeshData::VertexContainer vertices;
-  MeshData::FaceIndices     faces;
-  ConstructVertices( vertices, sz );
-  ConstructFaces(vertices, faces);
-  Material customMaterial = ConstructMaterial();
-
-  MeshData meshData;
-  BoneContainer bones;
-  meshData.SetData(vertices, faces, bones, customMaterial);
-  meshData.SetHasNormals(true);
-  meshData.SetHasTextureCoords(true);
-
-  Mesh mesh = Mesh::New(meshData);
-  return mesh;
-}
-
-
-void AddBone(Dali::BoneContainer& bones, const std::string& name, const Dali::Matrix& offsetMatrix)
-{
-  bones.push_back(Bone(name, offsetMatrix));
-}
-
-void CreateMeshData(MeshData& meshData)
-{
-  MeshData::VertexContainer vertices;
-  MeshData::FaceIndices faces;
-  Dali::BoneContainer bones;
-  AddBone(bones, "trunk",  Matrix::IDENTITY);
-  AddBone(bones, "branch", Matrix::IDENTITY);
-  AddBone(bones, "twig",   Matrix::IDENTITY);
-  ConstructVertices( vertices, 50 );
-  ConstructFaces(vertices, faces);
-  Material customMaterial = ConstructMaterial();
-  meshData.SetData(vertices, faces, bones, customMaterial);
-  meshData.SetHasNormals(true);
-  meshData.SetHasTextureCoords(true);
-}
-
-
-} // namespace Dali
diff --git a/automated-tests/src/dali/dali-test-suite-utils/mesh-builder.h b/automated-tests/src/dali/dali-test-suite-utils/mesh-builder.h
deleted file mode 100644 (file)
index 7d77806..0000000
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef MESH_BUILDER_H
-#define MESH_BUILDER_H
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/geometry/mesh.h>
-
-namespace Dali
-{
-
-void AddVertex( MeshData::VertexContainer& verts, Vector3 V, Vector2 UV );
-void SetNormal( MeshData::VertexContainer& verts, size_t vertIdx, Vector3 normal );
-void SetBone( MeshData::VertexContainer& verts, size_t vertIdx, size_t index, size_t boneIndex, float weight);
-void SetBones(MeshData::VertexContainer& verts);
-void ConstructBones(BoneContainer& bones);
-void CopyVertex( MeshData::Vertex& vert, Vector3& vector );
-void AddTriangle( MeshData::VertexContainer& verts,
-                  MeshData::FaceIndices& faces,
-                  size_t v0, size_t v1, size_t v2 );
-void ConstructVertices( MeshData::VertexContainer& vertices, float sz );
-void ConstructFaces(MeshData::VertexContainer& vertices, MeshData::FaceIndices& faces);
-Material ConstructMaterial();
-Mesh ConstructMesh( float sz );
-void AddBone(Dali::BoneContainer& bones, const std::string& name, const Dali::Matrix& offsetMatrix);
-void CreateMeshData(MeshData& meshData);
-
-}
-
-#endif // MESH_BUILDER_H
index 21c16c23235e48c53cb20bbe2834c576f4abd607..926e75af859484b8cc4a540d35f2afce804f2189 100644 (file)
@@ -24,7 +24,6 @@
 #include <string>
 
 // INTERNAL INCLUDES
-#include <dali/devel-api/common/set-wrapper.h>
 #include <dali/integration-api/platform-abstraction.h>
 
 #include "test-trace-call-stack.h"
diff --git a/automated-tests/src/dali/utc-Dali-AnimatableMesh.cpp b/automated-tests/src/dali/utc-Dali-AnimatableMesh.cpp
deleted file mode 100644 (file)
index 0de8bbb..0000000
+++ /dev/null
@@ -1,463 +0,0 @@
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/geometry/animatable-mesh.h>
-#include <dali/devel-api/actors/mesh-actor.h>
-#include <dali-test-suite-utils.h>
-#include <mesh-builder.h>
-
-using namespace Dali;
-
-
-void utc_dali_animatable_mesh_startup(void)
-{
-  test_return_value = TET_UNDEF;
-}
-
-void utc_dali_animatable_mesh_cleanup(void)
-{
-  test_return_value = TET_PASS;
-}
-
-namespace
-{
-
-void CreateFaces(Dali::AnimatableMesh::Faces& faces, int numVerts)
-{
-  for(int i=0; i<numVerts-3; i++)
-  {
-    faces.push_back(i);
-    faces.push_back(i+1);
-    faces.push_back(i+2);
-  }
-}
-
-void CreateOutOfRangeFaces(Dali::AnimatableMesh::Faces& faces, int numVerts)
-{
-  for(int i=numVerts; i<numVerts*2-3; i++)
-  {
-    faces.push_back(i);
-    faces.push_back(i+1);
-    faces.push_back(i+2);
-  }
-}
-
-AnimatableMesh CreateMesh()
-{
-  AnimatableMesh::Faces faces;
-  CreateFaces(faces, 10);
-  AnimatableMesh mesh = AnimatableMesh::New(10, faces);
-  return mesh;
-}
-
-} // anon namespace
-
-// Negative test case for a method
-int UtcDaliAnimatableMeshConstructor01(void)
-{
-  TestApplication application;
-
-  AnimatableMesh mesh;
-
-  DALI_TEST_CHECK( ! mesh );
-  END_TEST;
-}
-
-int UtcDaliAnimatableMeshConstructor02(void)
-{
-  TestApplication application;
-
-  Dali::AnimatableMesh::Faces faces;
-  CreateFaces(faces, 10);
-
-  AnimatableMesh mesh = AnimatableMesh::New(10, faces);
-  DALI_TEST_CHECK( mesh );
-
-  AnimatableMesh mesh2 = mesh;
-  DALI_TEST_CHECK( mesh2 );
-
-  AnimatableMesh mesh3 ( mesh2 );
-  DALI_TEST_CHECK( mesh3 );
-  END_TEST;
-}
-
-int UtcDaliAnimatableMeshConstructor03(void)
-{
-  TestApplication application;
-
-  // Heap allocate a handle. Don't do this in real code!
-  AnimatableMesh* mesh = new AnimatableMesh();
-  DALI_TEST_CHECK( ! *mesh );
-  delete mesh;
-  END_TEST;
-}
-
-
-// Positive test case for a method
-int UtcDaliAnimatableMeshNew01(void)
-{
-  TestApplication application;
-
-  Dali::AnimatableMesh::Faces faces;
-  CreateFaces(faces, 10);
-
-  AnimatableMesh mesh = AnimatableMesh::New(10, faces);
-  DALI_TEST_CHECK( mesh );
-  END_TEST;
-}
-
-// Positive test case for a method
-int UtcDaliAnimatableMeshNew02(void)
-{
-  TestApplication application;
-
-  Dali::AnimatableMesh::Faces faces;
-  CreateFaces(faces, 10);
-
-  Dali::Material mat = Dali::Material::New("dummy mat");
-  AnimatableMesh mesh = AnimatableMesh::New(10, faces, mat);
-  DALI_TEST_CHECK( mesh );
-  END_TEST;
-}
-
-
-// Negative test case for a method
-int UtcDaliAnimatableMeshNew03(void)
-{
-  TestApplication application;
-  Dali::AnimatableMesh::Faces faces;
-  try
-  {
-    AnimatableMesh mesh = AnimatableMesh::New(0, faces);
-    DALI_TEST_CHECK( !mesh );
-  }
-  catch (Dali::DaliException& e)
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT(e, "numVertices > 0", TEST_LOCATION);
-  }
-  END_TEST;
-}
-
-// Negative test case for a method
-int UtcDaliAnimatableMeshNew04(void)
-{
-  TestApplication application;
-
-  Dali::AnimatableMesh::Faces faces;
-
-  try
-  {
-    AnimatableMesh mesh = AnimatableMesh::New(10, faces);
-    DALI_TEST_CHECK( !mesh );
-  }
-  catch (Dali::DaliException& e)
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT(e, "faceIndices.size() > 0", TEST_LOCATION);
-  }
-  END_TEST;
-}
-
-// Negative test case for a method
-int UtcDaliAnimatableMeshNew05(void)
-{
-  TestApplication application;
-
-  Dali::AnimatableMesh::Faces faces;
-  CreateOutOfRangeFaces(faces, 10);
-
-  try
-  {
-    AnimatableMesh mesh = AnimatableMesh::New(10, faces);
-    DALI_TEST_CHECK( !mesh );
-  }
-  catch (Dali::DaliException& e)
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT(e, "faceIndex < numVertices", TEST_LOCATION);
-  }
-  END_TEST;
-}
-
-// Negative test case for a method
-int UtcDaliAnimatableMeshNew06(void)
-{
-  TestApplication application;
-
-  Dali::AnimatableMesh::Faces faces;
-  CreateFaces(faces, 10);
-
-  try
-  {
-    AnimatableMesh mesh = AnimatableMesh::New(10, faces, Dali::Material() );
-    DALI_TEST_CHECK( !mesh );
-  }
-  catch (Dali::DaliException& e)
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT(e, "material", TEST_LOCATION);
-  }
-  END_TEST;
-}
-
-int UtcDaliAnimatableMeshDownCast01(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::AnimatableMesh::DownCast()");
-
-  Dali::AnimatableMesh::Faces faces;
-  CreateFaces(faces, 10);
-
-  AnimatableMesh mesh = AnimatableMesh::New(10, faces);
-  BaseHandle* bh = &mesh;
-
-  AnimatableMesh mesh2 = AnimatableMesh::DownCast(*bh);
-  DALI_TEST_CHECK( mesh2 );
-  END_TEST;
-}
-
-int UtcDaliAnimatableMeshDownCast02(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::AnimatableMesh::DownCast()");
-
-  MeshData meshData;
-  CreateMeshData(meshData);
-  Mesh mesh = Mesh::New(meshData);
-  BaseHandle* bh = &mesh;
-
-  AnimatableMesh mesh2 = AnimatableMesh::DownCast(*bh);
-  DALI_TEST_CHECK( ! mesh2 );
-  END_TEST;
-}
-
-int UtcDaliAnimatableMeshGetPropertyIndex01(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::AnimatableMesh::operator[]");
-  AnimatableMesh mesh = CreateMesh();
-
-  Property::Index i = mesh.GetPropertyIndex(0, AnimatableVertex::Property::POSITION );
-  DALI_TEST_EQUALS( i, 0*3+0, TEST_LOCATION );
-
-  i = mesh.GetPropertyIndex(5, AnimatableVertex::Property::POSITION );
-  DALI_TEST_EQUALS( i, 5*3+0, TEST_LOCATION );
-
-  i = mesh.GetPropertyIndex(7, AnimatableVertex::Property::COLOR );
-  DALI_TEST_EQUALS( i, 7*3+1, TEST_LOCATION );
-
-  i = mesh.GetPropertyIndex(9, AnimatableVertex::Property::TEXTURE_COORDS );
-  DALI_TEST_EQUALS( i, 9*3+2, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliAnimatableMeshGetPropertyIndex02(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::AnimatableMesh::GetPropertyIndex");
-
-  AnimatableMesh mesh = CreateMesh();
-  try
-  {
-    Property::Index i = mesh.GetPropertyIndex(12, AnimatableVertex::Property::POSITION );
-    DALI_TEST_CHECK( i==0 );
-  }
-  catch (Dali::DaliException& e)
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT(e, "index < GetNumberOfVertices()", TEST_LOCATION);
-  }
-  END_TEST;
-}
-
-int UtcDaliAnimatableMeshGetPropertyIndex03(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::AnimatableMesh::GetPropertyIndex");
-
-  AnimatableMesh mesh = CreateMesh();
-  try
-  {
-    Property::Index i = mesh.GetPropertyIndex(12, AnimatableVertex::Property::COLOR );
-    DALI_TEST_CHECK( i==0 );
-  }
-  catch (Dali::DaliException& e)
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT(e, "index < GetNumberOfVertices()", TEST_LOCATION);
-  }
-  END_TEST;
-}
-
-int UtcDaliAnimatableMeshGetPropertyIndex04(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::AnimatableMesh::GetPropertyIndexa");
-
-  AnimatableMesh mesh = CreateMesh();
-  try
-  {
-    Property::Index i = mesh.GetPropertyIndex(12342343, AnimatableVertex::Property::TEXTURE_COORDS );
-    DALI_TEST_CHECK( i==0 );
-  }
-  catch (Dali::DaliException& e)
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT(e, "index < GetNumberOfVertices()", TEST_LOCATION);
-  }
-  END_TEST;
-}
-
-int UtcDaliAnimatableMeshOperatorArray01(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::AnimatableMesh::operator[]");
-
-  AnimatableMesh mesh = CreateMesh();
-  {
-    Vector3 initialPos1(0.0f, 200.0f, 0.0f);
-    Vector3 initialPos2(100.0f, 300.0f, 0.0f);
-
-    mesh[1].SetPosition(initialPos1);
-    mesh[3].SetPosition(initialPos2);
-
-    application.Render(0);
-    application.SendNotification();
-    application.Render(16);
-    application.SendNotification();
-    DALI_TEST_EQUALS( mesh[1].GetCurrentPosition(), initialPos1, TEST_LOCATION );
-
-    Vector3 pos = mesh[3].GetCurrentPosition();
-    DALI_TEST_EQUALS( pos, initialPos2, TEST_LOCATION );
-  }
-  END_TEST;
-}
-
-int UtcDaliAnimatableMeshOperatorArray02(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::AnimatableMesh::operator[]");
-
-  AnimatableMesh mesh = CreateMesh();
-  try
-  {
-    mesh[20].SetPosition(Vector3(0.0f, 0.0f, 0.0f));
-  }
-  catch (Dali::DaliException& e)
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT(e, "index < GetNumberOfVertices()", TEST_LOCATION);
-  }
-  END_TEST;
-}
-
-int UtcDaliAnimatableMeshAnimateVertex01(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::AnimatableMesh Animating properties");
-
-  AnimatableMesh mesh = CreateMesh();
-  MeshActor meshActor = MeshActor::New(mesh);
-  Stage::GetCurrent().Add(meshActor);
-  {
-    mesh[0].SetPosition(Vector3(0.0f, 200.0f, 0.0f));
-    mesh[1].SetPosition(Vector3(100.0f, 300.0f, 0.0f));
-
-    Animation anim = Animation::New(1);
-    anim.AnimateBy(mesh.GetVertexProperty(0, AnimatableVertex::Property::POSITION), Vector3(  0.0f, 100.0f, 0.0f));
-    anim.AnimateTo(mesh.GetVertexProperty(1, AnimatableVertex::Property::POSITION), Vector3(100.0f,   0.0f, 0.0f));
-    anim.Play();
-
-    application.SendNotification();
-    application.Render(0);
-    application.Render(500);
-    application.SendNotification();
-
-    // 50% progress
-    DALI_TEST_EQUALS( mesh[0].GetCurrentPosition(), Vector3(  0.0f, 250.0f, 0.0f), TEST_LOCATION );
-    DALI_TEST_EQUALS( mesh[1].GetCurrentPosition(), Vector3(100.0f, 150.0f, 0.0f), TEST_LOCATION );
-
-    application.SendNotification();
-    application.Render(501);
-    application.SendNotification();
-
-    DALI_TEST_EQUALS( mesh[0].GetCurrentPosition(), Vector3(  0.0f, 300.0f, 0.0f), TEST_LOCATION );
-    DALI_TEST_EQUALS( mesh[1].GetCurrentPosition(), Vector3(100.0f,   0.0f, 0.0f), TEST_LOCATION );
-  }
-  END_TEST;
-}
-
-int UtcDaliAnimatableVertexSettersAndGetters(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::AnimatableVertex constructors");
-  AnimatableMesh mesh = CreateMesh();
-  Vector3 v1Pos(0.0f, 200.0f, 0.0f);
-  Vector3 v2Pos(100.0f, 300.0f, 0.0f);
-  Vector2 uvs(0.1f, 0.2f);
-  mesh[0].SetPosition(v1Pos);
-  mesh[1].SetPosition(v2Pos);
-  mesh[2].SetColor(Color::BLACK);
-  mesh[3].SetTextureCoords(uvs);
-
-  application.SendNotification();
-  application.Render(16);
-  application.SendNotification();
-  application.Render(16);
-  application.SendNotification();
-
-  DALI_TEST_EQUALS(mesh[0].GetCurrentPosition(), v1Pos, TEST_LOCATION);
-  DALI_TEST_EQUALS(mesh[1].GetCurrentPosition(), v2Pos, TEST_LOCATION);
-  DALI_TEST_EQUALS(mesh[2].GetCurrentColor(), Color::BLACK, TEST_LOCATION);
-  DALI_TEST_EQUALS(mesh[3].GetCurrentTextureCoords(), uvs, TEST_LOCATION);
-  END_TEST;
-}
-
-int UtcDaliAnimatableMeshProperties(void)
-{
-  TestApplication application;
-  AnimatableMesh mesh = CreateMesh();
-
-  Property::IndexContainer indices;
-  mesh.GetPropertyIndices( indices );
-  DALI_TEST_CHECK( ! indices.empty() );
-  DALI_TEST_EQUALS( indices.size(), mesh.GetPropertyCount(), TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliAnimatableMeshExceedVertices(void)
-{
-  TestApplication application;
-
-  AnimatableMesh::Faces faces;
-  CreateFaces(faces, 10);
-
-  try
-  {
-    AnimatableMesh mesh = AnimatableMesh::New(3333334, faces);
-    tet_result( TET_FAIL );
-  }
-  catch ( DaliException& e )
-  {
-    DALI_TEST_ASSERT( e, "( numVertices * 3 ) < DEFAULT_PROPERTY_MAX_COUNT", TEST_LOCATION );
-  }
-  END_TEST;
-}
diff --git a/automated-tests/src/dali/utc-Dali-Atlas.cpp b/automated-tests/src/dali/utc-Dali-Atlas.cpp
deleted file mode 100644 (file)
index 137f40d..0000000
+++ /dev/null
@@ -1,191 +0,0 @@
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <iostream>
-#include <algorithm>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/integration-api/bitmap.h>
-#include <dali/devel-api/images/atlas.h>
-#include <dali-test-suite-utils.h>
-#include <test-native-image.h>
-
-using namespace Dali;
-
-namespace
-{
-static const char* gTestImageFilename = "icon_wrt.png";
-
-void PrepareResourceImage( TestApplication& application, unsigned int imageHeight, unsigned int imageWidth, Pixel::Format pixelFormat )
-{
-  TestPlatformAbstraction& platform = application.GetPlatform();
-  platform.SetClosestImageSize(Vector2( 16, 16));
-
-  Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::RETAIN );
-  Integration::PixelBuffer* pixbuffer = bitmap->GetPackedPixelsProfile()->ReserveBuffer( pixelFormat, imageWidth, imageHeight, imageWidth, imageHeight );
-  unsigned int bytesPerPixel = GetBytesPerPixel(  pixelFormat );
-  unsigned int initialColor = 0xFF;
-  memset( pixbuffer, initialColor, imageHeight*imageWidth*bytesPerPixel);
-
-  Integration::ResourcePointer resourcePtr(bitmap);
-  platform.SetResourceLoaded( 0, Dali::Integration::ResourceBitmap, resourcePtr );
-}
-
-}
-
-void utc_dali_atlas_startup(void)
-{
-  test_return_value = TET_UNDEF;
-}
-
-void utc_dali_atlas_cleanup(void)
-{
-  test_return_value = TET_PASS;
-}
-
-// 1.1
-int UtcDaliAtlasNew01(void)
-{
-  TestApplication application;
-
-  // invoke default handle constructor
-  Atlas atlas;
-
-  DALI_TEST_CHECK( !atlas );
-
-  // initialise handle
-  atlas = Atlas::New( 16, 16 );
-
-  DALI_TEST_CHECK( atlas );
-  END_TEST;
-}
-
-
-// 1.2
-int UtcDaliAtlasUpload01(void)
-{
-  TestApplication application;
-
-  Atlas atlas = Atlas::New( 16, 16, Pixel::RGBA8888 );
-  DALI_TEST_CHECK( atlas );
-
-  // Using correct pixel format
-  PixelBuffer* buffer = new PixelBuffer[16 * 16];
-  BufferImage image = BufferImage::New( buffer, 16, 16, Pixel::RGBA8888 );
-  DALI_TEST_CHECK( atlas.Upload( image, 0, 0 ) );
-
-  PrepareResourceImage( application, 16, 16, Pixel::RGBA8888 );
-  DALI_TEST_CHECK( atlas.Upload( gTestImageFilename, 0, 0 ) );
-
-  END_TEST;
-}
-
-// 1.3
-int UtcDaliAtlasUpload02(void)
-{
-  TestApplication application;
-
-  Atlas atlas = Atlas::New( 10, 10, Pixel::RGBA8888 );
-  DALI_TEST_CHECK( atlas );
-
-  // Using INCORRECT pixel format
-  PixelBuffer* buffer = new PixelBuffer[16 * 16];
-  BufferImage image = BufferImage::New( buffer, 16, 16, Pixel::A8 );
-  DALI_TEST_CHECK( !atlas.Upload( image, 0, 0 ) );
-
-  PrepareResourceImage( application, 16, 16, Pixel::A8 );
-  DALI_TEST_CHECK( !atlas.Upload( gTestImageFilename, 0, 0 ) );
-
-  END_TEST;
-}
-
-// 1.4
-int UtcDaliAtlasUpload03(void)
-{
-  TestApplication application;
-
-  Atlas atlas = Atlas::New( 10, 10, Pixel::RGBA8888 );
-  DALI_TEST_CHECK( atlas );
-
-  // Using image too big for atlas
-  PixelBuffer* buffer = new PixelBuffer[16 * 16];
-  BufferImage image = BufferImage::New( buffer, 16, 16, Pixel::RGBA8888 );
-  DALI_TEST_CHECK( !atlas.Upload( image, 0, 0 ) );
-
-  PrepareResourceImage( application, 16, 16, Pixel::RGBA8888 );
-  DALI_TEST_CHECK( !atlas.Upload( gTestImageFilename, 0, 0 ) );
-
-  END_TEST;
-}
-
-// 1.5
-int UtcDaliAtlasUpload04(void)
-{
-  TestApplication application;
-
-  Atlas atlas = Atlas::New( 32, 32, Pixel::RGBA8888 );
-  DALI_TEST_CHECK( atlas );
-
-  // Using valid offsets
-  PixelBuffer* buffer = new PixelBuffer[16 * 16];
-  BufferImage image = BufferImage::New( buffer, 16, 16, Pixel::RGBA8888 );
-
-  DALI_TEST_CHECK( atlas.Upload( image,  0,  0 ) );
-  DALI_TEST_CHECK( atlas.Upload( image, 16,  0 ) );
-  DALI_TEST_CHECK( atlas.Upload( image,  0, 16 ) );
-  DALI_TEST_CHECK( atlas.Upload( image, 16, 16 ) );
-
-  PrepareResourceImage( application, 16, 16, Pixel::RGBA8888 );
-  DALI_TEST_CHECK( atlas.Upload( gTestImageFilename,  0,  0 ) );
-  DALI_TEST_CHECK( atlas.Upload( gTestImageFilename, 16,  0 ) );
-  DALI_TEST_CHECK( atlas.Upload( gTestImageFilename,  0, 16 ) );
-  DALI_TEST_CHECK( atlas.Upload( gTestImageFilename, 16, 16 ) );
-
-  END_TEST;
-}
-
-// 1.6
-int UtcDaliAtlasUpload05(void)
-{
-  TestApplication application;
-
-  Atlas atlas = Atlas::New( 32, 32, Pixel::RGBA8888 );
-  DALI_TEST_CHECK( atlas );
-
-  // Using invalid offsets
-  PixelBuffer* buffer = new PixelBuffer[16 * 16];
-  BufferImage image = BufferImage::New( buffer, 16, 16, Pixel::RGBA8888 );
-
-  DALI_TEST_CHECK( !atlas.Upload( image,  0, 17 ) );
-  DALI_TEST_CHECK( !atlas.Upload( image, 17,  0 ) );
-  DALI_TEST_CHECK( !atlas.Upload( image, 17, 17 ) );
-  DALI_TEST_CHECK( !atlas.Upload( image, 99,  0 ) );
-  DALI_TEST_CHECK( !atlas.Upload( image,  0, 99 ) );
-  DALI_TEST_CHECK( !atlas.Upload( image, 99, 99 ) );
-
-  PrepareResourceImage( application, 16, 16, Pixel::RGBA8888 );
-
-  DALI_TEST_CHECK( !atlas.Upload( gTestImageFilename,  0, 17 ) );
-  DALI_TEST_CHECK( !atlas.Upload( gTestImageFilename, 17,  0 ) );
-  DALI_TEST_CHECK( !atlas.Upload( gTestImageFilename, 17, 17 ) );
-  DALI_TEST_CHECK( !atlas.Upload( gTestImageFilename, 99,  0 ) );
-  DALI_TEST_CHECK( !atlas.Upload( gTestImageFilename,  0, 99 ) );
-  DALI_TEST_CHECK( !atlas.Upload( gTestImageFilename, 99, 99 ) );
-
-  END_TEST;
-}
-
diff --git a/automated-tests/src/dali/utc-Dali-Constrainer.cpp b/automated-tests/src/dali/utc-Dali-Constrainer.cpp
deleted file mode 100644 (file)
index 076a9c2..0000000
+++ /dev/null
@@ -1,546 +0,0 @@
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/animation/path-constrainer.h>
-#include <dali-test-suite-utils.h>
-
-using namespace Dali;
-using namespace Dali::Internal;
-
-namespace
-{
-
-static void SetupPath( Dali::Path& path)
-{
-  path.AddPoint(Vector3( 30.0,  80.0, 0.0));
-  path.AddPoint(Vector3( 70.0, 120.0, 0.0));
-  path.AddPoint(Vector3(100.0, 100.0, 0.0));
-
-  //Control points for first segment
-  path.AddControlPoint( Vector3( 39.0,  90.0, 0.0) );
-  path.AddControlPoint(Vector3( 56.0, 119.0, 0.0) );
-
-  //Control points for second segment
-  path.AddControlPoint(Vector3( 78.0, 120.0, 0.0) );
-  path.AddControlPoint(Vector3( 93.0, 104.0, 0.0) );
-}
-
-static void SetupPathConstrainer( Dali::PathConstrainer& PathConstrainer)
-{
-  PathConstrainer.SetProperty( Dali::PathConstrainer::Property::FORWARD, Vector3(1.0f,0.0f,0.0f) );
-
-  Dali::Property::Array points;
-  points.Resize(3);
-  points[0] = Vector3( 30.0,  80.0, 0.0);
-  points[1] = Vector3( 70.0, 120.0, 0.0);
-  points[2] = Vector3(100.0, 100.0, 0.0);
-  PathConstrainer.SetProperty( Dali::PathConstrainer::Property::POINTS, points );
-
-  points.Resize(4);
-  points[0] = Vector3( 39.0,  90.0, 0.0);
-  points[1] = Vector3( 56.0, 119.0, 0.0);
-  points[2] = Vector3( 78.0, 120.0, 0.0);
-  points[3] = Vector3( 93.0, 104.0, 0.0);
-  PathConstrainer.SetProperty( Dali::PathConstrainer::Property::CONTROL_POINTS, points );
-}
-
-static void SetupLinearConstrainerUniformProgress( Dali::LinearConstrainer& linearConstrainer)
-{
-  Dali::Property::Array points;
-  points.Resize(3);
-  points[0] = 0.0f;
-  points[1] = 1.0f;
-  points[2] = 0.0f;
-  linearConstrainer.SetProperty( Dali::LinearConstrainer::Property::VALUE, points );
-}
-
-static void SetupLinearConstrainerNonUniformProgress( Dali::LinearConstrainer& linearConstrainer)
-{
-  Dali::Property::Array points;
-  points.Resize(3);
-  points[0] = 0.0f;
-  points[1] = 1.0f;
-  points[2] = 0.0f;
-  linearConstrainer.SetProperty( Dali::LinearConstrainer::Property::VALUE, points );
-
-  points[0] = 0.0f;
-  points[1] = 0.25f;
-  points[2] = 1.0f;
-  linearConstrainer.SetProperty( Dali::LinearConstrainer::Property::PROGRESS, points );
-}
-
-} // anonymous namespace
-
-//PathConstrainer test cases
-int UtcPathConstrainerApply(void)
-{
-  TestApplication application;
-
-  Dali::Actor actor = Dali::Actor::New();
-
-  // Register a float property
-  Property::Index index = actor.RegisterProperty( "t", 0.0f );
-
-  Dali::Stage::GetCurrent().Add(actor);
-
-  //Create a Path
-  Dali::Path path = Dali::Path::New();
-  SetupPath(path);
-
-  //Create a PathConstrainer
-  Dali::PathConstrainer pathConstrainer = Dali::PathConstrainer::New();
-  SetupPathConstrainer( pathConstrainer );
-
-  //Apply the path constraint to the actor's position. The source property for the constraint will be the custom property "t"
-  Vector2 range( 0.0f, 1.0f );
-  pathConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION), Property(actor,index), range );
-
-  //Create an animation to animate the custom property
-  float durationSeconds(1.0f);
-  Dali::Animation animation = Dali::Animation::New(durationSeconds);
-  animation.AnimateTo(Dali::Property(actor,index),1.0f);
-  animation.Play();
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
-
-  Vector3 position, tangent;
-  path.Sample(0.2f, position, tangent );
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
-  path.Sample(0.4f, position, tangent );
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
-  path.Sample(0.6f, position, tangent );
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
-  path.Sample(0.8f, position, tangent );
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 100% progress */);
-  path.Sample(1.0f, position, tangent );
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* beyond the animation duration*/);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcPathConstrainerApplyRange(void)
-{
-  TestApplication application;
-
-  Dali::Actor actor = Dali::Actor::New();
-
-  // Register a float property
-  Property::Index index = actor.RegisterProperty( "t", 0.0f );
-  Dali::Stage::GetCurrent().Add(actor);
-
-  //Create a Path
-  Dali::Path path = Dali::Path::New();
-  SetupPath(path);
-
-  //Create a PathConstrainer
-  Dali::PathConstrainer pathConstrainer = Dali::PathConstrainer::New();
-  SetupPathConstrainer( pathConstrainer );
-
-  //Apply the path constraint to the actor's position. The source property for the constraint will be the custom property "t"
-  Vector2 range( 100.0f, 300.0f );
-  pathConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION), Property(actor,index), range );
-
-
-  //Create an animation to animate the custom property
-  float durationSeconds(1.0f);
-  Dali::Animation animation = Dali::Animation::New(durationSeconds);
-  animation.AnimateTo(Dali::Property(actor,index),400.0f);
-  animation.Play();
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
-
-
-  Vector3 position, tangent;
-  float tValue;
-  actor.GetProperty(index).Get(tValue);
-  float currentCursor =  ( tValue - range.x ) / (range.y-range.x);
-  path.Sample(currentCursor, position, tangent );
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
-  actor.GetProperty(index).Get(tValue);
-  currentCursor =  ( tValue - range.x ) / (range.y-range.x);
-  path.Sample(currentCursor, position, tangent );
-  path.Sample(0.5, position, tangent );
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
-  actor.GetProperty(index).Get(tValue);
-  currentCursor =  ( tValue - range.x ) / (range.y-range.x);
-  path.Sample(currentCursor, position, tangent );
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 100% progress */);
-  actor.GetProperty(index).Get(tValue);
-  currentCursor =  ( tValue - range.x ) / (range.y-range.x);
-  path.Sample(currentCursor, position, tangent );
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* beyond the animation duration*/);
-  actor.GetProperty(index).Get(tValue);
-  currentCursor =  ( tValue - range.x ) / (range.y-range.x);
-  path.Sample(currentCursor, position, tangent );
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcPathConstrainerDestroy(void)
-{
-  TestApplication application;
-
-  Dali::Actor actor = Dali::Actor::New();
-
-  // Register a float property
-  Property::Index index = actor.RegisterProperty( "t", 0.0f );
-  Dali::Stage::GetCurrent().Add(actor);
-
-  {
-    //Create a Path
-    Dali::Path path = Dali::Path::New();
-    SetupPath(path);
-
-    //Create a PathConstrainer
-    Dali::PathConstrainer pathConstrainer = Dali::PathConstrainer::New();
-    SetupPathConstrainer( pathConstrainer );
-
-    //Apply the path constraint to the actor's position. The source property for the constraint will be the custom property "t"
-    Vector2 range( 0.0f, 1.0f );
-    pathConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION), Property(actor,index), range );
-
-    //Test that the constraint is correctly applied
-    actor.SetProperty(index,0.5f);
-    application.SendNotification();
-    application.Render(static_cast<unsigned int>(1.0f));
-
-    Vector3 position, tangent;
-    path.Sample(0.5f, position, tangent );
-    DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
-
-  }
-
-  //PathConstrainer has been destroyed. Constraint in the actor should have been removed
-  actor.SetProperty(index,0.75f);
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(1.0f));
-
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcPathConstrainerRemove(void)
-{
-  TestApplication application;
-
-  Dali::Actor actor = Dali::Actor::New();
-
-  // Register a float property
-  Property::Index index = actor.RegisterProperty( "t", 0.0f );
-  Dali::Stage::GetCurrent().Add(actor);
-
-  //Create a Path
-  Dali::Path path = Dali::Path::New();
-  SetupPath(path);
-
-  //Create a PathConstrainer
-  Dali::PathConstrainer pathConstrainer = Dali::PathConstrainer::New();
-  SetupPathConstrainer( pathConstrainer );
-
-  //Apply the path constraint to the actor's position. The source property for the constraint will be the custom property "t"
-  Vector2 range( 0.0f, 1.0f );
-  pathConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION), Property(actor,index), range );
-
-  //Test that the constraint is correctly applied
-  actor.SetProperty(index,0.5f);
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(1.0f));
-
-  Vector3 position, tangent;
-  path.Sample(0.5f, position, tangent );
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
-
-  //Remove constraint
-  pathConstrainer.Remove( actor );
-  actor.SetProperty(index,0.75f);
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(1.0f));
-
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
-
-  END_TEST;
-}
-
-//LinearConstrainer test cases
-int UtcLinearConstrainerDownCast(void)
-{
-  TestApplication application;
-  Dali::LinearConstrainer linearConstrainer = Dali::LinearConstrainer::New();
-
-  BaseHandle handle( linearConstrainer );
-  Dali::LinearConstrainer linearConstrainer2 = Dali::LinearConstrainer::DownCast( handle );
-  DALI_TEST_EQUALS( (bool)linearConstrainer2, true, TEST_LOCATION );
-
-  BaseHandle handle2;
-  Dali:: LinearConstrainer linearConstrainer3 = Dali::LinearConstrainer::DownCast( handle2 );
-  DALI_TEST_EQUALS( (bool)linearConstrainer3, false, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcLinearConstrainerCopyConstructor(void)
-{
-  TestApplication application;
-  Dali::LinearConstrainer linearConstrainer;
-  DALI_TEST_EQUALS( (bool)linearConstrainer, false, TEST_LOCATION );
-
-  linearConstrainer = Dali::LinearConstrainer::New();
-  DALI_TEST_EQUALS( (bool)linearConstrainer, true, TEST_LOCATION );
-
-  // call the copy constructor
-  Dali::LinearConstrainer linearConstrainer2( linearConstrainer );
-  DALI_TEST_EQUALS( (bool)linearConstrainer2, true, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcLinearConstrainerApply(void)
-{
-  TestApplication application;
-
-  Dali::Actor actor = Dali::Actor::New();
-
-  // Register a float property
-  Property::Index index = actor.RegisterProperty( "t", 0.0f );
-
-  Dali::Stage::GetCurrent().Add(actor);
-
-
-  //Create a LinearConstrainer without specifying progress for values
-  Dali::LinearConstrainer linearConstrainer = Dali::LinearConstrainer::New();
-  SetupLinearConstrainerUniformProgress( linearConstrainer );
-
-  //Apply the linear constraint to the actor's position. The source property for the constraint will be the custom property "t"
-  Vector2 range( 0.0f, 1.0f );
-  linearConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION_X), Property(actor,index), range );
-
-  //Create an animation to animate the custom property
-  float durationSeconds(1.0f);
-  Dali::Animation animation = Dali::Animation::New(durationSeconds);
-  animation.AnimateTo(Dali::Property(actor,index),1.0f);
-  animation.Play();
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
-
-  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.5f, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 1.0f, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.5f, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 100% progress */);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.0f, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* beyond the animation duration*/);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.0f, TEST_LOCATION );
-
-  //Setup a LinearConstrainer specifying the progress for each value
-  linearConstrainer.Remove(actor);
-  SetupLinearConstrainerNonUniformProgress( linearConstrainer );
-  linearConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION_X), Property(actor,index), range );
-
-  actor.SetProperty(index,0.0f);
-  animation.Play();
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
-
-  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 1.0f, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 2.0f/3.0f, Math::MACHINE_EPSILON_1, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 1.0f/3.0f, Math::MACHINE_EPSILON_1, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 100% progress */);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.0f, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* beyond the animation duration*/);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.0f, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcLinearConstrainerApplyRange(void)
-{
-  TestApplication application;
-
-  Dali::Actor actor = Dali::Actor::New();
-
-  // Register a float property
-  Property::Index index = actor.RegisterProperty( "t", 100.0f );
-  Dali::Stage::GetCurrent().Add(actor);
-
-  //Create a LinearConstrainer
-  Dali::LinearConstrainer linearConstrainer = Dali::LinearConstrainer::New();
-  SetupLinearConstrainerUniformProgress( linearConstrainer );
-
-  //Apply the linear constraint to the actor's position. The source property for the constraint will be the custom property "t"
-  Vector2 range( 100.0f, 300.0f );
-  linearConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION_X), Property(actor,index), range );
-
-
-  //Create an animation to animate the custom property
-  float durationSeconds(1.0f);
-  Dali::Animation animation = Dali::Animation::New(durationSeconds);
-  animation.AnimateTo(Dali::Property(actor,index),300.0f);
-  animation.Play();
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
-
-  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.5f, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 1.0f, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.5f, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 100% progress */);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.0f, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* beyond the animation duration*/);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.0f, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcLinearConstrainerDestroy(void)
-{
-  TestApplication application;
-
-  Dali::Actor actor = Dali::Actor::New();
-
-  // Register a float property
-  Property::Index index = actor.RegisterProperty( "t", 0.0f );
-  Dali::Stage::GetCurrent().Add(actor);
-
-  {
-    //Create a LinearConstrainer
-    Dali::LinearConstrainer linearConstrainer = Dali::LinearConstrainer::New();
-    SetupLinearConstrainerUniformProgress( linearConstrainer );
-
-    //Apply the linear constraint to the actor's position. The source property for the constraint will be the custom property "t"
-    Vector2 range( 0.0f, 1.0f );
-    linearConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION_X), Property(actor,index), range );
-
-    //Test that the constraint is correctly applied
-    actor.SetProperty(index,0.5f);
-    application.SendNotification();
-    application.Render(static_cast<unsigned int>(1.0f));
-
-    DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 1.0f, TEST_LOCATION );
-
-  }
-
-  //LinearConstrainer has been destroyed. Constraint in the actor should have been removed
-  actor.SetProperty(index,0.75f);
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(1.0f));
-
-  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.0f, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcLinearConstrainerRemove(void)
-{
-  TestApplication application;
-
-  Dali::Actor actor = Dali::Actor::New();
-
-  // Register a float property
-  Property::Index index = actor.RegisterProperty( "t", 0.0f );
-  Dali::Stage::GetCurrent().Add(actor);
-
-  //Create a LinearConstrainer
-  Dali::LinearConstrainer linearConstrainer = Dali::LinearConstrainer::New();
-  SetupLinearConstrainerUniformProgress( linearConstrainer );
-
-  //Apply the path constraint to the actor's position. The source property for the constraint will be the custom property "t"
-  Vector2 range( 0.0f, 1.0f );
-  linearConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION_X), Property(actor,index), range );
-
-  //Test that the constraint is correctly applied
-  actor.SetProperty(index,0.5f);
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(1.0f));
-
-  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 1.0f, TEST_LOCATION );
-
-  //Remove constraint
-  linearConstrainer.Remove( actor );
-  actor.SetProperty(index,0.75f);
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(1.0f));
-
-  DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 0.0f, TEST_LOCATION );
-
-  END_TEST;
-}
diff --git a/automated-tests/src/dali/utc-Dali-Context.cpp b/automated-tests/src/dali/utc-Dali-Context.cpp
deleted file mode 100644 (file)
index 54d35a6..0000000
+++ /dev/null
@@ -1,223 +0,0 @@
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/actors/mesh-actor.h>
-#include <dali-test-suite-utils.h>
-
-using namespace Dali;
-
-#include "mesh-builder.h"
-
-
-namespace
-{
-// Size of the VertexAttributeArray enables
-// GLES specification states that there's minimum of
-const unsigned int TEST_MAX_ATTRIBUTE_CACHE_SIZE = 8;
-
-enum TestAttribType
-{
-  ATTRIB_UNKNOWN = -1,
-  ATTRIB_POSITION,
-  ATTRIB_NORMAL,
-  ATTRIB_TEXCOORD,
-  ATTRIB_COLOR,
-  ATTRIB_BONE_WEIGHTS,
-  ATTRIB_BONE_INDICES,
-  ATTRIB_TYPE_LAST
-};
-
-// Create bitmap image
-static BufferImage CreateBufferImage()
-{
-  BufferImage image = BufferImage::New(4,4,Pixel::RGBA8888);
-
-  return image;
-}
-
-static MeshActor CreateMeshActor()
-{
-  MeshData meshData;
-  MeshData::VertexContainer    vertices;
-  MeshData::FaceIndices        faces;
-  BoneContainer                bones;
-  ConstructVertices(vertices, 60);
-  ConstructFaces(vertices, faces);
-  Material customMaterial = ConstructMaterial();
-  meshData.SetData(vertices, faces, bones, customMaterial);
-  meshData.SetHasNormals(true);
-  meshData.SetHasTextureCoords(true);
-
-  Mesh mesh = Mesh::New(meshData);
-  MeshActor actor = MeshActor::New(mesh);
-
-  actor.SetName("Test MeshActor");
-
-  return actor;
-}
-
-
-static ImageActor CreateImageActor()
-{
-  BufferImage image = CreateBufferImage();
-  ImageActor actor = ImageActor::New( image );
-  actor.SetSize( 100.0f, 100.0f );
-  actor.SetName("Test ImageActor");
-  return actor;
-}
-
-} // anonymous namespace
-
-
-// Positive test case for a method
-int UtcDaliContextVertexAttribStartup(void)
-{
-  tet_infoline("Testing vertex attrib initial state in context");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  // context class should initially set the vertex attrib locations to disable
-  // Make sure it has been modified
-  DALI_TEST_CHECK(application.GetGlAbstraction().GetVertexAttribArrayChanged());
-
-  // check the locations
-  for (unsigned int i = 0; i < TEST_MAX_ATTRIBUTE_CACHE_SIZE; i++)
-  {
-    DALI_TEST_CHECK( application.GetGlAbstraction().GetVertexAttribArrayState(i) == false);
-  }
-
-  tet_result(TET_PASS);
-  END_TEST;
-}
-
-// Tests to make the attribs only get set once when continually rendering an image actor
-int UtcDaliContextVertexAttribImageRendering(void)
-{
-  tet_infoline("Testing vertex attrib rendering state in context with images");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  // the vertex attribs get modified on startup to set them to disabled
-  // clear the flag to say they've changed
-  application.GetGlAbstraction().ClearVertexAttribArrayChanged();
-
-
-  // create a test image actor
-  ImageActor imageActor(CreateImageActor());
-  Stage::GetCurrent().Add(imageActor);
-
-
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  // check to make sure the state has changed (the image renderer will enable some
-  // locations).
-  DALI_TEST_CHECK(application.GetGlAbstraction().GetVertexAttribArrayChanged());
-
-  // Now check to make sure the state is cached, and isn't being set each frame.
-  application.GetGlAbstraction().ClearVertexAttribArrayChanged();
-
-  application.Render();
-  application.Render();
-  application.Render();
-
-  // if it has changed then the caching has failed
-  DALI_TEST_CHECK(application.GetGlAbstraction().GetVertexAttribArrayChanged() == false);
-
-
-  tet_result(TET_PASS);
-  END_TEST;
-}
-
-// test to make sure the attribs change when rendering both image and mode actors
-int UtcDaliContextVertexAttribImageAndModelRendering(void)
-{
-  tet_infoline("Testing vertex attrib rendering state in context with images and models");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  // the vertex attribs get modified on startup to set them to disabled
-  // clear the flag to say they've changed
-  application.GetGlAbstraction().ClearVertexAttribArrayChanged();
-
-  // create a test image and mesh actor.
-
-  MeshActor meshActor(CreateMeshActor());
-  Stage::GetCurrent().Add(meshActor);
-
-  ImageActor imageActor(CreateImageActor());
-  Stage::GetCurrent().Add(imageActor);
-
-
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  // check to make sure the state changes during the rendering of a frame
-  DALI_TEST_CHECK(application.GetGlAbstraction().GetVertexAttribArrayChanged());
-
-  // Now check to make sure the state is changing each frame.
-  application.GetGlAbstraction().ClearVertexAttribArrayChanged();
-
-  application.Render();
-  application.Render();
-  application.Render();
-
-  // make sure the state has changed
-  DALI_TEST_CHECK(application.GetGlAbstraction().GetVertexAttribArrayChanged());
-
-  // depending on the order of drawing, one of the attrib locations should be disabled
-  // Image uses locations 0 & 2  (position, texture)
-  // Model uses locations 0 & 1  (position, normals) -no textures
-  // so either location 1 or location 2 should be disabled after drawing.
-
-  // see if mesh was last to draw
-  if (application.GetGlAbstraction().GetVertexAttribArrayState(ATTRIB_NORMAL))
-  {
-    // texture should be disabled
-    DALI_TEST_CHECK( application.GetGlAbstraction().GetVertexAttribArrayState(ATTRIB_TEXCOORD) == false)
-  }
-  else
-  {
-    // image was to draw so, normals should be disabled
-    DALI_TEST_CHECK( application.GetGlAbstraction().GetVertexAttribArrayState(ATTRIB_NORMAL) == false)
-  }
-
-  tet_result(TET_PASS);
-
-  END_TEST;
-}
diff --git a/automated-tests/src/dali/utc-Dali-DistanceField.cpp b/automated-tests/src/dali/utc-Dali-DistanceField.cpp
deleted file mode 100644 (file)
index b9ab2da..0000000
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <iostream>
-#include <algorithm>
-
-#include <stdlib.h>
-
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/images/distance-field.h>
-#include <dali-test-suite-utils.h>
-
-using std::max;
-using namespace Dali;
-
-namespace
-{
-
-static const float ROTATION_EPSILON = 0.0001f;
-
-static unsigned char sourceImage[] =
-{
- 0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,
- 0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,
- 0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,
- 0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
-};
-
-} // anonymous namespace
-
-
-
-int UtcDaliGenerateDistanceField(void)
-{
-  unsigned char distanceField[4*4];
-
-  GenerateDistanceFieldMap(sourceImage, Size(8.0f, 8.0f), distanceField, Size(4.0f, 4.0f), 0, Size(4.0f, 4.0f));
-
-  if(distanceField[0]  <= distanceField[5] &&
-     distanceField[5]  <= distanceField[10] &&
-     distanceField[10] <= distanceField[15])
-  {
-    tet_result(TET_PASS);
-  }
-  else
-  {
-    tet_result(TET_FAIL);
-  }
-  END_TEST;
-}
diff --git a/automated-tests/src/dali/utc-Dali-DynamicsBody.cpp b/automated-tests/src/dali/utc-Dali-DynamicsBody.cpp
deleted file mode 100644 (file)
index 3c09a8d..0000000
+++ /dev/null
@@ -1,605 +0,0 @@
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <iostream>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali-test-suite-utils.h>
-#include <dali/devel-api/dynamics/dynamics.h>
-
-int UtcDaliDynamicsBodyConstructor(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsBodyConstructor - DynamicsBody::DynamicsBody()");
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  // Default constructor - create an uninitialized handle
-  DynamicsBody body;
-  DALI_TEST_CHECK( !body );
-
-  // create world and actor
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  Actor actor(Actor::New());
-
-  // enable dynamics on the actor to create the Dynamicsbody
-  actor.EnableDynamics(bodyConfig);
-
-  // initialize handle
-  body = actor.GetDynamicsBody();
-
-  DALI_TEST_CHECK( body );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyGetMass(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  const float testMass = 1.23f;
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  bodyConfig.SetMass(testMass);
-  Actor actor(Actor::New());
-
-  // enable dynamics on the actor to create the Dynamicsbody
-  actor.EnableDynamics(bodyConfig);
-
-  tet_infoline("UtcDaliDynamicsBodyGetMass - DynamicsBody::GetMass");
-  DALI_TEST_EQUALS( testMass, actor.GetDynamicsBody().GetMass(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyGetElasticity(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  const float testElasticity = 1.23f;
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  bodyConfig.SetElasticity(testElasticity);
-  Actor actor(Actor::New());
-
-  // enable dynamics on the actor to create the Dynamicsbody
-  actor.EnableDynamics(bodyConfig);
-
-  tet_infoline("UtcDaliDynamicsBodyGetMass - DynamicsBody::GetElasticity");
-  DALI_TEST_EQUALS( testElasticity, actor.GetDynamicsBody().GetElasticity(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodySetLinearVelocity(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsBodySetLinearVelocity - DynamicsBody::SetLinearVelocity");
-
-  TestApplication application;
-  TraceCallStack& trace( application.GetPlatform().GetTrace() );
-  trace.Enable( true );
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  Actor actor(Actor::New());
-
-  // enable dynamics on the actor to create the Dynamicsbody
-  actor.EnableDynamics(bodyConfig);
-
-  DynamicsBody body(actor.GetDynamicsBody());
-  body.SetLinearVelocity(Vector3::ONE);
-
-  DALI_TEST_CHECK( ! trace.FindMethod( "DynamicsBody::SetLinearVelocity" ) );
-
-  // update
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DALI_TEST_CHECK( trace.FindMethod( "DynamicsBody::SetLinearVelocity" ) );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodySetAngularVelocity(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsBodySetAngularVelocity - DynamicsBody::SetAngularVelocity");
-
-  TestApplication application;
-  TraceCallStack& trace( application.GetPlatform().GetTrace() );
-  trace.Enable( true );
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  Actor actor(Actor::New());
-
-  // enable dynamics on the actor to create the Dynamicsbody
-  actor.EnableDynamics(bodyConfig);
-
-  DynamicsBody body(actor.GetDynamicsBody());
-  body.SetAngularVelocity(Vector3::ONE);
-
-  DALI_TEST_CHECK( ! trace.FindMethod( "DynamicsBody::SetAngularVelocity" ) );
-
-  // update
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DALI_TEST_CHECK( trace.FindMethod( "DynamicsBody::SetAngularVelocity" ) );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodySetKinematic(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  const float testMass = 1.0f;
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  bodyConfig.SetMass(testMass);
-  Actor actor(Actor::New());
-
-  // enable dynamics on the actor to create the Dynamicsbody
-  actor.EnableDynamics(bodyConfig);
-
-  DynamicsBody body(actor.GetDynamicsBody());
-
-  DALI_TEST_EQUALS( testMass, body.GetMass(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-
-  tet_infoline("UtcDaliDynamicsBodySetKinematic - DynamicsBody::SetKinematic(true)");
-  body.SetKinematic(true);
-
-  DALI_TEST_CHECK( body.IsKinematic() );
-  DALI_TEST_EQUALS( 0.0f, body.GetMass(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-
-  tet_infoline("UtcDaliDynamicsBodySetKinematic - DynamicsBody::SetKinematic(false)");
-  body.SetKinematic(false);
-  DALI_TEST_CHECK( !body.IsKinematic() );
-  DALI_TEST_EQUALS( testMass, body.GetMass(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyIsKinematic(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  const float testMass = 1.0f;
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  bodyConfig.SetMass(testMass);
-  Actor actor(Actor::New());
-
-  // enable dynamics on the actor to create the Dynamicsbody
-  actor.EnableDynamics(bodyConfig);
-
-  DynamicsBody body(actor.GetDynamicsBody());
-
-  DALI_TEST_EQUALS( testMass, body.GetMass(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-
-  tet_infoline("UtcDaliDynamicsBodySetKinematic - DynamicsBody::IsSetKinematic");
-  body.SetKinematic(true);
-
-  DALI_TEST_CHECK( body.IsKinematic() );
-  body.SetKinematic(false);
-  DALI_TEST_CHECK( !body.IsKinematic() );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodySetSleepEnabled(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsBodySetSleepEnabled");
-
-  TestApplication application;
-  TraceCallStack& trace( application.GetPlatform().GetTrace() );
-  trace.Enable( true );
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  Actor actor(Actor::New());
-
-  // enable dynamics on the actor to create the Dynamicsbody
-  actor.EnableDynamics(bodyConfig);
-
-  DynamicsBody body(actor.GetDynamicsBody());
-
-  // SleepEnabled true by default
-  DALI_TEST_CHECK( body.GetSleepEnabled() );
-  body.SetSleepEnabled(false);
-
-  DALI_TEST_CHECK( ! trace.FindMethod( "DynamicsBody::SetSleepEnabled" ) );
-
-  // update
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DALI_TEST_CHECK( trace.FindMethod( "DynamicsBody::SetSleepEnabled" ) );
-
-  DALI_TEST_CHECK( ! body.GetSleepEnabled() );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyGetSleepEnabled(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsBodyGetSleepEnabled");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  Actor actor(Actor::New());
-
-  // enable dynamics on the actor to create the Dynamicsbody
-  actor.EnableDynamics(bodyConfig);
-
-  DynamicsBody body(actor.GetDynamicsBody());
-
-  // SleepEnabled true by default
-  DALI_TEST_CHECK( body.GetSleepEnabled() );
-  body.SetSleepEnabled(false);
-  DALI_TEST_CHECK( !body.GetSleepEnabled() );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyWakeUp(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsBodyWakeUp");
-
-  TestApplication application;
-  TraceCallStack& trace( application.GetPlatform().GetTrace() );
-  trace.Enable( true );
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  Actor actor(Actor::New());
-
-  // enable dynamics on the actor to create the Dynamicsbody
-  actor.EnableDynamics(bodyConfig);
-
-  DynamicsBody body(actor.GetDynamicsBody());
-
-  body.WakeUp();
-
-  DALI_TEST_CHECK( ! trace.FindMethod( "DynamicsBody::WakeUp" ) );
-
-  // update
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DALI_TEST_CHECK( trace.FindMethod( "DynamicsBody::WakeUp" ) );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyAddAnchor(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsBodyAddAnchor - DynamicsBody::AddAnchor()");
-
-  TestApplication application;
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  worldConfig.SetType(DynamicsWorldConfig::SOFT);
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  Actor rootActor(Actor::New());
-  world.SetRootActor(rootActor);
-  Stage::GetCurrent().Add(rootActor);
-
-  DynamicsBodyConfig softConfig( DynamicsBodyConfig::New() );
-  softConfig.SetType(DynamicsBodyConfig::SOFT);
-  Cloth mesh(Cloth::New(10.0f, 10.0f, 10, 10));
-  DynamicsShape meshShape(DynamicsShape::NewMesh(mesh));
-  softConfig.SetShape( meshShape );
-  softConfig.SetMass(1.0f);
-  MeshActor softActor(MeshActor::New(mesh));
-
-  rootActor.Add(softActor);
-  softActor.EnableDynamics(softConfig);
-  DynamicsBody softBody(softActor.GetDynamicsBody());
-
-  DynamicsBodyConfig anchorConfig(DynamicsBodyConfig::New());
-  anchorConfig.SetMass(0.0f);
-  Actor anchor(Actor::New());
-  rootActor.Add(anchor);
-  anchor.EnableDynamics(anchorConfig);
-  DynamicsBody anchorBody(anchor.GetDynamicsBody());
-  anchorBody.SetKinematic(true);
-  try
-  {
-    softBody.AddAnchor(0, anchorBody, false);
-
-    DALI_TEST_CHECK(true)
-  }
-  catch(Dali::DaliException& e)
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_CHECK( false );
-  }
-
-  rootActor.Remove(softActor);
-  rootActor.Remove(anchor);
-  Stage::GetCurrent().Remove(rootActor);
-  softActor.DisableDynamics();
-  anchor.DisableDynamics();
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConserveVolume(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsBodyConserveVolume");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  Actor actor(Actor::New());
-
-  // enable dynamics on the actor to create the Dynamicsbody
-  actor.EnableDynamics(bodyConfig);
-
-  DynamicsBody body(actor.GetDynamicsBody());
-
-  body.ConserveVolume(false);
-  DALI_TEST_CHECK( true );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConserveShape(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsBodyConserveShape");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  Actor actor(Actor::New());
-
-  // enable dynamics on the actor to create the Dynamicsbody
-  actor.EnableDynamics(bodyConfig);
-
-  DynamicsBody body(actor.GetDynamicsBody());
-
-  body.ConserveShape(false);
-  DALI_TEST_CHECK( true );
-  END_TEST;
-}
diff --git a/automated-tests/src/dali/utc-Dali-DynamicsBodyConfig.cpp b/automated-tests/src/dali/utc-Dali-DynamicsBodyConfig.cpp
deleted file mode 100644 (file)
index 30ae434..0000000
+++ /dev/null
@@ -1,679 +0,0 @@
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali-test-suite-utils.h>
-#include <dali/devel-api/dynamics/dynamics.h>
-
-using namespace Dali;
-
-
-int UtcDaliDynamicsBodyConfigNew(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-
-  tet_infoline("UtcDaliDynamicsBodyConfigNew - DynamicsBodyConfig::New()");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig config(DynamicsBodyConfig::New());
-
-  DALI_TEST_CHECK( config );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConfigConstructor(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsBodyConfigConstructor - DynamicsBodyConfig::DynamicsBodyConfig()");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  // Default constructor - create an uninitialized handle
-  DynamicsBodyConfig config;
-
-  DALI_TEST_CHECK( !config );
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  // initialize handle
-  config = DynamicsBodyConfig::New();
-
-  DALI_TEST_CHECK( config );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConfigType(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig config(DynamicsBodyConfig::New());
-
-  tet_infoline("UtcDaliDynamicsBodyConfigType - DynamicsBodyConfig::GetType");
-  DALI_TEST_CHECK( DynamicsBodyConfig::RIGID == config.GetType() );
-
-  tet_infoline("UtcDaliDynamicsBodyConfigType - DynamicsBodyConfig::SetType(const BodyType)");
-  config.SetType( DynamicsBodyConfig::SOFT );
-  DALI_TEST_CHECK( DynamicsBodyConfig::SOFT == config.GetType() );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConfigSetShape01(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsBodyConfigSetShape01 - DynamicsBodyConfig::SetShape(const DynamicsShape::ShapeType,const Vector3&)");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig config(DynamicsBodyConfig::New());
-
-  DALI_TEST_CHECK( DynamicsShape::CUBE == config.GetShape().GetType() );
-
-  const float radius(1.5f);
-  config.SetShape(DynamicsShape::SPHERE, Vector3(radius, 0.0f, 0.0f));
-
-  DALI_TEST_CHECK( DynamicsShape::SPHERE == config.GetShape().GetType() );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConfigSetShape02(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsBodyConfigSetShape02 - DynamicsBodyConfig::SetShape(DynamicsShape)");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig config(DynamicsBodyConfig::New());
-
-  DALI_TEST_CHECK( DynamicsShape::CUBE == config.GetShape().GetType() );
-
-  const float radius(1.5f);
-  DynamicsShape shape(DynamicsShape::NewSphere(radius));
-  config.SetShape(shape);
-
-  DALI_TEST_CHECK( DynamicsShape::SPHERE == config.GetShape().GetType() );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConfigGetShape(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsBodyConfigGetShape - DynamicsBodyConfig::GetShape");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig config(DynamicsBodyConfig::New());
-
-  DALI_TEST_CHECK( DynamicsShape::CUBE == config.GetShape().GetType() );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConfigMass(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  const float testMass = 1.23f;
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig config(DynamicsBodyConfig::New());
-  config.SetMass(testMass);
-
-  tet_infoline("UtcDaliDynamicsBodyConfigMass - DynamicsBodyConfig::GetMass");
-  DALI_TEST_EQUALS( testMass, config.GetMass(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-
-  tet_infoline("UtcDaliDynamicsBodyConfigMass - DynamicsBodyConfig::SetMass");
-  const float mass = config.GetMass() + 0.1f;
-  config.SetMass(mass);
-  DALI_TEST_EQUALS( mass, config.GetMass(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConfigElasticity(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  const float testElasticity = 0.87f;
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig config(DynamicsBodyConfig::New());
-  config.SetElasticity(testElasticity);
-
-  tet_infoline("UtcDaliDynamicsBodyConfigElasticity- DynamicsBodyConfig::GetElasticity");
-  DALI_TEST_EQUALS( testElasticity, config.GetElasticity(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-
-  tet_infoline("UtcDaliDynamicsBodyConfigElasticity - DynamicsBodyConfig::SetElasticity");
-  const float elasticity = config.GetElasticity() + 0.1f;
-  config.SetElasticity(elasticity);
-  DALI_TEST_EQUALS( elasticity, config.GetElasticity(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConfigFriction(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  const float testFriction= 0.87f;
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig config(DynamicsBodyConfig::New());
-  config.SetFriction(testFriction);
-
-  tet_infoline("UtcDaliDynamicsBodyConfigFriction - DynamicsBodyConfig::GetFriction");
-  DALI_TEST_EQUALS( testFriction, config.GetFriction(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-
-  tet_infoline("UtcDaliDynamicsBodyConfigFriction - DynamicsBodyConfig::SetFriction");
-  const float friction = config.GetFriction() + 0.1f;
-  config.SetFriction(friction);
-  DALI_TEST_EQUALS( friction, config.GetFriction(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConfigLinearDamping(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  const float testDamping = 0.123f;
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig config(DynamicsBodyConfig::New());
-  config.SetLinearDamping(testDamping);
-
-  tet_infoline("UtcDaliDynamicsBodyConfigLinearDamping- DynamicsBodyConfig::GetLinearDamping");
-  DALI_TEST_EQUALS( testDamping, config.GetLinearDamping(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-
-  tet_infoline("UtcDaliDynamicsBodyConfigLinearDamping - DynamicsBodyConfig::SetLinearDamping");
-  const float damping = config.GetLinearDamping() + 0.1f;
-  config.SetLinearDamping(damping);
-  DALI_TEST_EQUALS( damping, config.GetLinearDamping(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConfigAngularDamping(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  const float testDamping = 0.123f;
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig config(DynamicsBodyConfig::New());
-  config.SetAngularDamping(testDamping);
-
-  tet_infoline("UtcDaliDynamicsBodyConfigAngularDamping- DynamicsBodyConfig::GetAngularDamping");
-  DALI_TEST_EQUALS( testDamping, config.GetAngularDamping(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-
-  tet_infoline("UtcDaliDynamicsBodyConfigAngularDamping - DynamicsBodyConfig::SetAngularDamping");
-  const float damping = config.GetAngularDamping() + 0.1f;
-  config.SetAngularDamping(damping);
-  DALI_TEST_EQUALS( damping, config.GetAngularDamping(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConfigLinearSleepVelocity(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  const float testSleepVelocity = 0.123f;
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig config(DynamicsBodyConfig::New());
-  config.SetLinearSleepVelocity(testSleepVelocity);
-
-  tet_infoline("UtcDaliDynamicsBodyConfigLinearSleepVelocity - DynamicsBodyConfig::GetLinearSleepVelocity");
-  DALI_TEST_EQUALS( testSleepVelocity, config.GetLinearSleepVelocity(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-
-  tet_infoline("UtcDaliDynamicsBodyConfigLinearSleepVelocity - DynamicsBodyConfig::SetLinearSleepVelocity");
-  const float sleepVelocity = config.GetLinearSleepVelocity() + 0.1f;
-  config.SetLinearSleepVelocity(sleepVelocity);
-  DALI_TEST_EQUALS( sleepVelocity, config.GetLinearSleepVelocity(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConfigAngularSleepVelocity(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  const float testSleepVelocity = 0.123f;
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig config(DynamicsBodyConfig::New());
-  config.SetAngularSleepVelocity(testSleepVelocity);
-
-  tet_infoline("UtcDaliDynamicsBodyConfigAngularSleepVelocity - DynamicsBodyConfig::GetAngularSleepVelocity");
-  DALI_TEST_EQUALS( testSleepVelocity, config.GetAngularSleepVelocity(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-
-  tet_infoline("UtcDaliDynamicsBodyConfigAngularSleepVelocity - DynamicsBodyConfig::SetAngularSleepVelocity");
-  const float sleepVelocity = config.GetAngularSleepVelocity() + 0.1f;
-  config.SetAngularSleepVelocity(sleepVelocity);
-  DALI_TEST_EQUALS( sleepVelocity, config.GetAngularSleepVelocity(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConfigCollisionGroup(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  const short int testGroup = 0x1234;
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig config(DynamicsBodyConfig::New());
-  config.SetCollisionGroup(testGroup);
-
-  tet_infoline("UtcDaliDynamicsBodyConfigCollisionGroup- DynamicsBodyConfig::GetCollisionGroup");
-  DALI_TEST_EQUALS( testGroup, config.GetCollisionGroup(), TEST_LOCATION );
-
-  tet_infoline("UtcDaliDynamicsBodyConfigCollisionGroup - DynamicsBodyConfig::SetCollisionGroup");
-  const short int group = config.GetCollisionGroup() + 1;
-  config.SetCollisionGroup(group);
-  DALI_TEST_EQUALS( group, config.GetCollisionGroup(), TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConfigCollisionMask(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  const short int testMask = 0x7ffe;
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig config(DynamicsBodyConfig::New());
-  config.SetCollisionMask(testMask);
-
-  tet_infoline("UtcDaliDynamicsBodyConfigCollisionMask- DynamicsBodyConfig::GetCollisionMask");
-  DALI_TEST_EQUALS( testMask, config.GetCollisionMask(), TEST_LOCATION );
-
-  tet_infoline("UtcDaliDynamicsBodyConfigCollisionMask - DynamicsBodyConfig::SetCollisionMask");
-  const short int mask = config.GetCollisionMask() + 1;
-  config.SetCollisionMask(mask);
-  DALI_TEST_EQUALS( mask, config.GetCollisionMask(), TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConfigAnchorHardness(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  const float testHardness = 0.87f;
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig config(DynamicsBodyConfig::New());
-  config.SetAnchorHardness(testHardness);
-
-  tet_infoline("UtcDaliDynamicsBodyConfigAnchorHardness - DynamicsBodyConfig::GetAnchorHardness");
-  DALI_TEST_EQUALS( testHardness, config.GetAnchorHardness(), Math::MACHINE_EPSILON_0, TEST_LOCATION );
-
-  tet_infoline("UtcDaliDynamicsBodyConfigAnchorHardness - DynamicsBodyConfig::SetAnchorHardness");
-  const float hardness = config.GetAnchorHardness() + 0.1f;
-  config.SetAnchorHardness(hardness);
-  DALI_TEST_EQUALS( hardness, config.GetAnchorHardness(), Math::MACHINE_EPSILON_1, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConfigVolumeConservation(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsBodyConfigVolumeConservation");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig config(DynamicsBodyConfig::New());
-
-  const float conservation = config.GetVolumeConservation() + 0.1f;
-  config.SetVolumeConservation(conservation);
-  DALI_TEST_EQUALS( conservation, config.GetVolumeConservation(), Math::MACHINE_EPSILON_1, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliDynamicsBodyConfigShapeConservation(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsBodyConfigShapeConservation");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig config(DynamicsBodyConfig::New());
-
-  const float conservation = config.GetShapeConservation() + 0.1f;
-  config.SetShapeConservation(conservation);
-  DALI_TEST_EQUALS( conservation, config.GetShapeConservation(), Math::MACHINE_EPSILON_1, TEST_LOCATION );
-  END_TEST;
-}
diff --git a/automated-tests/src/dali/utc-Dali-DynamicsJoint.cpp b/automated-tests/src/dali/utc-Dali-DynamicsJoint.cpp
deleted file mode 100644 (file)
index 854fd87..0000000
+++ /dev/null
@@ -1,378 +0,0 @@
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <iostream>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali-test-suite-utils.h>
-#include <dali/devel-api/dynamics/dynamics.h>
-
-using namespace Dali;
-
-
-int UtcDaliDynamicsJointConstructor(void)
-{
-  tet_infoline("UtcDaliDynamicsJointConstructor - DynamicsJoint::DynamicsJoint");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsJoint joint;
-
-  DALI_TEST_CHECK( !joint );
-  END_TEST;
-}
-
-int UtcDaliDynamicsJointLinearLimit(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  Actor actor1(Actor::New());
-  actor1.EnableDynamics(bodyConfig);
-  Actor actor2(Actor::New());
-  actor2.EnableDynamics(bodyConfig);
-
-  DynamicsJoint joint( actor1.AddDynamicsJoint(actor2, Vector3() ) );
-
-  if( joint )
-  {
-    tet_infoline("UtcDaliDynamicsJointLinearLimit - DynamicsJoint::SetLinearLimit()");
-    joint.SetLinearLimit(DynamicsJoint::LINEAR_X, 0.0f, 1.0f);
-  }
-  DALI_TEST_CHECK( true );
-  END_TEST;
-}
-
-int UtcDaliDynamicsJointAngularLimit(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  Actor actor1(Actor::New());
-  actor1.EnableDynamics(bodyConfig);
-  Actor actor2(Actor::New());
-  actor2.EnableDynamics(bodyConfig);
-
-  DynamicsJoint joint( actor1.AddDynamicsJoint(actor2, Vector3() ) );
-
-  tet_infoline("UtcDaliDynamicsJointAngularLimit - DynamicsJoint::SetAngularLimit()");
-  joint.SetAngularLimit(DynamicsJoint::ANGULAR_X, Degree(0.0f), Degree(1.0f) );
-  DALI_TEST_CHECK( true );
-  END_TEST;
-}
-
-int UtcDaliDynamicsJointEnableSpring(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  Actor actor1(Actor::New());
-  actor1.EnableDynamics(bodyConfig);
-  Actor actor2(Actor::New());
-  actor2.EnableDynamics(bodyConfig);
-
-  DynamicsJoint joint( actor1.AddDynamicsJoint(actor2, Vector3() ) );
-
-  tet_infoline("UtcDaliDynamicsJointEnableSpring");
-  joint.EnableSpring(DynamicsJoint::LINEAR_X, true );
-  DALI_TEST_CHECK( true );
-  END_TEST;
-}
-
-int UtcDaliDynamicsJointSetSpringStiffness(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  Actor actor1(Actor::New());
-  actor1.EnableDynamics(bodyConfig);
-  Actor actor2(Actor::New());
-  actor2.EnableDynamics(bodyConfig);
-
-  DynamicsJoint joint( actor1.AddDynamicsJoint(actor2, Vector3() ) );
-
-  tet_infoline("UtcDaliDynamicsJointSetSpringStiffness");
-  joint.SetSpringStiffness(DynamicsJoint::LINEAR_X, 1.0f );
-  DALI_TEST_CHECK( true );
-  END_TEST;
-}
-
-int UtcDaliDynamicsJointSetSpringCenterPoint(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  Actor actor1(Actor::New());
-  actor1.EnableDynamics(bodyConfig);
-  Actor actor2(Actor::New());
-  actor2.EnableDynamics(bodyConfig);
-
-  DynamicsJoint joint( actor1.AddDynamicsJoint(actor2, Vector3() ) );
-
-  tet_infoline("UtcDaliDynamicsJointSetSpringCenterPoint");
-  joint.SetSpringCenterPoint(DynamicsJoint::LINEAR_X, 0.5f );
-  DALI_TEST_CHECK( true );
-  END_TEST;
-}
-
-int UtcDaliDynamicsJointEnableMotor(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  Actor actor1(Actor::New());
-  actor1.EnableDynamics(bodyConfig);
-  Actor actor2(Actor::New());
-  actor2.EnableDynamics(bodyConfig);
-
-  DynamicsJoint joint( actor1.AddDynamicsJoint(actor2, Vector3() ) );
-
-  tet_infoline("UtcDaliDynamicsJointEnableMotor");
-  joint.EnableMotor(DynamicsJoint::LINEAR_X, true );
-  DALI_TEST_CHECK( true );
-  END_TEST;
-}
-
-int UtcDaliDynamicsJointSetMotorVelocity(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  Actor actor1(Actor::New());
-  actor1.EnableDynamics(bodyConfig);
-  Actor actor2(Actor::New());
-  actor2.EnableDynamics(bodyConfig);
-
-  DynamicsJoint joint( actor1.AddDynamicsJoint(actor2, Vector3() ) );
-
-  tet_infoline("UtcDaliDynamicsJointSetMotorVelocity");
-  joint.SetMotorVelocity(DynamicsJoint::LINEAR_X, 1.0f );
-  DALI_TEST_CHECK( true );
-  END_TEST;
-}
-
-int UtcDaliDynamicsJointSetMotorForce(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  Actor actor1(Actor::New());
-  actor1.EnableDynamics(bodyConfig);
-  Actor actor2(Actor::New());
-  actor2.EnableDynamics(bodyConfig);
-
-  DynamicsJoint joint( actor1.AddDynamicsJoint(actor2, Vector3() ) );
-
-  tet_infoline("UtcDaliDynamicsJointSetMotorForce");
-  joint.SetMotorForce(DynamicsJoint::LINEAR_X, 0.5f );
-  DALI_TEST_CHECK( true );
-  END_TEST;
-}
-
-int UtcDaliDynamicsJointGetActor(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  DynamicsBodyConfig bodyConfig(DynamicsBodyConfig::New());
-  Actor actor1(Actor::New());
-  actor1.EnableDynamics(bodyConfig);
-  Actor actor2(Actor::New());
-  actor2.EnableDynamics(bodyConfig);
-
-  DynamicsJoint joint( actor1.AddDynamicsJoint(actor2, Vector3() ) );
-
-  tet_infoline("UtcDaliDynamicsJointGetActor");
-  DALI_TEST_CHECK( joint.GetActor(true) == actor1 && joint.GetActor(false) == actor2 );
-  END_TEST;
-}
diff --git a/automated-tests/src/dali/utc-Dali-DynamicsShape.cpp b/automated-tests/src/dali/utc-Dali-DynamicsShape.cpp
deleted file mode 100644 (file)
index 43f723d..0000000
+++ /dev/null
@@ -1,298 +0,0 @@
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <iostream>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali-test-suite-utils.h>
-#include <dali/devel-api/dynamics/dynamics.h>
-
-using namespace Dali;
-
-
-int UtcDaliDynamicsShapeConstructor(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsShapeConstructor - DynamicsShape::DynamicsShape");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( world )
-  {
-
-    // Default constructor - create an uninitialized handle
-    DynamicsShape shape;
-    DALI_TEST_CHECK( !shape );
-
-    // initialize handle
-    shape = DynamicsShape::NewCube(Vector3::ONE);
-
-    DALI_TEST_CHECK( shape );
-  }
-  else
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-  }
-
-  END_TEST;
-}
-
-int UtcDaliDynamicsShapeNewCapsule(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsShapeNewCapsule - DynamicsShape::NewCapsule");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( world )
-  {
-
-    DynamicsShape shape( DynamicsShape::NewCapsule( 1.0f, 2.0f ) );
-
-    DALI_TEST_CHECK( shape );
-    DALI_TEST_CHECK( DynamicsShape::CAPSULE == shape.GetType() );
-  }
-  else
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-  }
-
-  END_TEST;
-}
-
-int UtcDaliDynamicsShapeNewCone(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsShapeNewCone - DynamicsShape::NewCone");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( world )
-  {
-    DynamicsShape shape( DynamicsShape::NewCone( 1.0f, 2.0f ) );
-
-    DALI_TEST_CHECK( shape );
-    DALI_TEST_CHECK( DynamicsShape::CONE == shape.GetType() );
-  }
-  else
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-  }
-
-  END_TEST;
-}
-
-int UtcDaliDynamicsShapeNewCube(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsShapeNewCube - DynamicsShape::NewCube");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( world )
-  {
-    DynamicsShape shape( DynamicsShape::NewCube( Vector3::ONE ) );
-
-    DALI_TEST_CHECK( shape );
-    DALI_TEST_CHECK( DynamicsShape::CUBE == shape.GetType() );
-  }
-  else
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-  }
-  END_TEST;
-}
-
-int UtcDaliDynamicsShapeNewCylinder(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsShapeNewCylinder - DynamicsShape::NewCylinder");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( world )
-  {
-    DynamicsShape shape( DynamicsShape::NewCylinder( 1.0f, 2.0f ) );
-
-    DALI_TEST_CHECK( shape );
-    DALI_TEST_CHECK( DynamicsShape::CYLINDER == shape.GetType() );
-  }
-  else
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-  }
-  END_TEST;
-}
-
-int UtcDaliDynamicsShapeNewMesh(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsShapeNewMesh - DynamicsShape::NewMesh");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( world )
-  {
-    DynamicsShape shape( DynamicsShape::NewMesh( Cloth::New(10.0f, 10.0f, 10, 10)) );
-
-    DALI_TEST_CHECK( shape );
-    DALI_TEST_CHECK( DynamicsShape::MESH == shape.GetType() );
-  }
-  else
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-  }
-  END_TEST;
-}
-
-int UtcDaliDynamicsShapeNewSphere(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsShapeNewSphere - DynamicsShape::NewSphere");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( world )
-  {
-    DynamicsShape shape( DynamicsShape::NewSphere( 1.0f ) );
-
-    DALI_TEST_CHECK( shape );
-    DALI_TEST_CHECK( DynamicsShape::SPHERE == shape.GetType() );
-  }
-  else
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-  }
-  END_TEST;
-}
-
-int UtcDaliDynamicsShapeGetType(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsShapeGetType - DynamicsShape::GetType");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( world )
-  {
-    DynamicsShape shape( DynamicsShape::NewSphere( 1.0f ) );
-
-    DALI_TEST_CHECK( shape );
-    DALI_TEST_CHECK( DynamicsShape::SPHERE == shape.GetType() );
-  }
-  else
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-  }
-  END_TEST;
-}
diff --git a/automated-tests/src/dali/utc-Dali-DynamicsWorld.cpp b/automated-tests/src/dali/utc-Dali-DynamicsWorld.cpp
deleted file mode 100644 (file)
index f567f9e..0000000
+++ /dev/null
@@ -1,212 +0,0 @@
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <iostream>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali-test-suite-utils.h>
-#include <test-dynamics.h>
-#include <dali/devel-api/dynamics/dynamics.h>
-
-using namespace Dali;
-
-int UtcDaliStageInitializeDynamics(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  Stage stage = Stage::GetCurrent();
-  TraceCallStack& trace = application.GetPlatform().GetTrace();
-  trace.Enable(true);
-  DALI_TEST_CHECK( stage.InitializeDynamics( DynamicsWorldConfig::New() ) );
-  DALI_TEST_CHECK( trace.FindMethod( "GetDynamicsFactory" ) );
-  DALI_TEST_CHECK( trace.FindMethod( "DynamicsFactory::InitializeDynamics" ) );
-  END_TEST;
-}
-
-int UtcDaliStageGetDynamicsWorld(void)
-{
-  TestApplication application;
-
-  Stage stage = Stage::GetCurrent();
-
-  DALI_TEST_CHECK( !stage.GetDynamicsWorld() );
-  END_TEST;
-}
-
-int UtcDaliStageTerminateDynamics(void)
-{
-  TestApplication application;
-
-  Stage stage = Stage::GetCurrent();
-
-  stage.TerminateDynamics();
-
-  DALI_TEST_CHECK( !stage.GetDynamicsWorld() );
-  END_TEST;
-}
-
-int UtcDaliDynamicsWorldConstructor(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsWorldConstructor - DynamicsWorld::DynamicsWorld");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  // Default constructor - create an uninitialized handle
-  DynamicsWorld world;
-  DALI_TEST_CHECK( !world );
-
-  // initialize handle
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  world = Stage::GetCurrent().InitializeDynamics(worldConfig);
-
-  DALI_TEST_CHECK( world );
-  END_TEST;
-}
-
-int UtcDaliDynamicsWorldGravity(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-  TraceCallStack& trace( application.GetPlatform().GetTrace() );
-  trace.Enable( true );
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  const Vector3 gravity(1.0f, 2.0f, 3.0f);
-
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  tet_infoline("UtcDaliDynamicsWorldGravity - DynamicsWorld::SetGravity");
-  world.SetGravity(gravity);
-
-  // update
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DALI_TEST_CHECK( trace.FindMethod( "DynamicsWorld::SetGravity" ) );
-
-  tet_infoline("UtcDaliDynamicsWorldGravity - DynamicsWorld::GetGravity");
-  DALI_TEST_EQUALS(gravity, world.GetGravity(), TEST_LOCATION);
-  END_TEST;
-}
-
-int UtcDaliDynamicsWorldDebugDrawMode(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-  TraceCallStack& trace( application.GetPlatform().GetTrace() );
-  trace.Enable( true );
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  const Vector3 gravity(1.0f, 2.0f, 3.0f);
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  const int mode(DynamicsWorld::DEBUG_MODE_WIREFRAME | DynamicsWorld::DEBUG_MODE_AABB);
-
-  tet_infoline("UtcDaliDynamicsWorldDebugDrawMode - DynamicsWorld::SetDebugDrawMode");
-  world.SetDebugDrawMode(mode);
-
-  // update
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  DALI_TEST_CHECK( trace.FindMethod( "DynamicsWorld::SetDebugDrawMode" ) );
-
-  tet_infoline("UtcDaliDynamicsWorldDebugDrawMode - DynamicsWorld::GetDebugDrawMode");
-  DALI_TEST_CHECK(mode == world.GetDebugDrawMode());
-  END_TEST;
-}
-
-int UtcDaliDynamicsWorldRootActor(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  const Vector3 gravity(1.0f, 2.0f, 3.0f);
-  DynamicsWorldConfig worldConfig(DynamicsWorldConfig::New());
-  DynamicsWorld world( Stage::GetCurrent().InitializeDynamics(worldConfig) );
-
-  if( !world )
-  {
-    // cannot create dynamics world, log failure and exit
-    DALI_TEST_CHECK( false );
-    END_TEST;
-  }
-
-  Actor rootActor(Actor::New());
-
-  tet_infoline("UtcDaliDynamicsWorldDebugDrawMode - DynamicsWorld::GetRootActor");
-  Actor actor(world.GetRootActor());
-  DALI_TEST_CHECK( !actor );
-
-  tet_infoline("UtcDaliDynamicsWorldSetRootActor - DynamicsWorld::SetRootActor");
-  world.SetRootActor(rootActor);
-  DALI_TEST_CHECK(rootActor == world.GetRootActor());
-  END_TEST;
-}
diff --git a/automated-tests/src/dali/utc-Dali-DynamicsWorldConfig.cpp b/automated-tests/src/dali/utc-Dali-DynamicsWorldConfig.cpp
deleted file mode 100644 (file)
index 372ed66..0000000
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <iostream>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali-test-suite-utils.h>
-#include <dali/devel-api/dynamics/dynamics.h>
-
-using namespace Dali;
-
-
-int UtcDaliDynamicsWorldConfigConstructor(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsWorldConfigConstructor - DynamicsWorldConfig::DynamicsWorldConfig");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  // Default constructor - create an uninitialized handle
-  DynamicsWorldConfig worldConfig;
-  DALI_TEST_CHECK( !worldConfig );
-
-  // initialize handle
-  worldConfig = DynamicsWorldConfig::New();
-
-  DALI_TEST_CHECK( worldConfig );
-  END_TEST;
-}
-
-int UtcDaliDynamicsWorldConfigNew(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  tet_infoline("UtcDaliDynamicsWorldConfigNew - DynamicsWorldConfig::New");
-
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  // Default constructor - create an uninitialized handle
-  DynamicsWorldConfig worldConfig( DynamicsWorldConfig::New() );
-
-  DALI_TEST_CHECK( worldConfig );
-  END_TEST;
-}
-
-int UtcDaliDynamicsWorldConfigType(void)
-{
-#if !defined(DYNAMICS_SUPPORT)
-  tet_infoline("No dynamics support compiled\n");
-  return 0;
-#endif
-  TestApplication application;
-
-  // start up
-  application.SendNotification();
-  application.Render();
-  application.Render();
-
-  // Default constructor - create an uninitialized handle
-  DynamicsWorldConfig worldConfig( DynamicsWorldConfig::New() );
-
-  tet_infoline("UtcDaliDynamicsWorldConfigNew - DynamicsWorldConfig::GetType");
-  DALI_TEST_CHECK(DynamicsWorldConfig::RIGID == worldConfig.GetType());
-
-  tet_infoline("UtcDaliDynamicsWorldConfigNew - DynamicsWorldConfig::SetType");
-  worldConfig.SetType(DynamicsWorldConfig::SOFT);
-  DALI_TEST_CHECK(DynamicsWorldConfig::SOFT == worldConfig.GetType());
-  END_TEST;
-}
diff --git a/automated-tests/src/dali/utc-Dali-Hash.cpp b/automated-tests/src/dali/utc-Dali-Hash.cpp
deleted file mode 100644 (file)
index 79c3881..0000000
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * Copyright (c) 2015 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <string>
-#include <stdlib.h>
-#include <dali/devel-api/common/hash.h>
-#include <dali-test-suite-utils.h>
-
-void utc_dali_hash_startup(void)
-{
-  test_return_value = TET_UNDEF;
-}
-
-void utc_dali_hash_cleanup(void)
-{
-  test_return_value = TET_PASS;
-}
-
-
-int UtcDaliHash(void)
-{
-  // To fully test the Hash distribution we need to use a tool like http://code.google.com/p/smhasher/
-  // DALi currently uses the hash for variable length strings which come from:
-  // shader vert+frag source, font family + style, image filename.
-  TestApplication application;
-
-  tet_infoline("UtcDaliHash");
-
-  const std::string testString1( "highp vec4 glowColor = vec4( uGlowColor.rgb, uGlowColor.a * clampedColor.a );");
-  const std::string testString2( "lowp vec4 glowColor = vec4( uGlowColor.rgb, uGlowColor.a * clampedColor.a );");
-
-  DALI_TEST_CHECK( Dali::CalculateHash( testString1 ) != Dali::CalculateHash( testString2 ) );
-  DALI_TEST_CHECK( Dali::CalculateHash( testString1, testString2 ) != Dali::CalculateHash( testString2, testString1 ) );
-
-  END_TEST;
-}
-
-int UtcDaliHashNegative(void)
-{
-  // negative test, check hash value == initial value
-  const std::string emptyString;
-
-  DALI_TEST_CHECK( Dali::CalculateHash( emptyString ) != 0 );
-  DALI_TEST_CHECK( Dali::CalculateHash( emptyString, emptyString ) != 0 );
-
-  END_TEST;
-}
diff --git a/automated-tests/src/dali/utc-Dali-HitTestAlgorithm.cpp b/automated-tests/src/dali/utc-Dali-HitTestAlgorithm.cpp
deleted file mode 100644 (file)
index 891d6c7..0000000
+++ /dev/null
@@ -1,418 +0,0 @@
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/events/hit-test-algorithm.h>
-#include <dali/integration-api/events/touch-event-integ.h>
-#include <dali-test-suite-utils.h>
-
-using namespace Dali;
-
-namespace
-{
-
-/**
- * The functor to be used in the hit-test algorithm to check whether the actor is hittable.
- */
-bool IsActorHittableFunction(Actor actor, Dali::HitTestAlgorithm::TraverseType type)
-{
-  bool hittable = false;
-
-  switch (type)
-  {
-    case Dali::HitTestAlgorithm::CHECK_ACTOR:
-    {
-      // Check whether the actor is visible and not fully transparent.
-      if( actor.IsVisible()
-       && actor.GetCurrentWorldColor().a > 0.01f) // not FULLY_TRANSPARENT
-      {
-        // Check whether the actor has the specific name "HittableActor"
-        if(actor.GetName() == "HittableActor")
-        {
-          hittable = true;
-        }
-      }
-      break;
-    }
-    case Dali::HitTestAlgorithm::DESCEND_ACTOR_TREE:
-    {
-      if( actor.IsVisible() ) // Actor is visible, if not visible then none of its children are visible.
-      {
-        hittable = true;
-      }
-      break;
-    }
-    default:
-    {
-      break;
-    }
-  }
-
-  return hittable;
-};
-
-
-bool DefaultIsActorTouchableFunction(Dali::Actor actor, Dali::HitTestAlgorithm::TraverseType type)
-{
-  bool hittable = false;
-
-  switch (type)
-  {
-    case Dali::HitTestAlgorithm::CHECK_ACTOR:
-    {
-      if( actor.IsVisible() &&
-          actor.IsSensitive() &&
-          actor.GetCurrentWorldColor().a > 0.01f)
-      {
-        hittable = true;
-      }
-      break;
-    }
-    case Dali::HitTestAlgorithm::DESCEND_ACTOR_TREE:
-    {
-      if( actor.IsVisible() && // Actor is visible, if not visible then none of its children are visible.
-          actor.IsSensitive()) // Actor is sensitive, if insensitive none of its children should be hittable either.
-      {
-        hittable = true;
-      }
-      break;
-    }
-    default:
-    {
-      break;
-    }
-  }
-
-  return hittable;
-};
-
-} // anonymous namespace
-
-
-// Positive test case for a method
-int UtcDaliHitTestAlgorithmWithFunctor(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::HitTestAlgorithm functor");
-
-  Stage stage = Stage::GetCurrent();
-
-  Actor actor = Actor::New();
-  actor.SetSize(100.0f, 100.0f);
-  actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
-  actor.SetName("NonHittableActor");
-  stage.Add(actor);
-
-  // Render and notify
-  application.SendNotification();
-  application.Render();
-
-  Vector2 screenCoordinates( 10.0f, 10.0f );
-  Vector2 localCoordinates;
-  actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
-
-  // Perform a hit-test at the given screen coordinates
-  Dali::HitTestAlgorithm::Results results;
-  Dali::HitTestAlgorithm::HitTest( stage, screenCoordinates, results, IsActorHittableFunction );
-  DALI_TEST_CHECK( results.actor != actor );
-
-  actor.SetName("HittableActor");
-
-  results.actor = Actor();
-  results.actorCoordinates = Vector2::ZERO;
-
-  // Perform a hit-test at the given screen coordinates
-  Dali::HitTestAlgorithm::HitTest( stage, screenCoordinates, results, IsActorHittableFunction );
-  DALI_TEST_CHECK( results.actor == actor );
-  DALI_TEST_EQUALS( localCoordinates, results.actorCoordinates, 0.1f, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliHitTestAlgorithmWithFunctorOnRenderTask(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::HitTestAlgorithm functor, specific to a given render task");
-
-  Stage stage = Stage::GetCurrent();
-  Size stageSize = stage.GetSize();
-  RenderTaskList taskList = stage.GetRenderTaskList();
-
-  Actor actor[2];
-
-  for( int i=0; i<2; i++ )
-  {
-    actor[i] = Actor::New();
-    actor[i].SetSize(100.f, 100.f);
-    actor[i].SetParentOrigin(ParentOrigin::TOP_LEFT);
-    actor[i].SetAnchorPoint(AnchorPoint::TOP_LEFT);
-    actor[i].SetName("HittableActor");
-    stage.Add(actor[i]);
-  }
-  Vector2 position( 50.f, 40.f );
-  actor[1].SetPosition( position.x, position.y );
-
-  RenderTask renderTask[2];
-  renderTask[0] = taskList.GetTask( 0u );
-
-  FrameBufferImage frameBufferImage =  FrameBufferImage::New(stageSize.width, stageSize.height, Pixel::A8, Image::NEVER);
-  renderTask[1] = taskList.CreateTask();
-  renderTask[1].SetSourceActor( actor[1] );
-  renderTask[1].SetExclusive( true );
-  renderTask[1].SetInputEnabled( true );
-  renderTask[1].SetTargetFrameBuffer( frameBufferImage );
-  renderTask[1].SetRefreshRate( RenderTask::REFRESH_ONCE );
-  renderTask[1].SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
-  application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
-
-  // Render and notify
-  application.SendNotification();
-  application.Render();
-  application.Render();
-  application.SendNotification();
-
-  // Perform a hit-test at the given screen coordinates with different render tasks
-
-  Dali::HitTestAlgorithm::Results results;
-  Vector2 screenCoordinates( 25.f, 25.f );
-
-  Dali::HitTestAlgorithm::HitTest( renderTask[0], screenCoordinates, results, IsActorHittableFunction );
-  DALI_TEST_CHECK( results.actor == actor[0] );
-  DALI_TEST_EQUALS( screenCoordinates, results.actorCoordinates, 0.1f, TEST_LOCATION );
-
-  results.actor = Actor();
-  results.actorCoordinates = Vector2::ZERO;
-  Dali::HitTestAlgorithm::HitTest( renderTask[1], screenCoordinates, results, IsActorHittableFunction );
-  DALI_TEST_CHECK( !results.actor );
-  DALI_TEST_EQUALS( Vector2::ZERO, results.actorCoordinates, 0.1f, TEST_LOCATION );
-
-  screenCoordinates.x = 80.f;
-  screenCoordinates.y = 70.f;
-
-  results.actor = Actor();
-  results.actorCoordinates = Vector2::ZERO;
-  Dali::HitTestAlgorithm::HitTest( renderTask[0], screenCoordinates, results, IsActorHittableFunction );
-  DALI_TEST_CHECK( results.actor == actor[0] );
-  DALI_TEST_EQUALS( screenCoordinates, results.actorCoordinates, 0.1f, TEST_LOCATION );
-
-  results.actor = Actor();
-  results.actorCoordinates = Vector2::ZERO;
-  Dali::HitTestAlgorithm::HitTest( renderTask[1], screenCoordinates, results, IsActorHittableFunction );
-  DALI_TEST_CHECK( results.actor == actor[1]);
-  DALI_TEST_EQUALS( screenCoordinates - position, results.actorCoordinates, 0.1f, TEST_LOCATION );
-
-
-  screenCoordinates.x = 120.f;
-  screenCoordinates.y = 130.f;
-
-  results.actor = Actor();
-  results.actorCoordinates = Vector2::ZERO;
-  Dali::HitTestAlgorithm::HitTest( renderTask[0], screenCoordinates, results, IsActorHittableFunction );
-  DALI_TEST_CHECK( results.actor == actor[1] );
-  DALI_TEST_EQUALS( screenCoordinates - position, results.actorCoordinates, 0.1f, TEST_LOCATION );
-
-  results.actor = Actor();
-  results.actorCoordinates = Vector2::ZERO;
-  Dali::HitTestAlgorithm::HitTest( renderTask[1], screenCoordinates, results, IsActorHittableFunction );
-  DALI_TEST_CHECK( results.actor == actor[1]);
-  DALI_TEST_EQUALS( screenCoordinates - position, results.actorCoordinates, 0.1f, TEST_LOCATION );
-  END_TEST;
-}
-
-
-int UtcDaliHitTestAlgorithmOrtho01(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::HitTestAlgorithm with parallel Ortho camera()");
-
-  Stage stage = Stage::GetCurrent();
-  RenderTaskList renderTaskList = stage.GetRenderTaskList();
-  RenderTask defaultRenderTask = renderTaskList.GetTask(0u);
-  Dali::CameraActor cameraActor = defaultRenderTask.GetCameraActor();
-
-  Vector2 stageSize ( stage.GetSize() );
-  cameraActor.SetOrthographicProjection( stageSize );
-  cameraActor.SetPosition(0.0f, 0.0f, 1600.0f);
-
-  Vector2 actorSize( stageSize * 0.5f );
-  // Create two actors with half the size of the stage and set them to be partially overlapping
-  Actor blue = Actor::New();
-  blue.SetName( "Blue" );
-  blue.SetAnchorPoint( AnchorPoint::CENTER );
-  blue.SetParentOrigin( Vector3(1.0f/3.0f, 1.0f/3.0f, 0.5f) );
-  blue.SetSize( actorSize );
-  blue.SetZ(30.0f);
-
-  Actor green = Actor::New( );
-  green.SetName( "Green" );
-  green.SetAnchorPoint( AnchorPoint::CENTER );
-  green.SetParentOrigin( Vector3(2.0f/3.0f, 2.0f/3.0f, 0.5f) );
-  green.SetSize( actorSize );
-
-  // Add the actors to the view
-  stage.Add( blue );
-  stage.Add( green );
-
-  // Render and notify
-  application.SendNotification();
-  application.Render(0);
-  application.Render(10);
-
-  HitTestAlgorithm::Results results;
-  HitTest(stage, Vector2( 240.0f, 400.0f ), results, &DefaultIsActorTouchableFunction);
-  DALI_TEST_CHECK( results.actor == blue );
-  DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 5.0f/6.0f, TEST_LOCATION );
-
-  HitTest(stage, stageSize / 3.0f, results, &DefaultIsActorTouchableFunction);
-  DALI_TEST_CHECK( results.actor == blue );
-  DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 0.5f, TEST_LOCATION );
-
-  HitTest(stage, stageSize * 2.0f / 3.0f, results, &DefaultIsActorTouchableFunction);
-  DALI_TEST_CHECK( results.actor == green );
-  DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 0.5f, TEST_LOCATION );
-  END_TEST;
-}
-
-
-int UtcDaliHitTestAlgorithmOrtho02(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::HitTestAlgorithm with offset Ortho camera()");
-
-  Stage stage = Stage::GetCurrent();
-  RenderTaskList renderTaskList = stage.GetRenderTaskList();
-  RenderTask defaultRenderTask = renderTaskList.GetTask(0u);
-  Dali::CameraActor cameraActor = defaultRenderTask.GetCameraActor();
-
-  Vector2 stageSize ( stage.GetSize() );
-  cameraActor.SetOrthographicProjection(-stageSize.x * 0.3f,  stageSize.x * 0.7f,
-                                         stageSize.y * 0.3f, -stageSize.y * 0.7f,
-                                         800.0f, 4895.0f);
-  cameraActor.SetPosition(0.0f, 0.0f, 1600.0f);
-
-  Vector2 actorSize( stageSize * 0.5f );
-  // Create two actors with half the size of the stage and set them to be partially overlapping
-  Actor blue = Actor::New();
-  blue.SetName( "Blue" );
-  blue.SetAnchorPoint( AnchorPoint::TOP_LEFT );
-  blue.SetParentOrigin( Vector3(0.2f, 0.2f, 0.5f) );
-  blue.SetSize( actorSize );
-  blue.SetZ(30.0f);
-
-  Actor green = Actor::New( );
-  green.SetName( "Green" );
-  green.SetAnchorPoint( AnchorPoint::TOP_LEFT );
-  green.SetParentOrigin( Vector3(0.4f, 0.4f, 0.5f) );
-  green.SetSize( actorSize );
-
-  // Add the actors to the view
-  stage.Add( blue );
-  stage.Add( green );
-
-  // Render and notify
-  application.SendNotification();
-  application.Render(0);
-  application.Render(10);
-
-  {
-    HitTestAlgorithm::Results results;
-    HitTest(stage, Vector2( 240.0f, 400.0f ), results, &DefaultIsActorTouchableFunction);
-    DALI_TEST_CHECK( results.actor == green );
-    DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 0.6f, 0.01f, TEST_LOCATION );
-  }
-
-  {
-    HitTestAlgorithm::Results results;
-    HitTest(stage, Vector2( 0.001f, 0.001f ), results, &DefaultIsActorTouchableFunction);
-    DALI_TEST_CHECK( results.actor == blue );
-    DALI_TEST_EQUALS( results.actorCoordinates, Vector2( 0.001f, 0.001f ), 0.001f, TEST_LOCATION );
-  }
-
-  {
-    HitTestAlgorithm::Results results;
-    HitTest(stage, stageSize, results, &DefaultIsActorTouchableFunction);
-    DALI_TEST_CHECK( ! results.actor );
-    DALI_TEST_EQUALS( results.actorCoordinates, Vector2::ZERO, TEST_LOCATION );
-  }
-
-  // Just inside green
-  {
-    HitTestAlgorithm::Results results;
-    HitTest(stage, stageSize*0.69f, results, &DefaultIsActorTouchableFunction);
-    DALI_TEST_CHECK( results.actor == green );
-    DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 0.98f, 0.01f, TEST_LOCATION );
-  }
-
-  END_TEST;
-}
-
-int UtcDaliHitTestAlgorithmStencil(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::HitTestAlgorithm with a stencil");
-
-  Stage stage = Stage::GetCurrent();
-  Actor rootLayer = stage.GetRootLayer();
-  rootLayer.SetName( "RootLayer" );
-
-  // Create a layer
-  Layer layer = Layer::New();
-  layer.SetAnchorPoint( AnchorPoint::TOP_LEFT );
-  layer.SetParentOrigin( ParentOrigin::TOP_LEFT );
-  layer.SetName( "layer" );
-  stage.Add( layer );
-
-  // Create a stencil and add that to the layer
-  Actor stencil = ImageActor::New(Dali::BufferImage::WHITE() );
-  stencil.SetAnchorPoint( AnchorPoint::TOP_LEFT );
-  stencil.SetParentOrigin( ParentOrigin::TOP_LEFT );
-  stencil.SetSize( 50.0f, 50.0f );
-  stencil.SetDrawMode( DrawMode::STENCIL );
-  stencil.SetName( "stencil" );
-  layer.Add( stencil );
-
-  // Create a renderable actor and add that to the layer
-  Actor layerHitActor = ImageActor::New();
-  layerHitActor.SetSize( 100.0f, 100.0f );
-  layerHitActor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
-  layerHitActor.SetParentOrigin( ParentOrigin::TOP_LEFT );
-  layerHitActor.SetName( "layerHitActor" );
-  layer.Add( layerHitActor );
-
-  // Render and notify
-  application.SendNotification();
-  application.Render();
-
-  // Hit within stencil and actor
-  {
-    HitTestAlgorithm::Results results;
-    HitTest(stage, Vector2( 10.0f, 10.0f ), results, &DefaultIsActorTouchableFunction);
-    DALI_TEST_CHECK( results.actor == layerHitActor );
-    tet_printf( "Hit: %s\n", ( results.actor ? results.actor.GetName().c_str() : "NULL" ) );
-  }
-
-  // Hit within actor but outside of stencil, should hit the root-layer
-  {
-    HitTestAlgorithm::Results results;
-    HitTest(stage, Vector2( 60.0f, 60.0f ), results, &DefaultIsActorTouchableFunction);
-    DALI_TEST_CHECK( results.actor == rootLayer );
-    tet_printf( "Hit: %s\n", ( results.actor ? results.actor.GetName().c_str() : "NULL" ) );
-  }
-  END_TEST;
-}
index ccc633692a52706cabcfa1a4b9815e96a811b4d3..23c7880d2c2b03c53724e94db42486b21ce77f15 100644 (file)
@@ -20,7 +20,6 @@
 #include <stdlib.h>
 #include <dali/public-api/dali-core.h>
 #include <dali-test-suite-utils.h>
-#include <test-native-image.h>
 
 using namespace Dali;
 
diff --git a/automated-tests/src/dali/utc-Dali-Material.cpp b/automated-tests/src/dali/utc-Dali-Material.cpp
deleted file mode 100644 (file)
index 848d0f3..0000000
+++ /dev/null
@@ -1,333 +0,0 @@
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/actors/mesh-actor.h>
-#include <dali/devel-api/geometry/mesh.h>
-#include <dali/devel-api/geometry/animatable-mesh.h>
-#include <dali-test-suite-utils.h>
-
-using namespace Dali;
-
-
-void utc_dali_material_startup(void)
-{
-  test_return_value = TET_UNDEF;
-}
-
-void utc_dali_material_cleanup(void)
-{
-  test_return_value = TET_PASS;
-}
-
-namespace
-{
-
-static AnimatableMesh CreateMeshData(Material material)
-{
-  AnimatableMesh::Faces faces;
-  for(int i=0; i<10-3; i++)
-  {
-    faces.push_back(i);
-    faces.push_back(i+1);
-    faces.push_back(i+2);
-  }
-  return AnimatableMesh::New(10, faces, material);
-}
-
-}// anonymous namespace
-
-
-// Positive test case for a method
-int UtcDaliMaterialNew01(void)
-{
-  TestApplication application;
-  tet_infoline("Testing constructors, New and destructors");
-
-  Material material;
-  DALI_TEST_CHECK( ! material );
-
-  material = Material::New("material");
-  DALI_TEST_CHECK( material );
-
-  Material* material2 = new Material();
-  DALI_TEST_CHECK( ! *material2 );
-  delete material2;
-
-  Material material3 = material;
-  Material material4;
-  material4 = material;
-  Material material5 = material;
-  END_TEST;
-}
-
-
-int UtcDaliMaterialDownCast(void)
-{
-  TestApplication application;
-
-  Material material = Material::New("material");
-  BaseHandle handle(material);
-
-  Material mat2 = Material::DownCast( handle );
-  DALI_TEST_CHECK( mat2 );
-  END_TEST;
-}
-
-int UtcDaliMaterialSettersAndGetters(void)
-{
-  TestApplication application;
-  Material material = Material::New("material");
-  DALI_TEST_EQUALS( material.GetName(), "material", TEST_LOCATION );
-  material.SetName( "AnotherMaterial" );
-  DALI_TEST_EQUALS( material.GetName(), "AnotherMaterial", TEST_LOCATION );
-
-  DALI_TEST_EQUALS( material.GetOpacity(), Material::DEFAULT_OPACITY, 0.001, TEST_LOCATION);
-  material.SetOpacity(0.38f);
-  DALI_TEST_EQUALS( material.GetOpacity(), 0.38f, 0.001, TEST_LOCATION);
-
-  DALI_TEST_EQUALS( material.GetShininess(), Material::DEFAULT_SHININESS, 0.001, TEST_LOCATION);
-  material.SetShininess(0.47f);
-  DALI_TEST_EQUALS( material.GetShininess(), 0.47f, 0.001, TEST_LOCATION);
-
-  DALI_TEST_EQUALS( material.GetAmbientColor(), Material::DEFAULT_AMBIENT_COLOR, 0.001, TEST_LOCATION);
-  material.SetAmbientColor(Color::BLACK);
-  DALI_TEST_EQUALS( material.GetAmbientColor(), Color::BLACK, 0.001, TEST_LOCATION);
-
-  DALI_TEST_EQUALS( material.GetDiffuseColor(), Material::DEFAULT_DIFFUSE_COLOR, 0.001, TEST_LOCATION);
-  material.SetDiffuseColor(Color::BLUE);
-  DALI_TEST_EQUALS( material.GetDiffuseColor(), Color::BLUE, 0.001, TEST_LOCATION);
-
-  DALI_TEST_EQUALS( material.GetSpecularColor(), Material::DEFAULT_SPECULAR_COLOR, 0.001, TEST_LOCATION);
-  material.SetSpecularColor(Color::GREEN);
-  DALI_TEST_EQUALS( material.GetSpecularColor(), Color::GREEN, 0.001, TEST_LOCATION);
-
-  DALI_TEST_EQUALS( material.GetEmissiveColor(), Material::DEFAULT_EMISSIVE_COLOR, 0.001, TEST_LOCATION);
-  material.SetEmissiveColor(Color::MAGENTA);
-  DALI_TEST_EQUALS( material.GetEmissiveColor(), Color::MAGENTA, 0.001, TEST_LOCATION);
-
-  material.SetDiffuseTextureFileName("diffuse-texture.png");
-  DALI_TEST_EQUALS( material.GetDiffuseFileName(), "diffuse-texture.png", TEST_LOCATION);
-
-  material.SetOpacityTextureFileName("opacity-texture.png");
-  DALI_TEST_EQUALS( material.GetOpacityTextureFileName(), "opacity-texture.png", TEST_LOCATION);
-
-  material.SetNormalMapFileName("normal-map.png");
-  DALI_TEST_EQUALS( material.GetNormalMapFileName(), "normal-map.png", TEST_LOCATION);
-
-  Image diffuseTexture = ResourceImage::New("diffuse-texture.png");
-  material.SetDiffuseTexture(diffuseTexture);
-  DALI_TEST_EQUALS( material.GetDiffuseTexture(), diffuseTexture, TEST_LOCATION );
-
-  Image opacityTexture = ResourceImage::New("opacity-texture.png");
-  material.SetOpacityTexture(opacityTexture);
-  DALI_TEST_EQUALS( material.GetOpacityTexture(), opacityTexture, TEST_LOCATION);
-
-  Image normalMap = ResourceImage::New("normal-map.png");
-  material.SetNormalMap(normalMap);
-  DALI_TEST_EQUALS( material.GetNormalMap(), normalMap, TEST_LOCATION);
-
-  DALI_TEST_EQUALS( material.GetMapU(), (unsigned int)Material::DEFAULT_MAPPING_MODE, TEST_LOCATION );
-  DALI_TEST_EQUALS( material.GetMapV(), (unsigned int)Material::DEFAULT_MAPPING_MODE, TEST_LOCATION );
-  material.SetMapU( Material::MAPPING_MODE_WRAP );
-  material.SetMapV( Material::MAPPING_MODE_MIRROR );
-  DALI_TEST_EQUALS( material.GetMapU(), (unsigned int)Material::MAPPING_MODE_WRAP, TEST_LOCATION );
-  DALI_TEST_EQUALS( material.GetMapV(), (unsigned int)Material::MAPPING_MODE_MIRROR, TEST_LOCATION );
-
-  DALI_TEST_EQUALS( material.GetDiffuseUVIndex(), Material::DEFAULT_DIFFUSE_UV_INDEX, TEST_LOCATION );
-  material.SetDiffuseUVIndex( 1u );
-  DALI_TEST_EQUALS( material.GetDiffuseUVIndex(), 1u, TEST_LOCATION );
-
-  DALI_TEST_EQUALS( material.GetOpacityUVIndex(), Material::DEFAULT_OPACITY_UV_INDEX, TEST_LOCATION );
-  material.SetOpacityUVIndex( 1u );
-  DALI_TEST_EQUALS( material.GetOpacityUVIndex(), 1u, TEST_LOCATION );
-
-  DALI_TEST_EQUALS( material.GetNormalUVIndex(), Material::DEFAULT_NORMAL_UV_INDEX, TEST_LOCATION );
-  material.SetNormalUVIndex( 1u );
-  DALI_TEST_EQUALS( material.GetNormalUVIndex(), 1u, TEST_LOCATION );
-
-  DALI_TEST_EQUALS( material.GetHasHeightMap(), Material::DEFAULT_HAS_HEIGHT_MAP, TEST_LOCATION );
-  material.SetHasHeightMap(true);
-  DALI_TEST_EQUALS( material.GetHasHeightMap(), true, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliMaterialStage01(void)
-{
-  TestApplication application;
-  TraceCallStack& textureTrace = application.GetGlAbstraction().GetTextureTrace();
-  textureTrace.Enable(true);
-  TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
-
-  {
-    Material material = Material::New("material");
-    Image image = ResourceImage::New( "image.png", ResourceImage::IMMEDIATE, Image::NEVER );
-    DALI_TEST_CHECK(image);
-    application.SendNotification();
-    application.Render(16);
-
-    std::vector<GLuint> ids;
-    ids.push_back( 23 );
-    application.GetGlAbstraction().SetNextTextureIds( ids );
-    Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::DISCARD );
-    Integration::ResourcePointer resource(bitmap);
-    bitmap->GetPackedPixelsProfile()->ReserveBuffer(Pixel::RGBA8888, 80, 80, 80, 80);
-    DALI_TEST_CHECK( application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) );
-    Integration::ResourceRequest* request = application.GetPlatform().GetRequest();
-    DALI_TEST_CHECK( request != NULL );
-    if(request)
-    {
-      application.GetPlatform().SetResourceLoaded(request->GetId(), request->GetType()->id, resource);
-    }
-
-    material.SetDiffuseTexture(image);
-    application.SendNotification();
-    application.Render();
-
-    AnimatableMesh mesh = CreateMeshData(material);
-
-    application.SendNotification();
-    application.Render();
-    {
-      MeshActor meshActor = MeshActor::New(mesh);
-      meshActor.SetSize(100, 100);
-      Stage::GetCurrent().Add(meshActor);
-      application.SendNotification();
-      application.Render();
-
-      material.SetOpacity(0.5f);
-      application.SendNotification();
-      application.Render();
-      DALI_TEST_EQUALS( material.GetOpacity(), 0.5f, 0.001f, TEST_LOCATION );
-
-      Stage::GetCurrent().Remove(meshActor);
-      application.SendNotification();
-      application.Render();
-
-      DALI_TEST_CHECK( glAbstraction.CheckNoTexturesDeleted() );
-      DALI_TEST_CHECK( ! textureTrace.FindMethod( "DeleteTextures" ) );
-    }
-    application.SendNotification();
-    application.Render();
-
-    // Mesh should be destroyed, reducing connection count on material to zero.
-    // This should also reduce connection count on image to zero
-    DALI_TEST_EQUALS( material.GetOpacity(), 0.5f, 0.001f, TEST_LOCATION );
-  }
-  // SceneGraph::Material & SceneGraph::RenderMaterial should be destroyed
-  // Image should be destroyed
-  application.SendNotification();
-  application.Render();
-
-  application.Render();
-  DALI_TEST_CHECK( textureTrace.FindMethod( "DeleteTextures" ) );
-  DALI_TEST_CHECK( glAbstraction.CheckTextureDeleted( 23 ) );
-  END_TEST;
-}
-
-
-int UtcDaliMaterialStage01MemCheck(void)
-{
-  TestApplication application;
-  tet_result(TET_PASS);
-  END_TEST;
-}
-
-int UtcDaliMaterialStage02(void)
-{
-  TestApplication application;
-  TraceCallStack& textureTrace = application.GetGlAbstraction().GetTextureTrace();
-  textureTrace.Enable(true);
-  TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
-
-  {
-    Material material = Material::New("material");
-
-    Image image = ResourceImage::New( "image.png", ResourceImage::ON_DEMAND, Image::UNUSED );
-    DALI_TEST_CHECK(image);
-    application.SendNotification();
-    application.Render(16);
-    DALI_TEST_CHECK( !application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) );
-    DALI_TEST_CHECK( application.GetPlatform().GetRequest() == NULL );
-
-    std::vector<GLuint> ids;
-    ids.push_back( 23 );
-    application.GetGlAbstraction().SetNextTextureIds( ids );
-
-    material.SetDiffuseTexture(image);
-    application.SendNotification();
-    application.Render();
-    DALI_TEST_CHECK( !application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) );
-    DALI_TEST_CHECK( application.GetPlatform().GetRequest() == NULL );
-
-    AnimatableMesh mesh = CreateMeshData(material);
-
-    application.SendNotification();
-    application.Render();
-    DALI_TEST_CHECK( !application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) );
-    DALI_TEST_CHECK( application.GetPlatform().GetRequest() == NULL );
-
-    {
-      MeshActor meshActor = MeshActor::New(mesh);
-      meshActor.SetSize(100, 100);
-      Stage::GetCurrent().Add(meshActor);
-      application.SendNotification();
-      application.Render();
-
-      // Image connection count should go to one - image should get loaded
-      DALI_TEST_CHECK( application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) );
-      Integration::ResourceRequest* request = application.GetPlatform().GetRequest();
-      DALI_TEST_CHECK( request != NULL );
-
-      Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::DISCARD );
-      Integration::ResourcePointer resource(bitmap);
-      bitmap->GetPackedPixelsProfile()->ReserveBuffer(Pixel::RGBA8888, 80, 80, 80, 80);
-      if(request)
-      {
-        application.GetPlatform().SetResourceLoaded(request->GetId(), request->GetType()->id, resource);
-      }
-      application.Render();
-
-      material.SetOpacity(0.5f);
-      application.SendNotification();
-      application.Render();
-      DALI_TEST_EQUALS( material.GetOpacity(), 0.5f, 0.001f, TEST_LOCATION );
-
-      Stage::GetCurrent().Remove(meshActor);
-      application.SendNotification();
-      application.Render();
-
-      // This should reduce connection count on material to zero, freeing the texture:
-      DALI_TEST_CHECK( textureTrace.FindMethod( "DeleteTextures" ) );
-      DALI_TEST_CHECK( glAbstraction.CheckTextureDeleted( 23 ) );
-    }
-    application.SendNotification();
-    application.Render();
-
-    // Mesh should be destroyed, reducing connection count on material to zero.
-    // This should also reduce connection count on image to zero, freeing it
-    DALI_TEST_EQUALS( material.GetOpacity(), 0.5f, 0.001f, TEST_LOCATION );
-  }
-  application.SendNotification();
-  application.Render();
-
-  // SceneGraph::Material & SceneGraph::RenderMaterial should be destroyed
-  END_TEST;
-}
diff --git a/automated-tests/src/dali/utc-Dali-MeshActor.cpp b/automated-tests/src/dali/utc-Dali-MeshActor.cpp
deleted file mode 100644 (file)
index 3a36f3d..0000000
+++ /dev/null
@@ -1,748 +0,0 @@
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/actors/mesh-actor.h>
-#include <dali/devel-api/geometry/mesh.h>
-#include <dali/devel-api/geometry/animatable-mesh.h>
-#include <dali-test-suite-utils.h>
-
-using namespace Dali;
-
-#include <mesh-builder.h>
-
-void mesh_actor_test_startup(void)
-{
-  test_return_value = TET_UNDEF;
-}
-
-void mesh_actor_test_cleanup(void)
-{
-  test_return_value = TET_PASS;
-}
-
-namespace
-{
-
-static Mesh NewMesh()
-{
-  MeshData meshData;
-  MeshData::VertexContainer    vertices;
-  MeshData::FaceIndices        faces;
-  BoneContainer                bones;
-  ConstructVertices(vertices, 60);
-  ConstructFaces(vertices, faces);
-  Material customMaterial = ConstructMaterial();
-  meshData.SetData(vertices, faces, bones, customMaterial);
-  Mesh mesh = Mesh::New(meshData);
-  return mesh;
-}
-
-static AnimatableMesh NewAnimatableMesh()
-{
-  AnimatableMesh::Faces faces;
-  faces.push_back(0);
-  faces.push_back(1);
-  faces.push_back(2);
-
-  Material customMaterial = Material::New("CustomMaterial");
-  customMaterial.SetOpacity(.76f);
-  customMaterial.SetDiffuseColor(Vector4(0.8f, 0.0f, 0.4f, 1.0f));
-  customMaterial.SetAmbientColor(Vector4(0.2f, 1.0f, 0.6f, 1.0f));
-  customMaterial.SetSpecularColor(Vector4(0.5f, 0.6f, 0.7f, 1.0f));
-
-  AnimatableMesh mesh = AnimatableMesh::New( 10u, faces, customMaterial );
-  return mesh;
-}
-} // anonymous namespace
-
-int UtcDaliMeshActorConstructorVoid(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::MeshActor()");
-
-  MeshActor actor;
-  DALI_TEST_CHECK(!actor);
-  END_TEST;
-}
-
-int UtcDaliMeshActorNew01(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::New()");
-
-  AnimatableMesh mesh = NewAnimatableMesh();
-  MeshActor actor = MeshActor::New(mesh);
-  application.SendNotification();
-  application.Render();
-  application.Render();
-  application.SendNotification();
-
-  DALI_TEST_CHECK(actor);
-  END_TEST;
-}
-
-
-int UtcDaliMeshActorNew03(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::Mesh::New() - Create with no mesh");
-
-  try
-  {
-    MeshActor actor = MeshActor::New(); // Shouldn't assert
-    tet_result(TET_PASS);
-  }
-  catch (Dali::DaliException& e)
-  {
-    tet_result(TET_FAIL);
-  }
-
-  END_TEST;
-}
-
-int UtcDaliMeshActorCreateNoMeshData(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::Mesh::New() - Create with no mesh data");
-
-  try
-  {
-    MeshData meshData;
-    Mesh mesh = Mesh::New(meshData);
-    MeshActor actor1 = MeshActor::New(mesh);
-  }
-  catch(Dali::DaliException& e)
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT(e, "object", TEST_LOCATION);
-  }
-  END_TEST;
-}
-
-
-int UtcDaliMeshActorCreateSetData01(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshData::SetData() - Create with no verts");
-  try
-  {
-    MeshData meshData;
-    MeshData::VertexContainer vertices;
-    MeshData::FaceIndices     faces;
-    BoneContainer             bones;
-    Material                  customMaterial;
-    meshData.SetData(vertices, faces, bones, customMaterial);
-    Mesh mesh = Mesh::New(meshData);
-    MeshActor actor1 = MeshActor::New(mesh);
-  }
-  catch(Dali::DaliException& e)
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT(e, "!vertices.empty()", TEST_LOCATION );
-  }
-  END_TEST;
-}
-
-int UtcDaliMeshActorCreateSetData02(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshData::SetData - Create with no faces");
-  try
-  {
-    MeshData meshData;
-    MeshData::VertexContainer    vertices;
-    MeshData::FaceIndices        faces;
-    BoneContainer                bones;
-    Material                     customMaterial;
-    ConstructVertices(vertices, 60);
-    meshData.SetData(vertices, faces, bones, customMaterial);
-    Mesh mesh = Mesh::New(meshData);
-    MeshActor actor1 = MeshActor::New(mesh);
-  }
-  catch(Dali::DaliException& e)
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT(e, "!faceIndices.empty", TEST_LOCATION );
-  }
-  END_TEST;
-}
-
-int UtcDaliMeshActorCreateSetData03(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshData::SetData - Create with no mats");
-  try
-  {
-    MeshData meshData;
-    MeshData::VertexContainer    vertices;
-    MeshData::FaceIndices        faces;
-    BoneContainer                bones;
-    Material                     customMaterial;
-    ConstructVertices(vertices, 60);
-    ConstructFaces(vertices, faces);
-    meshData.SetData(vertices, faces, bones, customMaterial);
-    Mesh mesh = Mesh::New(meshData);
-    MeshActor actor1 = MeshActor::New(mesh);
-  }
-  catch(Dali::DaliException& e)
-  {
-    DALI_TEST_PRINT_ASSERT( e );
-    DALI_TEST_ASSERT(e, "material", TEST_LOCATION );
-  }
-  END_TEST;
-}
-
-int UtcDaliMeshActorCreateSetData04(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::SetData()");
-
-  MeshData meshData;
-  MeshData::VertexContainer    vertices;
-  MeshData::FaceIndices        faces;
-  BoneContainer                bones;
-  ConstructVertices(vertices, 60);
-  ConstructFaces(vertices, faces);
-  Material customMaterial = ConstructMaterial();
-  meshData.SetData(vertices, faces, bones, customMaterial);
-
-  Mesh mesh = Mesh::New(meshData);
-  MeshActor actor1 = MeshActor::New(mesh);
-  DALI_TEST_CHECK(actor1);
-  END_TEST;
-}
-
-
-int UtcDaliMeshActorDownCast(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::DownCast()");
-
-  MeshData meshData;
-  MeshData::VertexContainer    vertices;
-  MeshData::FaceIndices        faces;
-  BoneContainer                bones;
-  ConstructVertices(vertices, 60);
-  ConstructFaces(vertices, faces);
-  Material customMaterial = ConstructMaterial();
-  meshData.SetData(vertices, faces, bones, customMaterial);
-  Mesh mesh = Mesh::New(meshData);
-
-  MeshActor actor1 = MeshActor::New(mesh);
-  Actor anActor = Actor::New();
-  anActor.Add(actor1);
-
-  Actor child = anActor.GetChildAt(0);
-  MeshActor meshActor = MeshActor::DownCast(child);
-
-  DALI_TEST_CHECK(meshActor);
-  END_TEST;
-}
-
-int UtcDaliMeshActorDownCast2(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::DownCast()");
-
-  Actor actor1 = Actor::New();
-  Actor anActor = Actor::New();
-  anActor.Add(actor1);
-
-  Actor child = anActor.GetChildAt(0);
-  MeshActor meshActor = MeshActor::DownCast(child);
-  DALI_TEST_CHECK(!meshActor);
-
-  Actor unInitialzedActor;
-  meshActor = DownCast< MeshActor >( unInitialzedActor );
-  DALI_TEST_CHECK(!meshActor);
-  END_TEST;
-}
-
-int UtcDaliMeshActorSetMaterial01(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::SetMaterial()");
-
-  Mesh mesh = NewMesh();
-
-  MeshActor actor = MeshActor::New(mesh);
-  std::string name = "AMeshActor";
-  Stage::GetCurrent().Add(actor);
-  actor.SetName(name);
-  application.SendNotification();
-  application.Render();
-  application.Render();
-  application.SendNotification();
-
-  Material customMaterial = Material::New("CustomMaterial");
-  customMaterial.SetDiffuseColor(Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-
-  MeshActor::SetMaterial(actor, name, customMaterial);
-  application.SendNotification();
-  application.Render();
-  application.Render();
-  application.SendNotification();
-
-  DALI_TEST_CHECK( actor.GetMaterial() == customMaterial );
-  END_TEST;
-}
-
-int UtcDaliMeshActorSetMaterial01b(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::SetMaterial()");
-
-  Mesh mesh = NewMesh();
-
-  Actor rootActor = Actor::New();
-  MeshActor meshActor = MeshActor::New(mesh);
-  rootActor.Add(meshActor);
-
-  std::string name = "AMeshActor";
-  meshActor.SetName(name);
-
-  Stage::GetCurrent().Add(rootActor);
-  application.SendNotification();
-  application.Render();
-  application.Render();
-  application.SendNotification();
-
-  Material customMaterial = Material::New("CustomMaterial");
-  customMaterial.SetDiffuseColor(Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-
-  MeshActor::SetMaterial(rootActor, name, customMaterial);
-  application.SendNotification();
-  application.Render();
-  application.Render();
-  application.SendNotification();
-
-  DALI_TEST_CHECK(meshActor.GetMaterial() == customMaterial );
-  END_TEST;
-}
-
-
-int UtcDaliMeshActorSetMaterial02(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::SetMaterial()");
-
-  Mesh mesh = NewMesh();
-  MeshActor actor = MeshActor::New(mesh);
-
-  std::string name = "AMeshActor";
-  actor.SetName(name);
-  Stage::GetCurrent().Add(actor);
-  application.SendNotification();
-  application.Render();
-  application.Render();
-  application.SendNotification();
-
-  Material baseMat = actor.GetMaterial();
-  Material customMaterial = Material::New("CustomMaterial");
-  customMaterial.SetDiffuseColor(Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-
-  MeshActor::SetMaterial(actor, "NoName", customMaterial);
-  application.SendNotification();
-  application.Render();
-  application.Render();
-  application.SendNotification();
-
-  DALI_TEST_CHECK( actor.GetMaterial() == baseMat );
-  DALI_TEST_CHECK( actor.GetMaterial() != customMaterial );
-  END_TEST;
-}
-
-int UtcDaliMeshActorSetMaterial02b(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::SetMaterial()");
-
-  Mesh mesh = NewMesh();
-
-  MeshActor actor = MeshActor::New(mesh);
-  Stage::GetCurrent().Add(actor);
-
-  std::string name = "AMeshActor";
-  actor.SetName(name);
-  application.SendNotification();
-  application.Render();
-  application.Render();
-  application.SendNotification();
-
-  Material baseMat = actor.GetMaterial();
-  Material customMaterial = Material::New("CustomMaterial");
-  customMaterial.SetDiffuseColor(Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-
-  MeshActor::SetMaterial(actor, "NoName", customMaterial);
-  application.SendNotification();
-  application.Render();
-  application.Render();
-  application.SendNotification();
-
-  DALI_TEST_CHECK( actor.GetMaterial() == baseMat );
-  DALI_TEST_CHECK( actor.GetMaterial() != customMaterial );
-  END_TEST;
-}
-
-
-int UtcDaliMeshActorSetMaterial03(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::SetMaterial()");
-
-  Mesh mesh = NewMesh();
-
-  MeshActor actor = MeshActor::New(mesh);
-  std::string name = "AMeshActor";
-  actor.SetName(name);
-  Stage::GetCurrent().Add(actor);
-
-  Material customMaterial = Material::New("CustomMaterial");
-  customMaterial.SetDiffuseColor(Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-
-  actor.SetMaterial(customMaterial);
-  application.SendNotification();
-  application.Render(0);
-  application.Render(16);
-  application.SendNotification();
-
-  DALI_TEST_CHECK(actor.GetMaterial() == customMaterial );
-  END_TEST;
-}
-
-int UtcDaliMeshActorSetMaterial03b(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::SetMaterial()");
-
-  Mesh mesh = NewMesh();
-
-  MeshActor actor = MeshActor::New(mesh);
-  std::string name = "AMeshActor";
-  actor.SetName(name);
-  Stage::GetCurrent().Add(actor);
-
-  Material customMaterial = Material::New("CustomMaterial");
-  customMaterial.SetDiffuseColor(Vector4(1.0f, 0.0f, 0.0f, 1.0f));
-
-  actor.SetMaterial(customMaterial);
-  application.SendNotification();
-  application.Render(0);
-  application.Render(16);
-  application.SendNotification();
-  DALI_TEST_CHECK(actor.GetMaterial() == customMaterial );
-  END_TEST;
-}
-
-
-
-int UtcDaliMeshActorGetMaterial01(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::SetMaterial()");
-
-  MeshData meshData;
-  MeshData::VertexContainer vertices;
-  MeshData::FaceIndices faces;
-  BoneContainer bones;
-  ConstructVertices(vertices, 60);
-  ConstructFaces(vertices, faces);
-  Material material = ConstructMaterial();
-  meshData.SetData(vertices, faces, bones, material);
-  Mesh mesh = Mesh::New(meshData);
-
-  MeshActor actor = MeshActor::New(mesh);
-  std::string name = "AMeshActor";
-  actor.SetName(name);
-  application.SendNotification();
-  application.Render();
-  application.Render();
-  application.SendNotification();
-
-  Material gotMaterial = actor.GetMaterial();
-
-  DALI_TEST_EQUALS( material.GetOpacity(), gotMaterial.GetOpacity(), TEST_LOCATION );
-  DALI_TEST_EQUALS( material.GetAmbientColor(), gotMaterial.GetAmbientColor(), TEST_LOCATION );
-  DALI_TEST_EQUALS( material.GetDiffuseColor(), gotMaterial.GetDiffuseColor(), TEST_LOCATION );
-  DALI_TEST_EQUALS( material.GetSpecularColor(), gotMaterial.GetSpecularColor(), TEST_LOCATION );
-  END_TEST;
-}
-
-
-int UtcDaliMeshActorGetMaterial02(void)
-{
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::SetMaterial()");
-
-  MeshData meshData;
-  MeshData::VertexContainer vertices;
-  MeshData::FaceIndices faces;
-  BoneContainer bones;
-  ConstructVertices(vertices, 60);
-  ConstructFaces(vertices, faces);
-  Material material = ConstructMaterial();
-  meshData.SetData(vertices, faces, bones, material);
-  Mesh mesh = Mesh::New(meshData);
-
-  MeshActor actor = MeshActor::New(mesh);
-  std::string name = "AMeshActor";
-  actor.SetName(name);
-  application.SendNotification();
-  application.Render();
-  application.Render();
-  application.SendNotification();
-
-  Material gotMaterial = actor.GetMaterial();
-
-  DALI_TEST_EQUALS( material.GetOpacity(), gotMaterial.GetOpacity(), TEST_LOCATION );
-  DALI_TEST_EQUALS( material.GetAmbientColor(), gotMaterial.GetAmbientColor(), TEST_LOCATION );
-  DALI_TEST_EQUALS( material.GetDiffuseColor(), gotMaterial.GetDiffuseColor(), TEST_LOCATION );
-  DALI_TEST_EQUALS( material.GetSpecularColor(), gotMaterial.GetSpecularColor(), TEST_LOCATION );
-  END_TEST;
-}
-
-
-namespace
-{
-
-Material ConstructMaterial(float opacity, float diffuseOpacity)
-{
-  Material customMaterial = Material::New("CustomMaterial");
-  customMaterial.SetOpacity(opacity);
-  customMaterial.SetDiffuseColor(Vector4(0.8f, 0.0f, 0.4f, diffuseOpacity));
-  customMaterial.SetAmbientColor(Vector4(0.2f, 1.0f, 0.6f, 1.0f));
-  customMaterial.SetSpecularColor(Vector4(0.5f, 0.6f, 0.7f, 1.0f));
-  return customMaterial;
-}
-
-static void TestBlending( TestApplication& application, Material material, float actorOpacity, BlendingMode::Type blendingMode, bool expectedBlend )
-{
-  MeshData meshData;
-  MeshData::VertexContainer vertices;
-  MeshData::FaceIndices faces;
-  BoneContainer bones;
-  ConstructVertices(vertices, 60);
-  ConstructFaces(vertices, faces);
-  meshData.SetData(vertices, faces, bones, material);
-  Mesh mesh = Mesh::New(meshData);
-
-  application.SendNotification();
-  application.Render(0);
-  application.Render();
-  application.SendNotification();
-
-  MeshActor actor = MeshActor::New(mesh);
-  Stage::GetCurrent().Add(actor);
-
-  actor.SetBlendMode(blendingMode);
-  actor.SetOpacity(actorOpacity);
-
-  TraceCallStack& cullFaceTrace = application.GetGlAbstraction().GetCullFaceTrace();
-  cullFaceTrace.Enable(true);
-  application.SendNotification();
-  application.Render();
-  DALI_TEST_EQUALS( BlendEnabled( cullFaceTrace ), expectedBlend, TEST_LOCATION );
-}
-} //anonymous namespace
-
-
-int UtcDaliMeshActorBlend01(void)
-{
-  // Set Material with translucent color, actor color opaque, Set Use image alpha to true
-  // Expect blending
-
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::Blend01()");
-
-  TestBlending( application, ConstructMaterial(0.5f, 0.5f), 1.0f, BlendingMode::AUTO, true );
-  END_TEST;
-}
-
-
-int UtcDaliMeshActorBlend02(void)
-{
-  // Set material to translucent, set use image alpha to false, set actor opacity to 1.0f
-  // Expect no blending
-
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::Blend02()");
-  TestBlending( application, ConstructMaterial(0.5f, 0.5f), 1.0f, BlendingMode::OFF, false );
-  END_TEST;
-}
-
-int UtcDaliMeshActorBlend03(void)
-{
-  // Set material to opaque, set use image alpha to true, set actor opacity to 1.0f
-  // Expect no blending
-
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::Blend03()");
-  TestBlending( application, ConstructMaterial(1.0f, 1.0f), 1.0f, BlendingMode::AUTO, false );
-  END_TEST;
-}
-
-
-int UtcDaliMeshActorBlend04(void)
-{
-  // Set material to have image with alpha, set use image alpha to true, set actor opacity to 1.0f
-  // Expect blending
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::Blend04()");
-
-  Material material = ConstructMaterial(1.0f, 1.0f);
-  BufferImage image = BufferImage::New( 100, 50, Pixel::RGBA8888 );
-  material.SetDiffuseTexture( image );
-  application.SendNotification();
-  application.Render(0);
-
-  TestBlending( application, material, 1.0f, BlendingMode::AUTO, true );
-  END_TEST;
-}
-
-int UtcDaliMeshActorBlend05(void)
-{
-  // Set material to have image with alpha, set use image alpha to false, set actor opacity to 1.0f
-  // Expect no blending
-
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::Blend05()");
-
-  Material material = ConstructMaterial(1.0f, 1.0f);
-  BufferImage image = BufferImage::New( 100, 50, Pixel::RGBA8888 );
-  material.SetDiffuseTexture( image );
-  application.SendNotification();
-  application.Render(0);
-
-  TestBlending( application, material, 1.0f, BlendingMode::ON, true );
-  END_TEST;
-}
-
-
-int UtcDaliMeshActorBlend06(void)
-{
-  // Set material to have image without alpha, set use image alpha to true, set actor opacity to 1.0f
-  // Expect no blending
-
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::Blend()");
-
-  Material material = ConstructMaterial(1.0f, 1.0f);
-  BufferImage image = BufferImage::New( 100, 50, Pixel::RGB888 );
-  material.SetDiffuseTexture( image );
-  application.SendNotification();
-  application.Render(0);
-
-  TestBlending( application, material, 1.0f, BlendingMode::AUTO, false );
-  END_TEST;
-}
-
-int UtcDaliMeshActorBlend07(void)
-{
-  // Set material to have framebuffer with alpha, set use image alpha to true, set actor opacity to 1.0f
-  // Expect blending
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::Blend07()");
-  application.Render(0);
-
-  Material material = ConstructMaterial(1.0f, 1.0f);
-  FrameBufferImage image = FrameBufferImage::New( 100, 50, Pixel::RGBA8888 );
-  RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
-  RenderTask task = taskList.GetTask( 0u );
-  task.SetTargetFrameBuffer( image ); // To ensure frame buffer is connected
-  application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
-  application.SendNotification();
-  application.Render();
-
-  material.SetDiffuseTexture( image ); // (to render from)
-  application.SendNotification();
-  application.Render();
-  application.Render();
-  application.SendNotification();
-
-  TestBlending( application, material, 1.0f, BlendingMode::AUTO, true );
-  END_TEST;
-}
-
-int UtcDaliMeshActorBlend08(void)
-{
-  // Set material to have image with alpha, set use image alpha to false, set actor opacity to 0.5f
-  // Expect blending
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::Blend08()");
-
-  Material material = ConstructMaterial(1.0f, 1.0f);
-  BufferImage image = BufferImage::New( 100, 50, Pixel::RGBA8888 );
-  material.SetDiffuseTexture( image );
-  application.SendNotification();
-  application.Render(0);
-
-  TestBlending( application, material, 0.5f, BlendingMode::AUTO, true );
-  END_TEST;
-}
-
-int UtcDaliMeshActorBlend09(void)
-{
-  // Set material to have image with no alpha, set material opacity to 0.5, set use image alpha to true, set actor opacity to 1.0f
-  // Expect blending
-  TestApplication application;
-  tet_infoline("Testing Dali::MeshActor::Blend08()");
-
-  Material material = ConstructMaterial(0.5f, 1.0f);
-  BufferImage image = BufferImage::New( 100, 50, Pixel::RGB888 );
-  material.SetDiffuseTexture( image );
-  application.SendNotification();
-  application.Render(0);
-
-  TestBlending( application, material, 1.0f, BlendingMode::AUTO, true );
-  END_TEST;
-}
-
-// Test that bones update the mesh's bone transform uniforms
-// (Removed old test - wasn't checking the above information, but instead the property
-// info, which is tested elsewhere)
-
-int UtcDaliMeshActorIndices(void)
-{
-  TestApplication application;
-  Actor basicActor = Actor::New();
-  Mesh mesh = NewMesh();
-  MeshActor meshActor = MeshActor::New(mesh);
-
-  Property::IndexContainer indices;
-  meshActor.GetPropertyIndices( indices );
-  DALI_TEST_CHECK( indices.size() == basicActor.GetPropertyCount() ); // Mesh Actor does not have any properties
-  DALI_TEST_EQUALS( indices.size(), meshActor.GetPropertyCount(), TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliAnimatableMeshActorIndices(void)
-{
-  TestApplication application;
-  Actor basicActor = Actor::New();
-  AnimatableMesh mesh = NewAnimatableMesh();
-  MeshActor meshActor = MeshActor::New(mesh);
-
-  Property::IndexContainer indices;
-  meshActor.GetPropertyIndices( indices );
-  DALI_TEST_CHECK( indices.size() == basicActor.GetPropertyCount() ); // Mesh Actor does not have any properties
-  DALI_TEST_EQUALS( indices.size(), meshActor.GetPropertyCount(), TEST_LOCATION );
-  END_TEST;
-}
diff --git a/automated-tests/src/dali/utc-Dali-MeshData.cpp b/automated-tests/src/dali/utc-Dali-MeshData.cpp
deleted file mode 100644 (file)
index 273bd27..0000000
+++ /dev/null
@@ -1,331 +0,0 @@
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali-test-suite-utils.h>
-
-using namespace Dali;
-
-#include "mesh-builder.h"
-
-
-
-int UtcDaliMeshDataNew(void)
-{
-  TestApplication application;
-  MeshData meshData;
-
-  DALI_TEST_EQUALS(meshData.HasNormals(), false, TEST_LOCATION);
-  DALI_TEST_EQUALS(meshData.HasTextureCoords(), false, TEST_LOCATION);
-  END_TEST;
-}
-
-
-int UtcDaliMeshDataSetData(void)
-{
-  TestApplication application;
-
-  MeshData meshData;
-  MeshData::VertexContainer    vertices;
-  MeshData::FaceIndices        faces;
-  BoneContainer                bones;
-  ConstructVertices(vertices, 60);
-  ConstructFaces(vertices, faces);
-  Material customMaterial = ConstructMaterial();
-  meshData.SetData(vertices, faces, bones, customMaterial);
-
-  DALI_TEST_GREATER(meshData.GetVertexCount(), size_t(0), TEST_LOCATION);
-  DALI_TEST_GREATER(meshData.GetFaceCount(), size_t(0), TEST_LOCATION);
-
-  const MeshData::FaceIndices& faces2 = meshData.GetFaces();
-  const MeshData::VertexContainer& verts2 = meshData.GetVertices();
-  DALI_TEST_EQUALS(faces.at(0), faces2.at(0), TEST_LOCATION);
-  DALI_TEST_EQUALS(vertices.at(1).y, verts2.at(1).y, TEST_LOCATION);
-  DALI_TEST_EQUALS(meshData.GetBoneCount(), static_cast<size_t>(0), TEST_LOCATION);
-  END_TEST;
-}
-
-int UtcDaliMeshDataAddToBoundingVolume(void)
-{
-  TestApplication application;
-
-  float sz=40.0f;
-
-  MeshData meshData;
-  MeshData::VertexContainer    vertices;
-  MeshData::FaceIndices        faces;
-  BoneContainer                bones;
-  ConstructVertices(vertices, sz);
-  ConstructFaces(vertices, faces);
-  Material customMaterial = ConstructMaterial();
-  meshData.SetData(vertices, faces, bones, customMaterial);
-
-  Vector4 upper(-1e10f, -1e10f, -1e10f, 0.0f);
-  Vector4 lower(1e10f, 1e10f, 1e10f, 0.0f);
-  Matrix f(false);
-  f.SetIdentityAndScale(Vector3(2.0f, 2.0f, 2.0f));
-  meshData.AddToBoundingVolume(lower, upper, f);
-
-  Vector4 min(-sz*0.5f, -sz,      -sz*0.7f, 0.0f);
-  Vector4 max( sz*0.5f,  sz*0.3f,  sz*0.5f, 0.0f);
-
-  // Test that upper and lower bounds are set and transformed
-  DALI_TEST_EQUALS(lower, min*2.0f, 0.001, TEST_LOCATION);
-  DALI_TEST_EQUALS(upper, max*2.0f, 0.001, TEST_LOCATION);
-
-  // Test that mesh's upper and lower bounds are set and not transformed
-  DALI_TEST_EQUALS(meshData.GetBoundingBoxMin(), min, 0.001, TEST_LOCATION);
-  DALI_TEST_EQUALS(meshData.GetBoundingBoxMax(), max, 0.001, TEST_LOCATION);
-  END_TEST;
-}
-
-int UtcDaliMeshDataBoundingBox(void)
-{
-  TestApplication application;
-
-  float sz=40.0f;
-  MeshData meshData;
-  Vector4 min(-1.0f, -2.0f, -3.0f, 0.0f);
-  Vector4 max(1.0f, 2.0f, 3.0f, 0.0f);
-  meshData.SetBoundingBoxMin(min);
-  meshData.SetBoundingBoxMax(max);
-  DALI_TEST_EQUALS(meshData.GetBoundingBoxMin(), min, 0.001, TEST_LOCATION);
-  DALI_TEST_EQUALS(meshData.GetBoundingBoxMax(), max, 0.001, TEST_LOCATION);
-
-  MeshData::VertexContainer    vertices;
-  MeshData::FaceIndices        faces;
-  BoneContainer                bones;
-  ConstructVertices(vertices, sz);
-  ConstructFaces(vertices, faces);
-  Material customMaterial = ConstructMaterial();
-  meshData.SetData(vertices, faces, bones, customMaterial);
-
-  // Check bounding box hasn't changed
-  DALI_TEST_EQUALS(meshData.GetBoundingBoxMin(), min, 0.001, TEST_LOCATION);
-  DALI_TEST_EQUALS(meshData.GetBoundingBoxMax(), max, 0.001, TEST_LOCATION);
-
-  Vector4 upper(-1e10f, -1e10f, -1e10f, 0.0f);
-  Vector4 lower(1e10f, 1e10f, 1e10f, 0.0f);
-  meshData.AddToBoundingVolume(lower, upper, Matrix::IDENTITY);
-
-  // Bounding box should have been update
-  Vector4 bbMin(-sz*0.5f, -sz,      -sz*0.7f, 0.0f);
-  Vector4 bbMax( sz*0.5f,  sz*0.3f,  sz*0.5f, 0.0f);
-
-  // Test that upper and lower bounds are set and transformed
-  DALI_TEST_EQUALS(lower, bbMin, 0.001, TEST_LOCATION);
-  DALI_TEST_EQUALS(upper, bbMax, 0.001, TEST_LOCATION);
-
-  // Test that mesh's upper and lower bounds are set and not transformed
-  DALI_TEST_EQUALS(meshData.GetBoundingBoxMin(), bbMin, 0.001, TEST_LOCATION);
-  DALI_TEST_EQUALS(meshData.GetBoundingBoxMax(), bbMax, 0.001, TEST_LOCATION);
-  END_TEST;
-}
-
-int UtcDaliMeshDataGetVertexCount(void)
-{
-  TestApplication application;
-
-  MeshData meshData;
-  MeshData::VertexContainer    vertices;
-  MeshData::FaceIndices        faces;
-  BoneContainer                bones;
-  ConstructVertices(vertices, 30);
-  ConstructFaces(vertices, faces);
-  Material customMaterial = ConstructMaterial();
-
-  DALI_TEST_EQUALS(meshData.GetVertexCount(), static_cast<size_t>(0), TEST_LOCATION);
-
-  meshData.SetData(vertices, faces, bones, customMaterial);
-  DALI_TEST_EQUALS(meshData.GetVertexCount(), vertices.size(), TEST_LOCATION);
-
-  END_TEST;
-}
-
-int UtcDaliMeshDataGetVertices(void)
-{
-  TestApplication application;
-  MeshData meshData;
-  const Dali::MeshData::VertexContainer& verts1 = meshData.GetVertices();
-  DALI_TEST_CHECK(verts1.size() == 0);
-
-  MeshData::VertexContainer    vertices;
-  MeshData::FaceIndices        faces;
-  BoneContainer                bones;
-  ConstructVertices(vertices, 30);
-  ConstructFaces(vertices, faces);
-  Material customMaterial = ConstructMaterial();
-  meshData.SetData(vertices, faces, bones, customMaterial);
-
-  const Dali::MeshData::VertexContainer& verts2 = meshData.GetVertices();
-  DALI_TEST_CHECK(verts2.size() != 0);
-  DALI_TEST_CHECK(verts2.size() == meshData.GetVertexCount());
-  END_TEST;
-}
-
-int UtcDaliMeshDataGetFaceCount(void)
-{
-  TestApplication application;
-  MeshData meshData;
-  DALI_TEST_EQUALS(meshData.GetFaceCount(), static_cast<size_t>(0), TEST_LOCATION);
-
-  MeshData::VertexContainer    vertices;
-  MeshData::FaceIndices        faces;
-  BoneContainer                bones;
-  ConstructVertices(vertices, 30);
-  ConstructFaces(vertices, faces);
-  Material customMaterial = ConstructMaterial();
-  meshData.SetData(vertices, faces, bones, customMaterial);
-
-  DALI_TEST_EQUALS(meshData.GetFaceCount(), faces.size() / 3, TEST_LOCATION);
-  END_TEST;
-}
-
-int UtcDaliMeshDataGetFaces(void)
-{
-  TestApplication application;
-  MeshData meshData;
-  const Dali::MeshData::FaceIndices& faces1 = meshData.GetFaces();
-  DALI_TEST_CHECK(faces1.size() == 0);
-
-  MeshData::VertexContainer    vertices;
-  MeshData::FaceIndices        faces;
-  BoneContainer                bones;
-  ConstructVertices(vertices, 30);
-  ConstructFaces(vertices, faces);
-  Material customMaterial = ConstructMaterial();
-  meshData.SetData(vertices, faces, bones, customMaterial);
-
-  const Dali::MeshData::FaceIndices& faces2 = meshData.GetFaces();
-  DALI_TEST_CHECK(faces2.size() != 0);
-  END_TEST;
-}
-
-int UtcDaliMeshDataTextureCoords(void)
-{
-  TestApplication application;
-  MeshData meshData;
-  DALI_TEST_EQUALS(meshData.HasTextureCoords(), false, TEST_LOCATION);
-  meshData.SetHasTextureCoords(true);
-  DALI_TEST_EQUALS(meshData.HasTextureCoords(), true, TEST_LOCATION);
-  END_TEST;
-}
-
-int UtcDaliMeshDataNormals(void)
-{
-  TestApplication application;
-  MeshData meshData;
-  DALI_TEST_EQUALS(meshData.HasNormals(), false, TEST_LOCATION);
-  meshData.SetHasNormals(true);
-  DALI_TEST_EQUALS(meshData.HasNormals(), true, TEST_LOCATION);
-  END_TEST;
-}
-
-int UtcDaliMeshDataGetMaterial(void)
-{
-  TestApplication application;
-  MeshData meshData;
-  Material aMat = meshData.GetMaterial();
-  DALI_TEST_CHECK(!aMat);
-
-  MeshData::VertexContainer    vertices;
-  MeshData::FaceIndices        faces;
-  BoneContainer                bones;
-  ConstructVertices(vertices, 30);
-  ConstructFaces(vertices, faces);
-  Material customMaterial = ConstructMaterial();
-  meshData.SetData(vertices, faces, bones, customMaterial);
-
-  aMat = meshData.GetMaterial();
-  DALI_TEST_CHECK(aMat);
-  END_TEST;
-}
-
-int UtcDaliMeshDataSetMaterial(void)
-{
-  TestApplication application;
-  MeshData meshData;
-
-  Material aMat = meshData.GetMaterial();
-  DALI_TEST_CHECK(!aMat);
-
-  Material mat1 = ConstructMaterial();
-  meshData.SetMaterial(mat1);
-  aMat = meshData.GetMaterial();
-  DALI_TEST_CHECK(mat1 == aMat);
-
-  MeshData::VertexContainer    vertices;
-  MeshData::FaceIndices        faces;
-  BoneContainer                bones;
-  ConstructVertices(vertices, 30);
-  ConstructFaces(vertices, faces);
-  Material customMaterial = ConstructMaterial();
-  meshData.SetData(vertices, faces, bones, customMaterial);
-
-  aMat = meshData.GetMaterial();
-
-  DALI_TEST_CHECK(aMat == customMaterial);
-  DALI_TEST_CHECK(aMat != mat1);
-
-  END_TEST;
-}
-
-int UtcDaliMeshDataGetBoneCount(void)
-{
-  TestApplication application;
-  MeshData meshData;
-  DALI_TEST_EQUALS(meshData.GetBoneCount(), static_cast<size_t>(0), TEST_LOCATION);
-  DALI_TEST_EQUALS(meshData.HasBones(), false, TEST_LOCATION);
-
-  MeshData::VertexContainer    vertices;
-  MeshData::FaceIndices        faces;
-  BoneContainer                bones;
-  ConstructVertices(vertices, 30);
-  ConstructFaces(vertices, faces);
-  ConstructBones(bones);
-  Material customMaterial = ConstructMaterial();
-  meshData.SetData(vertices, faces, bones, customMaterial);
-
-  DALI_TEST_EQUALS(meshData.GetBoneCount(), static_cast<size_t>(3), TEST_LOCATION);
-  DALI_TEST_EQUALS(meshData.HasBones(), true, TEST_LOCATION);
-  END_TEST;
-}
-
-
-int UtcDaliMeshDataGetBones(void)
-{
-  TestApplication application;
-  MeshData meshData;
-  DALI_TEST_EQUALS(meshData.GetBoneCount(), static_cast<size_t>(0), TEST_LOCATION);
-  const BoneContainer& bones1 = meshData.GetBones();
-  DALI_TEST_CHECK(bones1.empty());
-
-  MeshData::VertexContainer    vertices;
-  MeshData::FaceIndices        faces;
-  BoneContainer                bones;
-  ConstructVertices(vertices, 30);
-  ConstructFaces(vertices, faces);
-  ConstructBones(bones);
-  Material customMaterial = ConstructMaterial();
-  meshData.SetData(vertices, faces, bones, customMaterial);
-  const BoneContainer& bones3 = meshData.GetBones();
-  DALI_TEST_CHECK( ! bones3.empty() );
-  END_TEST;
-}
diff --git a/automated-tests/src/dali/utc-Dali-Mutex.cpp b/automated-tests/src/dali/utc-Dali-Mutex.cpp
deleted file mode 100644 (file)
index 2911d6c..0000000
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * Copyright (c) 2015 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <iostream>
-#include <stdlib.h>
-#include <unistd.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/common/mutex.h>
-#include <dali-test-suite-utils.h>
-
-using Dali::Mutex;
-
-int UtcDaliMutexSingleThread(void)
-{
-  tet_infoline("Testing Dali::Mutex in a single thread");
-
-  {
-    Mutex mutex1;
-    DALI_TEST_EQUALS( false, mutex1.IsLocked(), TEST_LOCATION );
-  }
-
-  {
-    Mutex mutex2;
-    Mutex::ScopedLock lock( mutex2 );
-    DALI_TEST_EQUALS( true, mutex2.IsLocked(), TEST_LOCATION );
-  }
-
-  Mutex mutex3;
-  {
-    Mutex::ScopedLock lock( mutex3 );
-  }
-  DALI_TEST_EQUALS( false, mutex3.IsLocked(), TEST_LOCATION );
-
-  END_TEST;
-}
-
-namespace // for local variables to avoid name clashes
-{
-int gGlobalValue = 0;
-Mutex* gGlobalValueMutex;
-bool gWorkerThreadWait = true;
-enum ThreadState { INIT, RUN, LOCKING, TERMINATE } gWorkerThreadState = INIT;
-}
-void* WorkerThread1( void* ptr )
-{
-  gWorkerThreadState = RUN;
-  {
-    Mutex::ScopedLock lock( *gGlobalValueMutex );
-    gWorkerThreadState = LOCKING;
-    gGlobalValue = -1;
-    while( gWorkerThreadWait ) // wait till we can exit
-    {
-      usleep( 1 ); // 1 microsecond
-    }
-  }
-  gWorkerThreadState = TERMINATE;
-  return NULL;
-}
-
-int UtcDaliMutexMultiThread(void)
-{
-  tet_infoline("Testing Dali::Mutex multithreaded");
-
-  gGlobalValueMutex = new Dali::Mutex;
-
-  pthread_t thread1;
-  // initialize values
-  gGlobalValue = 0;
-  gWorkerThreadWait = true;
-  DALI_TEST_EQUALS( INIT, gWorkerThreadState, TEST_LOCATION );
-  DALI_TEST_EQUALS( 0, gGlobalValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( false, gGlobalValueMutex->IsLocked(), TEST_LOCATION );
-
-  // lock the mutex
-  {
-    Mutex::ScopedLock lock( *gGlobalValueMutex );
-    DALI_TEST_EQUALS( true, gGlobalValueMutex->IsLocked(), TEST_LOCATION );
-    pthread_create( &thread1, NULL, &WorkerThread1, NULL );
-    // wait till the thread is in run state
-    while( RUN != gWorkerThreadState )
-    {
-      usleep( 1 ); // 1 microsecond
-    }
-    // now the thread is running and mutex is still locked by this thread so value is not changed
-    DALI_TEST_EQUALS( true, gGlobalValueMutex->IsLocked(), TEST_LOCATION );
-    DALI_TEST_EQUALS( 0, gGlobalValue, TEST_LOCATION );
-    // drop out of scope, releases our lock
-  }
-  // now child thread is allowed to change the value
-  // wait till the thread is in locking state
-  while( LOCKING != gWorkerThreadState )
-  {
-    usleep( 1 ); // 1 microsecond
-  }
-  // mutex is locked, but not by us, by the child thread
-  DALI_TEST_EQUALS( true, gGlobalValueMutex->IsLocked(), TEST_LOCATION );
-  // value is changed
-  DALI_TEST_EQUALS( -1, gGlobalValue, TEST_LOCATION );
-  // let worker finish
-  gWorkerThreadWait = false;
-  // wait till the thread is terminated state
-  while( TERMINATE != gWorkerThreadState )
-  {
-    usleep( 1 ); // 1 microsecond
-  }
-  DALI_TEST_EQUALS( false, gGlobalValueMutex->IsLocked(), TEST_LOCATION );
-  void* exitValue;
-  pthread_join( thread1, &exitValue );
-
-  END_TEST;
-}
-
-int UtcDaliMutexNonCopyable(void)
-{
-  // we want to make sure that mutex is not copyable (its copy constructor is not defined)
-  // this test will stop compiling if Mutex has compiler generated copy constructor
-  DALI_COMPILE_TIME_ASSERT( !__has_trivial_copy( Mutex ) );
-
-  DALI_TEST_CHECK( true );
-  END_TEST;
-}
-
-
index 15fcfff52c4c3046276d1cb2c4fb8780dba66994..1383ee454b77abf006c9359d0252f911f79c70de 100644 (file)
 #include <stdlib.h>
 #include <dali-test-suite-utils.h>
 #include <dali/public-api/dali-core.h>
-#include <dali/devel-api/actors/mesh-actor.h>
-#include <dali/devel-api/geometry/mesh.h>
 
 using namespace Dali;
 
-#include "mesh-builder.h"
-
 namespace
 {
 
@@ -128,25 +124,6 @@ struct TestLayerCallback
   bool& mSignalVerified;
 };
 
-
-struct TestMeshActorCallback
-{
-  TestMeshActorCallback(bool& signalReceived)
-  : mSignalVerified(signalReceived)
-  {
-  }
-  void operator()(BaseHandle object)
-  {
-    tet_infoline("Verifying TestMeshActorCallback()");
-    MeshActor actor = MeshActor::DownCast(object);
-    if(actor)
-    {
-      mSignalVerified = true;
-    }
-  }
-  bool& mSignalVerified;
-};
-
 struct TestAnimationCallback
 {
   TestAnimationCallback(bool& signalReceived)
@@ -321,37 +298,6 @@ int UtcDaliObjectRegistrySignalLayerCreated(void)
   END_TEST;
 }
 
-
-int UtcDaliObjectRegistrySignalMeshActorCreated(void)
-{
-  TestApplication application;
-  ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
-
-  bool verified = false;
-  TestMeshActorCallback test(verified);
-
-  Dali::RefObject* objectPointer = NULL;
-  TestObjectDestroyedCallback test2(verified, objectPointer);
-
-  registry.ObjectCreatedSignal().Connect(&application, test);
-  registry.ObjectDestroyedSignal().Connect(&application, test2);
-
-  Mesh mesh = ConstructMesh(60);
-
-  {
-    MeshActor actor = MeshActor::New(mesh);
-
-    DALI_TEST_CHECK(actor);
-    DALI_TEST_CHECK( test.mSignalVerified );
-
-    verified = false;
-    objectPointer = actor.GetObjectPtr();
-  }
-  DALI_TEST_CHECK( test.mSignalVerified );
-  END_TEST;
-}
-
-
 int UtcDaliObjectRegistrySignalAnimationCreated(void)
 {
   TestApplication application;
index 23ddf892d7b895e41cdbba379a0c14c2e7bf831f..25ebaf909c380f9bfbba34e2cc1297e77a24d49a 100644 (file)
@@ -19,7 +19,6 @@
 
 #include <stdlib.h>
 #include <dali/public-api/dali-core.h>
-#include <dali/devel-api/actors/mesh-actor.h>
 #include <dali/integration-api/events/touch-event-integ.h>
 #include <dali-test-suite-utils.h>
 
@@ -303,9 +302,10 @@ int UtcDaliRenderableActorGetCullFace(void)
 
   DALI_TEST_CHECK( CullNone == imageActor.GetCullFace() );
 
-  MeshActor meshActor = MeshActor::New();
+  imageActor.SetCullFace( CullBack );
+
+  DALI_TEST_CHECK( CullBack == imageActor.GetCullFace() );
 
-  DALI_TEST_CHECK( CullBack == meshActor.GetCullFace() );
   END_TEST;
 }
 
diff --git a/automated-tests/src/dali/utc-Dali-Scripting.cpp b/automated-tests/src/dali/utc-Dali-Scripting.cpp
deleted file mode 100644 (file)
index 981e506..0000000
+++ /dev/null
@@ -1,1012 +0,0 @@
-/*
- * Copyright (c) 2014 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/scripting/scripting.h>
-#include <dali-test-suite-utils.h>
-
-using namespace Dali;
-using namespace Dali::Scripting;
-
-namespace
-{
-
-const StringEnum< int > COLOR_MODE_VALUES[] =
-{
-    { "USE_OWN_COLOR", USE_OWN_COLOR },
-    { "USE_PARENT_COLOR", USE_PARENT_COLOR },
-    { "USE_OWN_MULTIPLY_PARENT_COLOR", USE_OWN_MULTIPLY_PARENT_COLOR },
-    { "USE_OWN_MULTIPLY_PARENT_ALPHA", USE_OWN_MULTIPLY_PARENT_ALPHA },
-};
-const unsigned int COLOR_MODE_VALUES_COUNT = sizeof( COLOR_MODE_VALUES ) / sizeof( COLOR_MODE_VALUES[0] );
-
-const StringEnum< int > POSITION_INHERITANCE_MODE_VALUES[] =
-{
-    { "INHERIT_PARENT_POSITION", INHERIT_PARENT_POSITION },
-    { "USE_PARENT_POSITION", USE_PARENT_POSITION },
-    { "USE_PARENT_POSITION_PLUS_LOCAL_POSITION", USE_PARENT_POSITION_PLUS_LOCAL_POSITION },
-    { "DONT_INHERIT_POSITION", DONT_INHERIT_POSITION },
-};
-const unsigned int POSITION_INHERITANCE_MODE_VALUES_COUNT = sizeof( POSITION_INHERITANCE_MODE_VALUES ) / sizeof( POSITION_INHERITANCE_MODE_VALUES[0] );
-
-const StringEnum< int > DRAW_MODE_VALUES[] =
-{
-    { "NORMAL", DrawMode::NORMAL },
-    { "OVERLAY", DrawMode::OVERLAY },
-    { "STENCIL", DrawMode::STENCIL },
-};
-const unsigned int DRAW_MODE_VALUES_COUNT = sizeof( DRAW_MODE_VALUES ) / sizeof( DRAW_MODE_VALUES[0] );
-
-
-////////////////////////////////////////////////////////////////////////////////
-// Helpers for string to enum comparisons for Image and Image loading parameters
-////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Template to check enumerations of type T, with a class of type X
- */
-template< typename T, typename X >
-void TestEnumStrings(
-  Property::Map& map,                       // The map used to create instance of type X
-  const StringEnum< int >* values,          // An array of string values
-  unsigned int num,                         // Number of items in the array
-  T ( X::*method )() const,                 // The member method of X to call to get the enum
-  X ( *creator ) ( const Property::Value& ) // The method which creates an instance of type X
-)
-{
-  const unsigned int lastIndex( map.Count() - 1 );
-  const std::string& key = map.GetKey( lastIndex );
-  Property::Value& value = map.GetValue( lastIndex );
-
-  for ( unsigned int i = 0; i < num; ++i )
-  {
-    value = values[i].string;
-    tet_printf("Checking: %s: %s\n", key.c_str(), values[i].string );
-    X instance = creator( map );
-    DALI_TEST_EQUALS( values[i].value, ( instance.*method )(), TEST_LOCATION );
-  }
-}
-
-/// Helper method to create ResourceImage using property
-ResourceImage NewResourceImage( const Property::Value& map )
-{
-  ResourceImage image = ResourceImage::DownCast( NewImage( map ) );
-  return image;
-}
-
-/// Helper method to create ResourceImage using property
-BufferImage NewBufferImage( const Property::Value& map )
-{
-  BufferImage image = BufferImage::DownCast( NewImage( map ) );
-  return image;
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// Helpers for string to enum comparisons for Actor to Property::Map
-//////////////////////////////////////////////////////////////////////////////
-
-/**
- * Template to check enumerations of type T
- */
-template< typename T >
-void TestEnumStrings(
-  const char * const keyName,               // The name of the key to check
-  TestApplication& application,             // Reference to the application class
-  const StringEnum< int >* values,          // An array of string values
-  unsigned int num,                         // Number of items in the array
-  void ( Actor::*method )( T )              // The Actor member method to set the enumeration
-)
-{
-  for ( unsigned int i = 0; i < num; ++i )
-  {
-    tet_printf("Checking: %s: %s\n", keyName, values[i].string );
-
-    Actor actor = Actor::New();
-    (actor.*method)( ( T ) values[i].value );
-
-    Stage::GetCurrent().Add( actor );
-    application.SendNotification();
-    application.Render();
-
-    Property::Map map;
-    CreatePropertyMap( actor, map );
-
-    DALI_TEST_CHECK( map.Count() );
-    Property::Value value( map );
-    DALI_TEST_CHECK( value.HasKey( keyName ) );
-    DALI_TEST_EQUALS( value.GetValue( keyName ).Get< std::string >(), values[i].string, TEST_LOCATION );
-
-    Stage::GetCurrent().Remove( actor );
-  }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-
-} // anon namespace
-
-
-
-int UtcDaliScriptingGetColorMode(void)
-{
-  TestApplication application;
-
-  for ( unsigned int i = 0; i < COLOR_MODE_VALUES_COUNT; ++i )
-  {
-    tet_printf( "Checking %s == %d\n", COLOR_MODE_VALUES[i].string, COLOR_MODE_VALUES[i].value );
-    DALI_TEST_EQUALS( COLOR_MODE_VALUES[i].value, GetColorMode( COLOR_MODE_VALUES[i].string ), TEST_LOCATION );
-    DALI_TEST_EQUALS( COLOR_MODE_VALUES[i].string, GetColorMode( (ColorMode) COLOR_MODE_VALUES[i].value ), TEST_LOCATION );
-  }
-
-  try
-  {
-    (void)GetColorMode("INVALID_ARG");
-    tet_result( TET_FAIL );
-  }
-  catch ( DaliException& e )
-  {
-    DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
-  }
-  END_TEST;
-}
-
-int UtcDaliScriptingGetPositionInheritanceMode(void)
-{
-  TestApplication application;
-
-  for ( unsigned int i = 0; i < POSITION_INHERITANCE_MODE_VALUES_COUNT; ++i )
-  {
-    tet_printf( "Checking %s == %d\n", POSITION_INHERITANCE_MODE_VALUES[i].string, POSITION_INHERITANCE_MODE_VALUES[i].value );
-    DALI_TEST_EQUALS( POSITION_INHERITANCE_MODE_VALUES[i].value, GetPositionInheritanceMode( POSITION_INHERITANCE_MODE_VALUES[i].string ), TEST_LOCATION );
-    DALI_TEST_EQUALS( POSITION_INHERITANCE_MODE_VALUES[i].string, GetPositionInheritanceMode( (PositionInheritanceMode) POSITION_INHERITANCE_MODE_VALUES[i].value ), TEST_LOCATION );
-  }
-
-  try
-  {
-    (void)GetPositionInheritanceMode("INVALID_ARG");
-    tet_result( TET_FAIL );
-  }
-  catch ( DaliException& e )
-  {
-    DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
-  }
-  END_TEST;
-}
-
-
-int UtcDaliScriptingGetDrawMode(void)
-{
-  TestApplication application;
-
-  for ( unsigned int i = 0; i < DRAW_MODE_VALUES_COUNT; ++i )
-  {
-    tet_printf( "Checking %s == %d\n", DRAW_MODE_VALUES[i].string, DRAW_MODE_VALUES[i].value );
-    DALI_TEST_EQUALS( DRAW_MODE_VALUES[i].value, GetDrawMode( DRAW_MODE_VALUES[i].string ), TEST_LOCATION );
-    DALI_TEST_EQUALS( DRAW_MODE_VALUES[i].string, GetDrawMode( (DrawMode::Type) DRAW_MODE_VALUES[i].value ), TEST_LOCATION );
-  }
-
-  try
-  {
-    (void)GetDrawMode("INVALID_ARG");
-    tet_result( TET_FAIL );
-  }
-  catch ( DaliException& e )
-  {
-    DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
-  }
-  END_TEST;
-}
-
-int UtcDaliScriptingGetAnchorConstant(void)
-{
-  TestApplication application;
-
-  DALI_TEST_EQUALS( Dali::ParentOrigin::TOP_LEFT, GetAnchorConstant( "TOP_LEFT" ), TEST_LOCATION );
-  DALI_TEST_EQUALS( Dali::ParentOrigin::TOP_CENTER, GetAnchorConstant( "TOP_CENTER" ), TEST_LOCATION );
-  DALI_TEST_EQUALS( Dali::ParentOrigin::TOP_RIGHT, GetAnchorConstant( "TOP_RIGHT" ), TEST_LOCATION );
-  DALI_TEST_EQUALS( Dali::ParentOrigin::CENTER_LEFT, GetAnchorConstant( "CENTER_LEFT" ), TEST_LOCATION );
-  DALI_TEST_EQUALS( Dali::ParentOrigin::CENTER, GetAnchorConstant( "CENTER" ), TEST_LOCATION );
-  DALI_TEST_EQUALS( Dali::ParentOrigin::CENTER_RIGHT, GetAnchorConstant( "CENTER_RIGHT" ), TEST_LOCATION );
-  DALI_TEST_EQUALS( Dali::ParentOrigin::BOTTOM_LEFT, GetAnchorConstant( "BOTTOM_LEFT" ), TEST_LOCATION );
-  DALI_TEST_EQUALS( Dali::ParentOrigin::BOTTOM_CENTER, GetAnchorConstant( "BOTTOM_CENTER" ), TEST_LOCATION );
-  DALI_TEST_EQUALS( Dali::ParentOrigin::BOTTOM_RIGHT, GetAnchorConstant( "BOTTOM_RIGHT" ), TEST_LOCATION );
-
-  try
-  {
-    (void)GetAnchorConstant("INVALID_ARG");
-    tet_result( TET_FAIL );
-  }
-  catch ( DaliException& e )
-  {
-    DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
-  }
-  END_TEST;
-}
-
-int UtcDaliScriptingNewImageNegative(void)
-{
-  TestApplication application;
-
-  // Invalid filename
-  try
-  {
-    Property::Map map;
-    map[ "filename" ] = Vector3::ZERO;
-    Image image = NewImage( map );
-    tet_result( TET_FAIL );
-  }
-  catch ( DaliException& e )
-  {
-    DALI_TEST_ASSERT( e, "map.GetValue(field).GetType()", TEST_LOCATION );
-  }
-
-  // Invalid load-policy
-  try
-  {
-    Property::Map map;
-    map[ "load-policy" ] = Vector3::ZERO;
-    Image image = NewImage( map );
-    tet_result( TET_FAIL );
-  }
-  catch ( DaliException& e )
-  {
-    DALI_TEST_ASSERT( e, "map.GetValue(field).GetType()", TEST_LOCATION );
-
-    // Invalid value
-    try
-    {
-      Property::Map map;
-      map[ "load-policy" ] = "INVALID";
-      Image image = NewImage( map );
-      tet_result( TET_FAIL );
-    }
-    catch ( DaliException& e )
-    {
-      DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
-    }
-  }
-
-  // Invalid release-policy
-  try
-  {
-    Property::Map map;
-    map[ "release-policy" ] = Vector3::ZERO;
-    Image image = NewImage( map );
-    tet_result( TET_FAIL );
-  }
-  catch ( DaliException& e )
-  {
-    DALI_TEST_ASSERT( e, "map.GetValue(field).GetType()", TEST_LOCATION );
-
-    // Invalid value
-    try
-    {
-      Property::Map map;
-      map[ "release-policy" ] = "INVALID";
-      Image image = NewImage( map );
-      tet_result( TET_FAIL );
-    }
-    catch ( DaliException& e )
-    {
-      DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
-    }
-  }
-
-  // Invalid width
-  try
-  {
-    Property::Map map;
-    map[ "width" ] = "Invalid";
-    map[ "height" ] = "Invalid";
-    Image image = NewImage( map );
-    tet_result( TET_FAIL );
-  }
-  catch ( DaliException& e )
-  {
-    DALI_TEST_ASSERT( e, "value.GetType()", TEST_LOCATION );
-  }
-
-  // Invalid height
-  try
-  {
-    Property::Map map;
-    map[ "width" ] = 10;
-    map[ "height" ] = "Invalid";
-    Image image = NewImage( map );
-    tet_result( TET_FAIL );
-  }
-  catch ( DaliException& e )
-  {
-    DALI_TEST_ASSERT( e, "value.GetType()", TEST_LOCATION );
-  }
-
-  // Invalid fitting-mode
-  try
-  {
-    Property::Map map;
-    map[ "fitting-mode" ] = Vector3::ZERO;
-    Image image = NewImage( map );
-    DALI_TEST_EQUALS( "Expected exception to be thrown", "But exception was not thrown", TEST_LOCATION );
-  }
-  catch ( DaliException& e )
-  {
-    DALI_TEST_ASSERT( e, "value.GetType() == Property::STRING", TEST_LOCATION );
-
-    // Invalid value
-    try
-    {
-      Property::Map map;
-      map[ "fitting-mode" ] = "INVALID";
-      Image image = NewImage( map );
-      DALI_TEST_EQUALS( "Expected exception to be thrown", "But exception was not thrown", TEST_LOCATION );
-    }
-    catch ( DaliException& e )
-    {
-      DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
-    }
-  }
-
-  // Invalid scaling-mode
-  try
-  {
-    Property::Map map;
-    map[ "sampling-mode" ] = Vector3::ZERO;
-    Image image = NewImage( map );
-    DALI_TEST_EQUALS( "Expected exception to be thrown", "But exception was not thrown", TEST_LOCATION );
-  }
-  catch ( DaliException& e )
-  {
-    DALI_TEST_ASSERT( e, "value.GetType() == Property::STRING", TEST_LOCATION );
-
-    // Invalid value
-    try
-    {
-      Property::Map map;
-      map[ "sampling-mode" ] = "INVALID";
-      Image image = NewImage( map );
-      DALI_TEST_EQUALS( "Expected exception to be thrown", "But exception was not thrown", TEST_LOCATION );
-    }
-    catch ( DaliException& e )
-    {
-      DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
-    }
-  }
-
-  // Invalid orientation-correction
-  try
-  {
-    Property::Map map;
-    map[ "orientation" ] = Vector3::ZERO;
-    Image image = NewImage( map );
-    DALI_TEST_EQUALS( "Expected exception to be thrown", "But exception was not thrown", TEST_LOCATION );
-  }
-  catch ( DaliException& e )
-  {
-    DALI_TEST_ASSERT( e, "value.GetType() == Property::BOOLEAN", TEST_LOCATION );
-  }
-
-  // Invalid type
-  try
-  {
-    Property::Map map;
-    map[ "type" ] = Vector3::ZERO;
-    Image image = NewImage( map );
-    tet_result( TET_FAIL );
-  }
-  catch ( DaliException& e )
-  {
-    DALI_TEST_ASSERT( e, "map.GetValue(\"type\").GetType()", TEST_LOCATION );
-
-    // Invalid value
-    try
-    {
-      Property::Map map;
-      map[ "type" ] = "INVALID";
-      Image image = NewImage( map );
-      tet_result( TET_FAIL );
-    }
-    catch ( DaliException& e )
-    {
-      DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
-    }
-  }
-
-  // Invalid pixel-format
-  try
-  {
-    Property::Map map;
-    map[ "pixel-format" ] = Vector3::ZERO;
-    Image image = NewImage( map );
-    tet_result( TET_FAIL );
-  }
-  catch ( DaliException& e )
-  {
-    DALI_TEST_ASSERT( e, "map.GetValue(field).GetType()", TEST_LOCATION );
-
-    // Invalid value
-    try
-    {
-      Property::Map map;
-      map[ "pixel-format" ] = "INVALID";
-      Image image = NewImage( map );
-      tet_result( TET_FAIL );
-    }
-    catch ( DaliException& e )
-    {
-      DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
-    }
-  }
-
-  END_TEST;
-}
-
-
-int UtcDaliScriptingNewImage(void)
-{
-  TestApplication application;
-
-  Property::Map map;
-  map[ "filename" ] = "TEST_FILE";
-
-  // Filename only
-  {
-    ResourceImage image = ResourceImage::DownCast( NewImage( map ) );
-    DALI_TEST_EQUALS( "TEST_FILE", image.GetUrl(), TEST_LOCATION );
-  }
-
-  // load-policy
-  map[ "load-policy" ] = "";
-  {
-    const StringEnum< int > values[] =
-    {
-        { "IMMEDIATE", ResourceImage::IMMEDIATE },
-        { "ON_DEMAND", ResourceImage::ON_DEMAND }
-    };
-   TestEnumStrings< ResourceImage::LoadPolicy, ResourceImage >( map, values, ( sizeof( values ) / sizeof ( values[0] ) ), &ResourceImage::GetLoadPolicy, &NewResourceImage );
-  }
-
-  // release-policy
-  map[ "release-policy" ] = "";
-  {
-    const StringEnum< int > values[] =
-    {
-        { "UNUSED", Image::UNUSED },
-        { "NEVER", Image::NEVER }
-    };
-    TestEnumStrings< Image::ReleasePolicy, Image >( map, values, ( sizeof( values ) / sizeof ( values[0] ) ), &Image::GetReleasePolicy, &NewImage );
-  }
-
-  // float width and height
-  map[ "width" ] = (float) 10.0f;
-  map[ "height" ] = (float) 20.0f;
-  {
-    Image image = NewImage( map );
-    DALI_TEST_EQUALS( image.GetWidth(), 10.0f, TEST_LOCATION );
-    DALI_TEST_EQUALS( image.GetHeight(), 20.0f, TEST_LOCATION );
-  }
-
-  // int width and height
-  map[ "width"] = (int) 50;
-  map[ "height" ] = (int) 70;
-  {
-    Image image = NewImage( map );
-    DALI_TEST_EQUALS( image.GetWidth(), 50u, TEST_LOCATION );
-    DALI_TEST_EQUALS( image.GetHeight(), 70u, TEST_LOCATION );
-  }
-
-  //map.erase( map.end() - 2, map.end() );
-
-  // type FrameBufferImage
-  map[ "type" ] = "FrameBufferImage";
-  {
-    Image image = NewImage( map );
-    DALI_TEST_CHECK( FrameBufferImage::DownCast( image ) );
-  }
-  // type BufferImage
-   map[ "type" ] = "BufferImage";
-   {
-     Image image = NewImage( map );
-     DALI_TEST_CHECK( BufferImage::DownCast( image ) );
-     DALI_TEST_CHECK((BufferImage::DownCast( image )).GetPixelFormat()== Pixel::RGBA8888);
-   }
-
-   // pixel-format
-   map[ "pixel-format" ] = "";
-   {
-     const StringEnum< int > values[] =
-     {
-         { "A8", Pixel::A8 },
-         { "L8", Pixel::L8 },
-         { "LA88", Pixel::LA88 },
-         { "RGB565", Pixel::RGB565 },
-         { "BGR565", Pixel::BGR565 },
-         { "RGBA4444", Pixel::RGBA4444 },
-         { "BGRA4444", Pixel::BGRA4444 },
-         { "RGBA5551", Pixel::RGBA5551 },
-         { "BGRA5551", Pixel::BGRA5551 },
-         { "RGB888", Pixel::RGB888 },
-         { "RGB8888", Pixel::RGB8888 },
-         { "BGR8888", Pixel::BGR8888 },
-         { "RGBA8888", Pixel::RGBA8888 },
-         { "BGRA8888", Pixel::BGRA8888 },
-       /*{ "COMPRESSED_R11_EAC", Pixel::COMPRESSED_R11_EAC },
-         { "COMPRESSED_SIGNED_R11_EAC", Pixel::COMPRESSED_SIGNED_R11_EAC },
-         { "COMPRESSED_RG11_EAC", Pixel::COMPRESSED_RG11_EAC },
-         { "COMPRESSED_SIGNED_RG11_EAC", Pixel::COMPRESSED_SIGNED_RG11_EAC },
-         { "COMPRESSED_RGB8_ETC2", Pixel::COMPRESSED_RGB8_ETC2 },
-         { "COMPRESSED_SRGB8_ETC2", Pixel::COMPRESSED_SRGB8_ETC2 },
-         { "COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2", Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 },
-         { "COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2", Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 },
-         { "COMPRESSED_RGBA8_ETC2_EAC", Pixel::COMPRESSED_RGBA8_ETC2_EAC },
-         { "COMPRESSED_SRGB8_ALPHA8_ETC2_EAC", Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC },
-         { "COMPRESSED_RGB8_ETC1", Pixel::COMPRESSED_RGB8_ETC1 },
-         { "COMPRESSED_RGB_PVRTC_4BPPV1", Pixel::COMPRESSED_RGB_PVRTC_4BPPV1 },*/
-         // BufferImage does not support compressed formats
-     };
-
-     TestEnumStrings< Pixel::Format, BufferImage >( map, values, ( sizeof( values ) / sizeof ( values[0] ) ), &BufferImage::GetPixelFormat, &NewBufferImage );
-   }
-
-  // type Image
-  map[ "type" ] = "ResourceImage";
-  {
-    Image image = NewImage( map );
-    DALI_TEST_CHECK( ResourceImage::DownCast( image ) );
-    DALI_TEST_CHECK( !FrameBufferImage::DownCast( image ) );
-    DALI_TEST_CHECK( !BufferImage::DownCast( image ) );
-  }
-  END_TEST;
-}
-
-int UtcDaliScriptingNewShaderEffect(void)
-{
-  TestApplication application;
-
-  Property::Map programMap;
-  programMap[ "vertex-filename" ] = "bump.vert";
-  programMap[ "fragment-filename" ] = "bump.frag";
-
-  Property::Map imageMap;
-  imageMap[ "filename" ] = "image.png";
-
-  Property::Map map;
-  map[ "image" ] = imageMap;
-  map[ "program" ] = programMap;
-  map[ "uLightPosition" ] = Vector3( 0.0, 0.0, -1.5);
-  map[ "uAmbientLight" ] = (int)10;
-
-  ShaderEffect shader = NewShaderEffect( map );
-
-  DALI_TEST_CHECK( shader );
-  END_TEST;
-}
-
-int UtcDaliScriptingNewActorNegative(void)
-{
-  TestApplication application;
-
-  // Empty map
-  {
-    Actor handle = NewActor( Property::Map() );
-    DALI_TEST_CHECK( !handle );
-  }
-
-  // Map with only properties
-  {
-    Property::Map map;
-    map[ "parent-origin" ] = ParentOrigin::TOP_CENTER;
-    map[ "anchor-point" ] = AnchorPoint::TOP_CENTER;
-    Actor handle = NewActor( map );
-    DALI_TEST_CHECK( !handle );
-  }
-
-  // Add some signals to the map, we should have no signal connections as its not yet supported
-  {
-    Property::Map map;
-    map[ "type" ] = "Actor";
-    map[ "signals" ] = Property::MAP;
-    Actor handle = NewActor( map );
-    DALI_TEST_CHECK( handle );
-    DALI_TEST_CHECK( !handle.MouseWheelEventSignal().GetConnectionCount() );
-    DALI_TEST_CHECK( !handle.OffStageSignal().GetConnectionCount() );
-    DALI_TEST_CHECK( !handle.OnStageSignal().GetConnectionCount() );
-    DALI_TEST_CHECK( !handle.TouchedSignal().GetConnectionCount() );
-  }
-  END_TEST;
-}
-
-int UtcDaliScriptingNewActorProperties(void)
-{
-  TestApplication application;
-
-  Property::Map map;
-  map[ "type" ] = "Actor";
-  map[ "size" ] = Vector3::ONE;
-  map[ "position" ] = Vector3::XAXIS;
-  map[ "scale" ] = Vector3::ONE;
-  map[ "visible" ] = false;
-  map[ "color" ] = Color::MAGENTA;
-  map[ "name" ] = "MyActor";
-  map[ "color-mode" ] = "USE_PARENT_COLOR";
-  map[ "inherit-shader-effect" ] = false;
-  map[ "sensitive" ] = false;
-  map[ "leave-required" ] = true;
-  map[ "position-inheritance" ] = "DONT_INHERIT_POSITION";
-  map[ "draw-mode" ] = "STENCIL";
-  map[ "inherit-orientation" ] = false;
-  map[ "inherit-scale" ] = false;
-
-  // Default properties
-  {
-    Actor handle = NewActor( map );
-    DALI_TEST_CHECK( handle );
-
-    Stage::GetCurrent().Add( handle );
-    application.SendNotification();
-    application.Render();
-
-    DALI_TEST_EQUALS( handle.GetCurrentSize(), Vector3::ONE, TEST_LOCATION );
-    DALI_TEST_EQUALS( handle.GetCurrentPosition(), Vector3::XAXIS, TEST_LOCATION );
-    DALI_TEST_EQUALS( handle.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
-    DALI_TEST_EQUALS( handle.IsVisible(), false, TEST_LOCATION );
-    DALI_TEST_EQUALS( handle.GetCurrentColor(), Color::MAGENTA, TEST_LOCATION );
-    DALI_TEST_EQUALS( handle.GetName(), "MyActor", TEST_LOCATION );
-    DALI_TEST_EQUALS( handle.GetColorMode(), USE_PARENT_COLOR, TEST_LOCATION );
-    DALI_TEST_EQUALS( handle.IsSensitive(), false, TEST_LOCATION );
-    DALI_TEST_EQUALS( handle.GetLeaveRequired(), true, TEST_LOCATION );
-    DALI_TEST_EQUALS( handle.GetPositionInheritanceMode(), DONT_INHERIT_POSITION, TEST_LOCATION );
-    DALI_TEST_EQUALS( handle.GetDrawMode(), DrawMode::STENCIL, TEST_LOCATION );
-    DALI_TEST_EQUALS( handle.IsOrientationInherited(), false, TEST_LOCATION );
-    DALI_TEST_EQUALS( handle.IsScaleInherited(), false, TEST_LOCATION );
-
-    Stage::GetCurrent().Remove( handle );
-  }
-
-  // Check Anchor point and parent origin vector3s
-  map[ "parent-origin" ] = ParentOrigin::TOP_CENTER;
-  map[ "anchor-point" ] = AnchorPoint::TOP_LEFT;
-  {
-    Actor handle = NewActor( map );
-    DALI_TEST_CHECK( handle );
-
-    Stage::GetCurrent().Add( handle );
-    application.SendNotification();
-    application.Render();
-
-    DALI_TEST_EQUALS( handle.GetCurrentParentOrigin(), ParentOrigin::TOP_CENTER, TEST_LOCATION );
-    DALI_TEST_EQUALS( handle.GetCurrentAnchorPoint(), AnchorPoint::TOP_LEFT, TEST_LOCATION );
-
-    Stage::GetCurrent().Remove( handle );
-  }
-
-  // Check Anchor point and parent origin STRINGS
-  map[ "parent-origin" ] = "TOP_LEFT";
-  map[ "anchor-point" ] = "CENTER_LEFT";
-  {
-    Actor handle = NewActor( map );
-    DALI_TEST_CHECK( handle );
-
-    Stage::GetCurrent().Add( handle );
-    application.SendNotification();
-    application.Render();
-
-    DALI_TEST_EQUALS( handle.GetCurrentParentOrigin(), ParentOrigin::TOP_LEFT, TEST_LOCATION );
-    DALI_TEST_EQUALS( handle.GetCurrentAnchorPoint(), AnchorPoint::CENTER_LEFT, TEST_LOCATION );
-
-    Stage::GetCurrent().Remove( handle );
-  }
-  END_TEST;
-}
-
-int UtcDaliScriptingNewActorChildren(void)
-{
-  TestApplication application;
-
-  Property::Map map;
-  map[ "type" ] = "Actor";
-  map[ "position" ] = Vector3::XAXIS;
-
-  Property::Map child1Map;
-  child1Map[ "type" ] = "ImageActor";
-  child1Map[ "position" ] = Vector3::YAXIS;
-
-  Property::Array childArray;
-  childArray.PushBack( child1Map );
-  map[ "actors" ] = childArray;
-
-  // Create
-  Actor handle = NewActor( map );
-  DALI_TEST_CHECK( handle );
-
-  Stage::GetCurrent().Add( handle );
-  application.SendNotification();
-  application.Render();
-
-  DALI_TEST_EQUALS( handle.GetCurrentPosition(), Vector3::XAXIS, TEST_LOCATION );
-  DALI_TEST_EQUALS( handle.GetChildCount(), 1u, TEST_LOCATION );
-
-  Actor child1 = handle.GetChildAt(0);
-  DALI_TEST_CHECK( child1 );
-  DALI_TEST_CHECK( ImageActor::DownCast( child1 ) );
-  DALI_TEST_EQUALS( child1.GetCurrentPosition(), Vector3::YAXIS, TEST_LOCATION );
-  DALI_TEST_EQUALS( child1.GetChildCount(), 0u, TEST_LOCATION );
-
-  Stage::GetCurrent().Remove( handle );
-  END_TEST;
-}
-
-
-int UtcDaliScriptingCreatePropertyMapActor(void)
-{
-  TestApplication application;
-
-  // Actor Type
-  {
-    Actor actor = Actor::New();
-
-    Property::Map map;
-    CreatePropertyMap( actor, map );
-    DALI_TEST_CHECK( !map.Empty() );
-    Property::Value value( map );
-    DALI_TEST_CHECK( value.HasKey( "type" ) );
-    DALI_TEST_EQUALS( value.GetValue( "type").Get< std::string >(), "Actor", TEST_LOCATION );
-
-    Stage::GetCurrent().Remove( actor );
-  }
-
-  // ImageActor Type
-  {
-    Actor actor = ImageActor::New();
-
-    Property::Map map;
-    CreatePropertyMap( actor, map );
-    DALI_TEST_CHECK( !map.Empty() );
-    Property::Value value( map );
-    DALI_TEST_CHECK( value.HasKey( "type" ) );
-    DALI_TEST_EQUALS( value.GetValue( "type").Get< std::string >(), "ImageActor", TEST_LOCATION );
-
-    Stage::GetCurrent().Remove( actor );
-  }
-
-  // Default properties
-  {
-    Actor actor = Actor::New();
-    actor.SetSize( Vector3::ONE );
-    actor.SetPosition( Vector3::XAXIS );
-    actor.SetScale( Vector3::ZAXIS );
-    actor.SetVisible( false );
-    actor.SetColor( Color::MAGENTA );
-    actor.SetName( "MyActor" );
-    actor.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
-    actor.SetParentOrigin( ParentOrigin::TOP_RIGHT );
-    actor.SetSensitive( false );
-    actor.SetLeaveRequired( true );
-    actor.SetInheritOrientation( false );
-    actor.SetInheritScale( false );
-    actor.SetSizeModeFactor( Vector3::ONE );
-
-    Stage::GetCurrent().Add( actor );
-    application.SendNotification();
-    application.Render();
-
-    Property::Map map;
-    CreatePropertyMap( actor, map );
-
-    DALI_TEST_CHECK( !map.Empty() );
-    Property::Value value( map );
-    DALI_TEST_CHECK( value.HasKey( "size" ) );
-    DALI_TEST_EQUALS( value.GetValue( "size" ).Get< Vector3 >(), Vector3::ONE, TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "position" ) );
-    DALI_TEST_EQUALS( value.GetValue( "position" ).Get< Vector3 >(), Vector3::XAXIS, TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "scale" ) );
-    DALI_TEST_EQUALS( value.GetValue( "scale" ).Get< Vector3 >(), Vector3::ZAXIS, TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "visible" ) );
-    DALI_TEST_EQUALS( value.GetValue( "visible" ).Get< bool >(), false, TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "color" ) );
-    DALI_TEST_EQUALS( value.GetValue( "color" ).Get< Vector4 >(), Color::MAGENTA, TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "name" ) );
-    DALI_TEST_EQUALS( value.GetValue( "name").Get< std::string >(), "MyActor", TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "anchor-point" ) );
-    DALI_TEST_EQUALS( value.GetValue( "anchor-point" ).Get< Vector3 >(), AnchorPoint::CENTER_LEFT, TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "parent-origin" ) );
-    DALI_TEST_EQUALS( value.GetValue( "parent-origin" ).Get< Vector3 >(), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "sensitive" ) );
-    DALI_TEST_EQUALS( value.GetValue( "sensitive" ).Get< bool >(), false, TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "leave-required" ) );
-    DALI_TEST_EQUALS( value.GetValue( "leave-required" ).Get< bool >(), true, TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "inherit-orientation" ) );
-    DALI_TEST_EQUALS( value.GetValue( "inherit-orientation" ).Get< bool >(), false, TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "inherit-scale" ) );
-    DALI_TEST_EQUALS( value.GetValue( "inherit-scale" ).Get< bool >(), false, TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "size-mode-factor" ) );
-    DALI_TEST_EQUALS( value.GetValue( "size-mode-factor" ).Get< Vector3 >(), Vector3::ONE, TEST_LOCATION );
-
-    Stage::GetCurrent().Remove( actor );
-  }
-
-  // ColorMode
-  TestEnumStrings< ColorMode >( "color-mode", application, COLOR_MODE_VALUES, COLOR_MODE_VALUES_COUNT, &Actor::SetColorMode );
-
-  // PositionInheritanceMode
-  TestEnumStrings< PositionInheritanceMode >( "position-inheritance", application, POSITION_INHERITANCE_MODE_VALUES, POSITION_INHERITANCE_MODE_VALUES_COUNT, &Actor::SetPositionInheritanceMode );
-
-  // DrawMode
-  TestEnumStrings< DrawMode::Type >( "draw-mode", application, DRAW_MODE_VALUES, DRAW_MODE_VALUES_COUNT, &Actor::SetDrawMode );
-
-  // Children
-  {
-    Actor actor = Actor::New();
-    Actor child = ImageActor::New();
-    actor.Add( child );
-
-    Stage::GetCurrent().Add( actor );
-    application.SendNotification();
-    application.Render();
-
-    Property::Map map;
-    CreatePropertyMap( actor, map );
-    DALI_TEST_CHECK( !map.Empty() );
-
-    Property::Value value( map );
-    DALI_TEST_CHECK( value.HasKey( "type" ) );
-    DALI_TEST_EQUALS( value.GetValue( "type" ).Get< std::string >(), "Actor", TEST_LOCATION );
-
-    DALI_TEST_CHECK( value.HasKey( "actors" ) );
-    Property::Array children( value.GetValue( "actors").Get< Property::Array >() );
-    DALI_TEST_CHECK( !children.Empty() );
-    Property::Map childMap( children[0].Get< Property::Map >() );
-    DALI_TEST_CHECK( !childMap.Empty() );
-    Property::Value childValue( childMap );
-    DALI_TEST_CHECK( childValue.HasKey( "type" ) );
-    DALI_TEST_EQUALS( childValue.GetValue( "type" ).Get< std::string >(), "ImageActor", TEST_LOCATION );
-
-    Stage::GetCurrent().Remove( actor );
-  }
-  END_TEST;
-}
-
-int UtcDaliScriptingCreatePropertyMapImage(void)
-{
-  TestApplication application;
-
-  // Empty
-  {
-    Image image;
-    Property::Map map;
-    CreatePropertyMap( image, map );
-    DALI_TEST_CHECK( map.Empty() );
-  }
-
-  // Default
-  {
-    Image image = ResourceImage::New( "MY_PATH" );
-
-    Property::Map map;
-    CreatePropertyMap( image, map );
-    DALI_TEST_CHECK( !map.Empty() );
-
-    Property::Value value( map );
-    DALI_TEST_CHECK( value.HasKey( "type" ) );
-    DALI_TEST_EQUALS( value.GetValue( "type" ).Get< std::string >(), "ResourceImage", TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "filename" ) );
-    DALI_TEST_EQUALS( value.GetValue( "filename" ).Get< std::string >(), "MY_PATH", TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "load-policy") );
-    DALI_TEST_EQUALS( value.GetValue( "load-policy" ).Get< std::string >(), "IMMEDIATE", TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "release-policy") );
-    DALI_TEST_EQUALS( value.GetValue( "release-policy" ).Get< std::string >(), "NEVER", TEST_LOCATION );
-    DALI_TEST_CHECK( !value.HasKey( "width" ) );
-    DALI_TEST_CHECK( !value.HasKey( "height" ) );
-  }
-
-  // Change values
-  {
-    ResourceImage image = ResourceImage::New( "MY_PATH", ResourceImage::ON_DEMAND, Image::UNUSED, ImageDimensions( 300, 400 ), FittingMode::FIT_WIDTH );
-
-    Property::Map map;
-    CreatePropertyMap( image, map );
-    DALI_TEST_CHECK( !map.Empty() );
-
-    Property::Value value( map );
-    DALI_TEST_CHECK( value.HasKey( "type" ) );
-    DALI_TEST_EQUALS( value.GetValue( "type" ).Get< std::string >(), "ResourceImage", TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "filename" ) );
-    DALI_TEST_EQUALS( value.GetValue( "filename" ).Get< std::string >(), "MY_PATH", TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "load-policy") );
-    DALI_TEST_EQUALS( value.GetValue( "load-policy" ).Get< std::string >(), "ON_DEMAND", TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "release-policy") );
-    DALI_TEST_EQUALS( value.GetValue( "release-policy" ).Get< std::string >(), "UNUSED", TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "width" ) );
-    DALI_TEST_EQUALS( value.GetValue( "width" ).Get< int >(), 300, TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "height" ) );
-    DALI_TEST_EQUALS( value.GetValue( "height" ).Get< int >(), 400, TEST_LOCATION );
-  }
-
-  // BufferImage
-  {
-    Image image = BufferImage::New( 200, 300, Pixel::A8 );
-    Property::Map map;
-    CreatePropertyMap( image, map );
-    Property::Value value( map );
-    DALI_TEST_CHECK( value.HasKey( "type" ) );
-    DALI_TEST_EQUALS( value.GetValue( "type" ).Get< std::string >(), "BufferImage", TEST_LOCATION );
-    DALI_TEST_CHECK( value.HasKey( "pixel-format") );
-    DALI_TEST_EQUALS( value.GetValue( "pixel-format" ).Get< std::string >(), "A8", TEST_LOCATION );
-  }
-
-  // FrameBufferImage
-  {
-    Image image = FrameBufferImage::New( 200, 300, Pixel::RGBA8888 );
-    Property::Map map;
-    CreatePropertyMap( image, map );
-    Property::Value value( map );
-    DALI_TEST_CHECK( value.HasKey( "type" ) );
-    DALI_TEST_EQUALS( value.GetValue( "type" ).Get< std::string >(), "FrameBufferImage", TEST_LOCATION );
-  }
-  END_TEST;
-}
-
-int UtcDaliScriptingGetEnumerationTemplates(void)
-{
-  TestApplication application;
-
-  const Scripting::StringEnum< int > myTable[] =
-  {
-    { "ONE",    1 },
-    { "TWO",    2 },
-    { "THREE",  3 },
-    { "FOUR",   4 },
-    { "FIVE",   5 },
-  };
-  const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
-
-  for ( unsigned int i = 0; i < myTableCount; ++i )
-  {
-    tet_printf("Checking: %s\n", myTable[ i ].string );
-    DALI_TEST_EQUALS( myTable[ i ].value, GetEnumeration( myTable[ i ].string, myTable, myTableCount ), TEST_LOCATION );
-  }
-
-  for ( unsigned int i = 0; i < myTableCount; ++i )
-  {
-    tet_printf("Checking: %d\n", myTable[ i ].value );
-    DALI_TEST_EQUALS( myTable[ i ].string, GetEnumerationName( myTable[ i ].value, myTable, myTableCount ), TEST_LOCATION );
-  }
-
-  END_TEST;
-}
-
-int UtcDaliScriptingCompareEnums(void)
-{
-  // EQUAL
-  DALI_TEST_CHECK( CompareEnums( "", "" ) );
-  DALI_TEST_CHECK( CompareEnums( "HELLO", "HELLO" ) );
-  DALI_TEST_CHECK( CompareEnums( "HELLO", "hello" ) );
-  DALI_TEST_CHECK( CompareEnums( "hello", "HELLO" ) );
-  DALI_TEST_CHECK( CompareEnums( "hello-world", "HELLO_WORLD" ) );
-  DALI_TEST_CHECK( CompareEnums( "hello_WORLD", "HELLO-world" ) );
-  DALI_TEST_CHECK( CompareEnums( "hello_WORLD-", "HELLO-world_" ) );
-  DALI_TEST_CHECK( CompareEnums( "_hello_WORLD-", "-HELLO-world_" ) );
-  DALI_TEST_CHECK( CompareEnums( "-hello_WORLD-", "_HELLO-world_" ) );
-  DALI_TEST_CHECK( CompareEnums( "hello123", "HELLO123" ) );
-
-  // NOT EQUAL
-  DALI_TEST_CHECK( ! CompareEnums( "hello", "HELLOWORLD" ) );
-
-  END_TEST;
-}