Added Singleton class with testing

Author: ashblue

Assets/AdncAnimatorHelpers/Editor/Testing/AnimatorPlayback/TestAnimatorPlayback.cs

@@ -1,7 +1,7 @@
 using Adnc.AnimatorHelpers.Conditions;
 using Adnc.AnimatorHelpers.Variables;
 using Adnc.Utility.Testing;
-using AdncAnimatorHelpers.Editor.Testing.Utilities;
+using Adnc.AnimatorHelpers.Editors.Testing.Utilities;
 using NUnit.Framework;
 using UnityEngine;
 using Object = UnityEngine.Object;

Assets/AdncAnimatorHelpers/Editor/Testing/AnimatorStub/TestAnimatorStub.cs

@@ -1,10 +1,11 @@
-using AdncAnimatorHelpers.Editor.Testing.Utilities;
+using Adnc.Utility.Testing;
+using Adnc.AnimatorHelpers.Editors.Testing.Utilities;
 using NUnit.Framework;
 using UnityEngine;
 
-namespace Adnc.AnimatorHelpers.Editors.Testing.Examples {
+namespace Adnc.AnimatorHelpers.Editors.Testing {
     [Category("Examples")]
-    public class TestAnimatorStub {
+    public class TestAnimatorStub : TestBase {
         private GameObject _go;
         private AnimatorStub _animStub;
 

Assets/AdncAnimatorHelpers/Editor/Testing/Singleton.meta

@@ -1,5 +1,108 @@
-namespace AdncAnimatorHelpers.Editor.Testing.Singleton {
-    public class TestSingleton {
-        
+using Adnc.Utility.Testing;
+using Adnc.AnimatorHelpers.Stubs;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Adnc.AnimatorHelpers.Editors.Testing {
+    public class TestSingleton : TestBase {
+        [TearDown]
+        public void ClearSingleton () {
+            SingletonStub.ClearSingleton();
+        }
+
+        [Test]
+        public void InstanceLazyLoadsWhenCalled () {
+            Assert.IsNotNull(SingletonStub.Instance);
+        }
+
+        [Test]
+        public void SingletonAlwaysReturnsSameInstance () {
+            var i = SingletonStub.Instance;
+
+            Assert.AreSame(i, SingletonStub.Instance);
+        }
+
+        [Test]
+        public void InstanceIsAutoInjectedIfComponentAlreadyExists () {
+            var stub = new GameObject("ForceLoad")
+                .AddComponent<SingletonStub>();
+
+            Assert.AreEqual(stub, SingletonStub.Instance);
+
+            Object.DestroyImmediate(stub.gameObject);
+        }
+
+        [Test]
+        public void PreMadeSingletonReturnsSameInstance () {
+            var stub = new GameObject("ForceLoad")
+                .AddComponent<SingletonStub>();
+            var i = SingletonStub.Instance;
+
+            Assert.AreSame(i, SingletonStub.Instance);
+
+            Object.DestroyImmediate(stub.gameObject);
+        }
+
+        [Test]
+        public void MultipleInstancesStillReturnsInstance () {
+            var stub1 = new GameObject("ForceLoad1")
+                .AddComponent<SingletonStub>();
+            var stub2 = new GameObject("ForceLoad2")
+                .AddComponent<SingletonStub>();
+
+            Assert.IsNotNull(SingletonStub.Instance);
+
+            Object.DestroyImmediate(stub1.gameObject);
+            Object.DestroyImmediate(stub2.gameObject);
+        }
+
+        [Test]
+        public void InstancePropertiesCanBeChangesGlobally () {
+            var prop1 = SingletonStub.Instance.globalString;
+            SingletonStub.Instance.globalString = "a";
+            var prop2 = SingletonStub.Instance.globalString;
+
+            Assert.AreNotEqual(prop1, prop2);
+        }
+
+        [Test]
+        public void ClearSingletonWipesInstance () {
+            var i = SingletonStub.Instance;
+
+            SingletonStub.ClearSingleton();
+
+            Assert.AreNotSame(i, SingletonStub.Instance);
+        }
+
+        [Test]
+        public void OnDestroyClearsInstance () {
+            var i = SingletonStub.Instance;
+
+            CallPrivateMethod(SingletonStub.Instance, "OnDestroy");
+            Object.DestroyImmediate(i.gameObject);
+
+            Assert.AreNotSame(i, SingletonStub.Instance);
+        }
+
+        [Test]
+        public void OnDestroySecondInstanceDoesNotClearInstance () {
+            var stub1 = new GameObject("ForceLoad1")
+                .AddComponent<SingletonStub>();
+            SingletonStub.Instance.globalString = "changeToCache";
+            var stub2 = new GameObject("ForceLoad2")
+                .AddComponent<SingletonStub>();
+
+            CallPrivateMethod(stub2, "OnDestroy");
+            Object.DestroyImmediate(stub2.gameObject);
+
+            Assert.AreSame(stub1, SingletonStub.Instance);
+
+            Object.DestroyImmediate(stub1.gameObject);
+        }
+
+        [Test]
+        public void LazyLoadSingletonNameMatchesComponentName () {
+            Assert.AreEqual("SingletonStub", SingletonStub.Instance.name);
+        }
     }
 }

Assets/AdncAnimatorHelpers/Editor/Testing/Singleton/TestSingleton.cs

@@ -1,7 +1,7 @@
 using UnityEditor.Animations;
 using UnityEngine;
 
-namespace AdncAnimatorHelpers.Editor.Testing.Utilities {
+namespace Adnc.AnimatorHelpers.Editors.Testing.Utilities {
     public class AnimatorStub {
         /// <summary>
         /// Reference to the Animator attached to the passed GameObject

Assets/AdncAnimatorHelpers/Editor/Testing/Utilities/AnimatorStub.cs

@@ -1,5 +1,4 @@
-namespace AdncAnimatorHelpers.Scripts.AnimatorHelperManager {
-    public class AnimatorHelperManager {
-        
+namespace Adnc.AnimatorHelpers {
+    public class AnimatorHelperManager : Singleton<AnimatorHelperManager> {
     }
 }

Assets/AdncAnimatorHelpers/Examples/Singleton.meta

@@ -1,5 +1,64 @@
-namespace Adnc.AnimatorHelpers {
-    public class Singleton {
-        
+using System.Linq;
+using UnityEngine;
+
+namespace Adnc.AnimatorHelpers {
+    // @SRC http://wiki.unity3d.com/index.php/Singleton
+    public class Singleton<T> : MonoBehaviour where T : MonoBehaviour {
+        private static T _instance;
+
+        private static string SingletonName {
+            get { return typeof(T).Name; }
+        }
+
+        public static T Instance {
+            get {
+                if (_instance != null) {
+                    return _instance;
+                }
+
+                var instances = FindObjectsOfType(typeof(T));
+                if (instances.Length >= 1) {
+                    if (Application.isPlaying) {
+                        Debug.AssertFormat(
+                            instances.Length == 1,
+                            "{1} {0} singletons detected. There should only ever be one present",
+                            SingletonName,
+                            instances.Length);
+                    }
+
+                    _instance = (T)instances[0];
+                    return _instance;
+                }
+
+                var singleton = new GameObject(SingletonName);
+                _instance = singleton.AddComponent<T>();
+
+                // Only add DontDestroyOnLoad if the user fails to manually implement the component in a scene
+                // Thereby giving the user more control over the singleton lifecycle
+                if (Application.isPlaying) {
+                    DontDestroyOnLoad(singleton);
+                }
+
+                return _instance;
+            }
+        }
+
+        protected virtual void OnDestroy () {
+            if (_instance == this) {
+                _instance = null;
+            }
+        }
+
+        /// <summary>
+        /// Test friendly method to prevent persisting singletons with editor tests
+        /// </summary>
+        public static void ClearSingleton () {
+            if (Application.isPlaying || _instance == null) {
+                return;
+            }
+
+            DestroyImmediate(_instance);
+            _instance = null;
+        }
     }
 }

Assets/AdncAnimatorHelpers/Scripts/AnimatorHelperManager.meta

@@ -1,6 +1,9 @@
 using Adnc.AnimatorHelpers;
 
-namespace Adnc.AnimatorHelpers.Editors.Testing.Stubs {
+namespace Adnc.AnimatorHelpers.Stubs {
+    /// <summary>
+    /// Testing only class
+    /// </summary>
     public class SingletonStub : Singleton<SingletonStub> {
         public string globalString = "test";
     }