Working on unit tests for fbxprefab...

Author: Benoit Hudson

Assets/FbxExporters/Editor/UnitTests/ExporterTestBase.cs

@@ -17,10 +17,11 @@ namespace FbxExporters.UnitTests
     public abstract class ExporterTestBase
     {
         /// <summary>
-        /// Sleep an amount of time (in ms) so we can safely assume that the timestamp on an fbx will change.
+        /// Sleep an amount of time (in ms) so we can safely assume that the
+        /// timestamp on an fbx will change.
         /// </summary>
         public void SleepForFileTimestamp() {
-            System.Threading.Thread.Sleep(1000);
+            System.Threading.Thread.Sleep(100);
         }
 
         private string _testDirectory;

Assets/FbxExporters/Editor/UnitTests/FbxPrefabTest.cs

@@ -12,6 +12,8 @@ public class FbxPrefabTest : ExporterTestBase
         FbxPrefab.FbxRepresentation m_originalRep;
 
         GameObject m_source; // the fbx model
+        FbxPrefab.FbxRepresentation m_originalHistory;
+
         GameObject m_autoPrefab; // prefab that auto-updates
         GameObject m_manualPrefab; // prefab that doesn't auto-update
 
@@ -49,61 +51,86 @@ void OnUpdate(FbxPrefab prefabInstance, IEnumerable<GameObject> updated)
             }
         }
 
