Create unit tests and solve a crash revealed by the unit tests.

Author: Benoit Hudson

Assets/FbxExporters/Editor/ConvertToModel.cs

@@ -181,7 +181,7 @@ public static GameObject[] CreateInstantiatedModelPrefab (GameObject [] unityGam
             /// </summary>
             /// <returns>new file name.</returns>
             /// <param name="filename">Filename.</param>
-            private static string IncrementFileName(string path, string filename)
+            public static string IncrementFileName(string path, string filename)
             {
                 string fileWithoutExt = Path.GetFileNameWithoutExtension (filename);
                 string ext = Path.GetExtension (filename);
@@ -217,7 +217,7 @@ private static string IncrementFileName(string path, string filename)
             /// e.g. Sphere becomes Sphere 1
             /// </summary>
             /// <param name="exportSet">Export set.</param>
-            private static void EnforceUniqueNames(GameObject[] exportSet)
+            public static void EnforceUniqueNames(GameObject[] exportSet)
             {
                 Dictionary<string, int> NameToIndexMap = new Dictionary<string, int> ();
                 string format = "{0} {1}";
@@ -249,7 +249,7 @@ private static void EnforceUniqueNames(GameObject[] exportSet)
             /// </summary>
             /// <param name="orig">Original GameObject.</param>
             /// <param name="imported">Imported GameObject.</param>
-            private static void SetupImportedGameObject(GameObject orig, GameObject imported)
+            public static void SetupImportedGameObject(GameObject orig, GameObject imported)
             {
                 Transform importedTransform = imported.transform;
                 Transform origTransform = orig.transform;
@@ -258,16 +258,6 @@ private static void SetupImportedGameObject(GameObject orig, GameObject imported
                 importedTransform.SetParent (origTransform.parent, false);
                 importedTransform.SetSiblingIndex (origTransform.GetSiblingIndex());
 
-                // set the transform to be the same as before
-                bool success = UnityEditorInternal.ComponentUtility.CopyComponent (origTransform);
-                if (success) {
-                    success = UnityEditorInternal.ComponentUtility.PasteComponentValues(importedTransform);
-                }
-                if (!success) {
-                    Debug.LogWarning (string.Format ("Warning: Failed to copy component Transform from {0} to {1}",
-                        imported.name, origTransform.name));
-                }
-
                 // copy the components over, assuming that the hierarchy order is unchanged
                 if (origTransform.hierarchyCount != importedTransform.hierarchyCount) {
                     Debug.LogWarning (string.Format ("Warning: Exported {0} objects, but only imported {1}",
@@ -280,7 +270,7 @@ private static void SetupImportedGameObject(GameObject orig, GameObject imported
                 CopyComponentsRecursive (orig, imported, namesExpectedMatch:false);
             }
 
-            private static void FixSiblingOrder(Transform orig, Transform imported){
+            public static void FixSiblingOrder(Transform orig, Transform imported){
                 foreach (Transform origChild in orig) {
                     Transform importedChild = imported.Find (origChild.name);
                     if (importedChild == null) {
@@ -307,16 +297,16 @@ private static void CopyComponentsRecursive(GameObject from, GameObject to, bool
                 }
             }
 
-            private static void CopyComponents(GameObject from, GameObject to){
+            public static void CopyComponents(GameObject from, GameObject to){
                 var originalComponents = new List<Component>(to.GetComponents<Component> ());
                 var components = from.GetComponents<Component> ();
-                for(int i = 0; i < components.Length; i++){
-                    if(components[i] == null){
+                for(int i = 0, n = components.Length; i < n; ++i) {
+                    if (!components [i]) {
                         continue;
                     }
 
-                    bool success = UnityEditorInternal.ComponentUtility.CopyComponent (components[i]);
-                    if (success) {
+                    var json = EditorJsonUtility.ToJson(components[i]);
+                    {
                         bool foundComponentOfType = false;
                         for (int j = 0; j < originalComponents.Count; j++) {
                             var toComponent = originalComponents [j];
@@ -327,42 +317,43 @@ private static void CopyComponents(GameObject from, GameObject to){
                                 originalComponents.RemoveAt (j);
                                 foundComponentOfType = true;
 
-                                // Don't want to copy MeshFilter because then we will replace the
-                                // exported mesh with the old mesh.
+                                // Don't want to copy MeshFilter because then
+                                // we will replace the exported mesh with the
+                                // old mesh. TODO: just remove some entries
+                                // from the json.
                                 if (toComponent is MeshFilter) {
                                     break;
-                                }
-
-                                // Don't want to copy materials over in case the materials are
-                                // embedded in another model.
-                                if (toComponent is SkinnedMeshRenderer) {
+                                } else if (toComponent is SkinnedMeshRenderer) {
+                                    // Don't want to copy materials over in
+                                    // case the materials are embedded in
+                                    // another model.
                                     var skinnedMesh = toComponent as SkinnedMeshRenderer;
                                     var sharedMesh = skinnedMesh.sharedMesh;
                                     var sharedMats = skinnedMesh.sharedMaterials;
-                                    success = UnityEditorInternal.ComponentUtility.PasteComponentValues (toComponent);
+                                    EditorJsonUtility.FromJsonOverwrite(json, toComponent);
                                     skinnedMesh.sharedMesh = sharedMesh;
                                     skinnedMesh.sharedMaterials = sharedMats;
                                 } else if (toComponent is Renderer) {
+                                    // Don't want to copy materials over in
+                                    // case the materials are embedded in
+                                    // another model.
                                     var renderer = toComponent as Renderer;
                                     var sharedMats = renderer.sharedMaterials;
-                                    success = UnityEditorInternal.ComponentUtility.PasteComponentValues (toComponent);
+                                    EditorJsonUtility.FromJsonOverwrite(json, toComponent);
                                     renderer.sharedMaterials = sharedMats;
                                 } else {
-                                    success = UnityEditorInternal.ComponentUtility.PasteComponentValues (toComponent);
+                                    EditorJsonUtility.FromJsonOverwrite(json, toComponent);
                                 }
                                 break;
                             }
                         }
 
                         // component was not part of the original components, so add it
                         if (!foundComponentOfType) {
-                            success = UnityEditorInternal.ComponentUtility.PasteComponentAsNew (to);
+                            var toComponent = to.AddComponent(components[i].GetType());
+                            EditorJsonUtility.FromJsonOverwrite(json, toComponent);
                         }
                     }
-                    if (!success) {
-                        Debug.LogWarning (string.Format ("Warning: Failed to copy component {0} from {1} to {2}",
-                            components[i].GetType().Name, from.name, to.name));
-                    }
                 }
             }
         }

Assets/FbxExporters/Editor/UnitTests/ConvertToModelTest.cs

@@ -0,0 +1,126 @@
+using UnityEngine;
+using UnityEditor;
+using UnityEngine.TestTools;
+using NUnit.Framework;
+using System.Collections.Generic;
+using System.IO;
+using FbxExporters.Editor;
+
+namespace FbxExporters.UnitTests
+{
+    public class ConvertToModelTest
+    {
+        public static List<string> ChildNames(Transform a) {
+            var names = new List<string>();
+            foreach(Transform child in a) {
+                names.Add(child.name);
+            }
+            return names;
+        }
+
+        [Test]
+        public void TestStaticHelpers()
+        {
+            // Test IncrementFileName
+            {
+                var tempPath = Path.GetTempPath ();
+                var basename = Path.GetFileNameWithoutExtension (Path.GetRandomFileName ());
+
+                var filename1 = basename + " 1.fbx";
+                var filename2 = Path.Combine(tempPath, basename + " 2.fbx");
+                Assert.AreEqual (filename2, ConvertToModel.IncrementFileName (tempPath, filename1));
+
+                filename1 = basename + "1.fbx";
+                filename2 = Path.Combine(tempPath, basename + "2.fbx");
+                Assert.AreEqual (filename2, ConvertToModel.IncrementFileName (tempPath, filename1));
+
+                filename1 = basename + "k.fbx";
+                filename2 = Path.Combine(tempPath, basename + "k 1.fbx");
+                Assert.AreEqual (filename2, ConvertToModel.IncrementFileName (tempPath, filename1));
+            }
+
+            // Test EnforceUniqueNames
+            {
+                var a = new GameObject("a");
+                var b = new GameObject("b");
+                var a1 = new GameObject("a");
+                var a2 = new GameObject("a");
+                ConvertToModel.EnforceUniqueNames(new GameObject[] { a, b, a1, a2 });
+                Assert.AreEqual("a", a.name);
+                Assert.AreEqual("b", b.name);
+                Assert.AreEqual("a 1", a1.name);
+                Assert.AreEqual("a 2", a2.name);
+            }
+
+            // Test FixSiblingOrder
+            {
+                var a = new GameObject("a").transform;
+                var b = new GameObject("a").transform;
+
+                var a1 = new GameObject("a1").transform;
+                var a2 = new GameObject("a2").transform;
+                var a3 = new GameObject("a3").transform;
+
+                var b1 = new GameObject("a1").transform;
+                var b2 = new GameObject("a2").transform;
+                var b3 = new GameObject("a3").transform;
+
+                a1.parent = a;
+                a2.parent = a;
+                a3.parent = a;
+
+                b3.parent = b;
+                b1.parent = b;
+                b2.parent = b;
+
+                // Assert same set, different order.
+                Assert.That(ChildNames(b), Is.EquivalentTo(ChildNames(a)));
+                Assert.That(ChildNames(b), Is.Not.EqualTo(ChildNames(a)));
+
+                // Fix the sibling order. Now we have same set, same order!
+                ConvertToModel.FixSiblingOrder(a, b);
+                Assert.That(ChildNames(b), Is.EquivalentTo(ChildNames(a)));
+                Assert.That(ChildNames(b), Is.EqualTo(ChildNames(a)));
+            }
+
+            // Test CopyComponents
+            if (false){
+                var a = new GameObject("a");
+                var b = new GameObject("b");
+                a.AddComponent<BoxCollider>();
+                a.transform.localPosition += new Vector3(1,2,3);
+                Assert.IsFalse(b.GetComponent<BoxCollider>());
+                Assert.AreEqual(Vector3.zero, b.transform.localPosition);
+                ConvertToModel.CopyComponents(a, b);
+                Assert.IsTrue(b.GetComponent<BoxCollider>());
+                Assert.AreEqual(new Vector3(1,2,3), b.transform.localPosition);
+            }
+
+            // Test SetupImportedGameObject. Very similar but recursive.
+            {
+                var a = new GameObject ("a");
+                var a1 = new GameObject ("AA");
+                var a2 = new GameObject ("BB");
+                a2.transform.parent = a.transform;
+                a1.transform.parent = a.transform; // out of alpha order!
+                var b = new GameObject ("b");
+                var b1 = new GameObject ("AA");
+                var b2 = new GameObject ("BB");
+                b1.transform.parent = b.transform;
+                b2.transform.parent = b.transform; // in alpha order
+                a.AddComponent<BoxCollider> ();
+                a1.transform.localPosition = new Vector3 (1, 2, 3);
+
+                Assert.IsFalse (b.GetComponent<BoxCollider> ());
+                Assert.AreEqual ("BB", b.transform.GetChild (1).name);
+                Assert.AreEqual (Vector3.zero, b1.transform.localPosition);
+
+                ConvertToModel.SetupImportedGameObject (a, b);
+
+                Assert.IsTrue (b.GetComponent<BoxCollider> ());
+                Assert.AreEqual ("AA", b.transform.GetChild (1).name);
+                Assert.AreEqual (new Vector3 (1, 2, 3), b1.transform.localPosition);
+            }
+        }
+    }
+}