+        static KeyValuePair<string, FbxPrefab.FbxRepresentation> StackItem(
+                string name, FbxPrefab.FbxRepresentation rep)
+        {
+            return new KeyValuePair<string, FbxPrefab.FbxRepresentation>(name, rep);
+        }
+
         public static void AssertAreIdentical(
                 FbxPrefab.FbxRepresentation a,
                 FbxPrefab.FbxRepresentation b) {
             // A bit of a laborious comparison scheme. This is due to the
             // round-trip through FBX causing tiny errors in the transforms.
-            var astack = new List<FbxPrefab.FbxRepresentation> ();
-            astack.Add(a);
-            var bstack = new List<FbxPrefab.FbxRepresentation> ();
-            bstack.Add(b);
+            var astack = new List<KeyValuePair<string, FbxPrefab.FbxRepresentation>> ();
+            astack.Add(StackItem("(root)", a));
+            var bstack = new List<KeyValuePair<string, FbxPrefab.FbxRepresentation>> ();
+            bstack.Add(StackItem("(root)", b));
 
             var aDummy = new GameObject("aDummy").transform;
             var bDummy = new GameObject("bDummy").transform;
             while (astack.Count > 0) {
                 Assert.AreEqual(astack.Count, bstack.Count); // should never fail
-                a = astack[astack.Count - 1]; astack.RemoveAt(astack.Count - 1);
-                b = bstack[bstack.Count - 1]; bstack.RemoveAt(bstack.Count - 1);
+                var aKvp = astack[astack.Count - 1]; astack.RemoveAt(astack.Count - 1);
+                var bKvp = bstack[bstack.Count - 1]; bstack.RemoveAt(bstack.Count - 1);
+
+                var aName = aKvp.Key;
+                var bName = bKvp.Key;
+                Assert.AreEqual(aName, bName);
+
+                a = aKvp.Value;
+                b = bKvp.Value;
 
                 // Verify that they have the same children (by name).
                 var achildren = a.ChildNames;
                 var bchildren = b.ChildNames;
-                Assert.That(achildren, Is.EquivalentTo(bchildren));
+                Assert.That(achildren, Is.EquivalentTo(bchildren), aName + " children");
 
-                // Add the children to each stack.
+                // Add the children to each stack. It's important to get the
+                // same order for both stacks.
                 foreach(var child in achildren) {
-                    astack.Add(a.GetChild(child));
-                    bstack.Add(b.GetChild(child));
+                    astack.Add(StackItem(child, a.GetChild(child)));
+                    bstack.Add(StackItem(child, b.GetChild(child)));
                 }
 
                 // Verify that they have the same components.
                 var atypes = a.ComponentTypes;
                 var btypes = b.ComponentTypes;
-                Assert.That(atypes, Is.EquivalentTo(btypes));
+                Assert.That(atypes, Is.EquivalentTo(btypes), aName + " component types");
 
                 foreach(var t in atypes) {
                     var avalues = a.GetComponentValues(t);
                     var bvalues = b.GetComponentValues(t);
-                    Assert.AreEqual(avalues.Count, bvalues.Count);
-
-                    if (t != "UnityEngine.Transform") {
-                        Assert.AreEqual(avalues, bvalues);
-                    } else {
+                    Assert.AreEqual(avalues.Count, bvalues.Count, aName + " component multiplicity");
+
+                    //
+                    // TODO: test that the values match up.
+                    // Exceptions:
+                    // - Transforms we expect small changes.
+                    // - MeshFilter and MeshRenderer we expect guids to change
+                    //
+                    if (t == "UnityEngine.MeshFilter") {
+                        // TODO: test that everything but the guid matches
+                    } else if (t == "UnityEngine.MeshRenderer") {
+                        // TODO: test that everything but the guid matches
+                    } else if (t == "UnityEngine.Transform") {
                         // Verify that the transforms are nearly (but don't require bitwise) equal.
                         EditorJsonUtility.FromJsonOverwrite(avalues[0], aDummy);
                         EditorJsonUtility.FromJsonOverwrite(bvalues[0], bDummy);
                         var dist = Vector3.Distance(aDummy.localPosition, bDummy.localPosition);
-                        Assert.That(dist, Is.LessThan(1e-6), () => string.Format("position {0} vs {1} dist {2}",
-                                aDummy.localPosition, bDummy.localPosition, dist));
+                        Assert.That(dist, Is.LessThan(1e-6), () => string.Format("{3}: position {0} vs {1} dist {2}",
+                                aDummy.localPosition, bDummy.localPosition, dist, aName));
 
                         dist = Vector3.Distance(aDummy.localScale, bDummy.localScale);
-                        Assert.That(dist, Is.LessThan(1e-6), () => string.Format("scale {0} vs {1} dist {2}",
-                                aDummy.localScale, bDummy.localScale, dist));
+                        Assert.That(dist, Is.LessThan(1e-6), () => string.Format("{3}: scale {0} vs {1} dist {2}",
+                                aDummy.localScale, bDummy.localScale, dist, aName));
 
                         dist = Quaternion.Angle(aDummy.localRotation, bDummy.localRotation);
-                        Assert.That(dist, Is.LessThan(1e-6), () => string.Format("rotation {0} vs {1} angle {2}",
-                                aDummy.localRotation.eulerAngles, bDummy.localRotation.eulerAngles, dist));
+                        Assert.That(dist, Is.LessThan(1e-6), () => string.Format("{3}: rotation {0} vs {1} angle {2}",
+                                aDummy.localRotation.eulerAngles, bDummy.localRotation.eulerAngles, dist, aName));
+                    } else {
+                        // Default: test that the components are precisely identical.
+                        Assert.AreEqual(avalues, bvalues, string.Format("{0}: type {1}", aName, t));
                     }
                 }
             }
@@ -126,6 +153,7 @@ public void Init() {
             var fbxAsset = FbxExporters.Editor.ModelExporter.ExportObject(
                     GetRandomFbxFilePath(), m_original);
             m_source = AssetDatabase.LoadMainAssetAtPath(fbxAsset) as GameObject;
+            m_originalHistory = Rep(m_source);
             Assert.IsTrue(m_source);
 
             // Create an FbxPrefab linked to the Fbx file. Make it auto-update.
@@ -166,7 +194,11 @@ GameObject ModifySourceFbx()
             // - add parent3
             var newModel = PrefabUtility.InstantiatePrefab(m_source) as GameObject;
             GameObject.DestroyImmediate(newModel.transform.Find("Parent1").gameObject);
-            CreateGameObject("Parent3", newModel.transform);
+            var parent3 = CreateGameObject("Parent3", newModel.transform);
+
+            // We're not doing an apply operation, so the collider isn't
+            // supposed to get to the prefab, so don't test that it does.
+            Object.DestroyImmediate(parent3.GetComponent<BoxCollider>());
 
             // Export it to clobber the old FBX file.
             // Sleep one second first to make sure the timestamp differs
@@ -183,29 +215,35 @@ GameObject ModifySourceFbx()
 
         [Test]
         public void BasicTest() {
-            // Check the history is good at the start
+            // Verify we start in the right place.
             AssertAreIdentical(m_originalRep, Rep(m_manualPrefab));
             AssertAreIdentical(m_originalRep, Rep(m_autoPrefab));
-            AssertAreIdentical(m_originalRep, History(m_manualPrefab));
-            AssertAreIdentical(m_originalRep, History(m_autoPrefab));
+
+            // Verify history is as we expect. It differs from the originalRep
+            // in that it doesn't have box colliders.
+            AssertAreIdentical(m_originalHistory, History(m_manualPrefab));
+            AssertAreIdentical(m_originalHistory, History(m_autoPrefab));
 
             FbxPrefab.FbxRepresentation newHierarchy;
+            FbxPrefab.FbxRepresentation newHistory;
             using(var updateSet = new UpdateListener(m_autoPrefab)) {
                 Debug.Log("Testing auto update");
                 newHierarchy = Rep(ModifySourceFbx());
+                newHistory = Rep(m_source);
                 AssertAreDifferent(m_originalRep, newHierarchy);
 
-                // Make sure the fbx source changed.
-                AssertAreDifferent(m_originalRep, Rep(m_source));
-                AssertAreIdentical(newHierarchy, Rep(m_source));
+                // Make sure the fbx source changed (testing the test).
+                AssertAreDifferent(m_originalHistory, Rep(m_source));
 
                 // Make sure the auto-update prefab changed.
+                Debug.Log(string.Format("source: {0}\nprefab: {1}",
+                            newHierarchy.ToJson(), Rep(m_autoPrefab).ToJson()));
                 AssertAreIdentical(newHierarchy, Rep(m_autoPrefab));
-                AssertAreIdentical(newHierarchy, History(m_autoPrefab));
+                AssertAreIdentical(newHierarchy, Rep(m_source));
 
                 // Make sure the manual-update prefab didn't.
                 AssertAreIdentical(m_originalRep, Rep(m_manualPrefab));
-                AssertAreIdentical(m_originalRep, History(m_manualPrefab));
+                AssertAreIdentical(m_originalHistory, History(m_manualPrefab));
 
                 // Make sure we got the right changes.
                 Assert.AreEqual (1, updateSet.NumUpdates);
@@ -223,7 +261,7 @@ public void BasicTest() {
             var manualPrefabComponent = m_manualPrefab.GetComponent<FbxPrefab>();
             manualPrefabComponent.SyncPrefab();
             AssertAreIdentical(newHierarchy, Rep(m_manualPrefab));
-            AssertAreIdentical(newHierarchy, History(m_manualPrefab));
+            AssertAreIdentical(newHistory, History(m_manualPrefab));
 
             // Check some corner cases.
             Assert.AreEqual(m_source, manualPrefabComponent.GetFbxAsset());
@@ -245,38 +283,44 @@ public void BasicTest() {
             Assert.That( () => manualPrefabComponent.SetSourceModel(null), Throws.Nothing );
             Assert.IsNull(manualPrefabComponent.GetFbxAsset());
             AssertAreIdentical(newHierarchy, Rep(m_manualPrefab));
-            AssertAreIdentical(newHierarchy, History(m_manualPrefab));
+            AssertAreIdentical(newHistory, History(m_manualPrefab));
             Assert.That( () => manualPrefabComponent.SyncPrefab(), Throws.Nothing );
             AssertAreIdentical(newHierarchy, Rep(m_manualPrefab));
-            AssertAreIdentical(newHierarchy, History(m_manualPrefab));
+            AssertAreIdentical(newHistory, History(m_manualPrefab));
 
             // Switch to some other model, which looks like the original model
             // (but is a totally different file). This will cause an update
-            // immediately.
+            // immediately. We expect to have lost the colliders on the objects
+            // that were deleted in the interim.
             var fbxAsset = FbxExporters.Editor.ModelExporter.ExportObject(
                     GetRandomFbxFilePath(), m_original);
             var newSource = AssetDatabase.LoadMainAssetAtPath(fbxAsset) as GameObject;
             Assert.IsTrue(newSource);
             Debug.Log("Testing SetSourceModel relink");
             manualPrefabComponent.SetSourceModel(newSource);
             AssertAreIdentical(m_originalRep, Rep(m_manualPrefab));
-            AssertAreIdentical(m_originalRep, History(m_manualPrefab));
+            AssertAreIdentical(m_originalHistory, History(m_manualPrefab));
         }
 
         [Test]
         public void ManualToAuto() {
             // Check what happens when we go from manual to auto-update.
+            Debug.Log("ManualToAuto: modifying source");
             var newHierarchy = Rep(ModifySourceFbx());
+            var newHistory = Rep(m_source);
+
             AssertAreIdentical(m_originalRep, Rep(m_manualPrefab));
-            AssertAreIdentical(m_originalRep, History(m_manualPrefab));
+            AssertAreIdentical(m_originalHistory, History(m_manualPrefab));
 
+            Debug.Log("ManualToAuto: setting manual to manual");
             m_manualPrefab.GetComponent<FbxPrefab>().SetAutoUpdate(false);
             AssertAreIdentical(m_originalRep, Rep(m_manualPrefab));
-            AssertAreIdentical(m_originalRep, History(m_manualPrefab));
+            AssertAreIdentical(m_originalHistory, History(m_manualPrefab));
 
+            Debug.Log("ManualToAuto: setting manual to auto");
             m_manualPrefab.GetComponent<FbxPrefab>().SetAutoUpdate(true);
             AssertAreIdentical(newHierarchy, Rep(m_manualPrefab));
-            AssertAreIdentical(newHierarchy, History(m_manualPrefab));
+            AssertAreIdentical(newHistory, History(m_manualPrefab));
         }
     }