Initial commit

Assets/Scripts/Tests/Objects/ObjectLifetimeTests.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Collections;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+using Assert = UnityEngine.Assertions.Assert;
+
+namespace BracerLib.Tests.Objects
+{
+    public class ObjectLifetimeTests : TestBase
+    {
+        private class SomeDisposable : IDisposable
+        {
+            public bool IsDisposed { get; private set; }
+
+            public void Dispose()
+            {
+                if (IsDisposed)
+                    return;
+
+                IsDisposed = true;
+
+                GC.SuppressFinalize(this);
+            }
+        }
+
+        private SomeDisposable disposableObject;
+        private SomeDisposable disposableFuncObject;
+        private GameObject singleTestLifetimeObject;
+        private GameObject singleTestLifetimeFuncObject;
+        private GameObject completeTestLifetimeObject;
+        private GameObject completeTestLifetimeFuncObject;
+        private bool singleTestWasCreated;
+
+        [UnityTest, Order(1)]
+        public IEnumerator SetUpOneTimeObjects()
+        {
+            completeTestLifetimeObject = new GameObject("full lifetime");
+            RegisterOneTimeTestObject(completeTestLifetimeObject);
+
+            yield return null;
+            Assert.IsTrue(completeTestLifetimeObject != null);
+
+            completeTestLifetimeFuncObject = RegisterOneTimeTestObject(GetNewObject);
+
+            yield return null;
+            Assert.IsTrue(completeTestLifetimeFuncObject != null);
+        }
+
+        /// <summary>
+        /// Not here to test Unity code, but want to run through a basic shift of the object position.
+        /// </summary>
+        [UnityTest, Order(2)]
+        public IEnumerator TempUnityObjectMovesCorrectly()
+        {
+            Assert.IsFalse(singleTestWasCreated);
+
+            singleTestLifetimeObject = new GameObject("singleTestLifetime");
+            RegisterTempTestObject(singleTestLifetimeObject);
+            singleTestLifetimeFuncObject = RegisterTempTestObject(GetNewObject);
+            singleTestWasCreated = true;
+
+            Assert.IsTrue(singleTestWasCreated);
+
+            yield return null;
+
+            var testTransform = singleTestLifetimeObject.transform;
+            var tPos = testTransform.position;
+            var lastPos = tPos;
+            tPos = Vector3.one;
+            testTransform.position = tPos;
+
+            Assert.IsTrue(tPos != lastPos);
+
+            testTransform.Translate(Vector3.up);
+
+            yield return null;
+
+            tPos = testTransform.position;
+
+            Assert.IsTrue(tPos != lastPos);
+        }
+
+        [UnityTest, Order(3)]
+        public IEnumerator TempUnityObjectNoLongerExistsAfterPreviousTest()
+        {
+            Assert.IsTrue(singleTestWasCreated);
+            Assert.IsNull(singleTestLifetimeObject);
+            Assert.IsNull(singleTestLifetimeFuncObject);
+            yield return null;
+        }
+
+        [UnityTest, Order(4)]
+        public IEnumerator OneTimeObjectStillExists()
+        {
+            Assert.IsTrue(completeTestLifetimeObject != null);
+            Assert.IsTrue(completeTestLifetimeFuncObject != null);
+            yield return null;
+        }
+
+        [Test, Order(5)]
+        public void RegisterDisposableObject()
+        {
+            disposableObject = new SomeDisposable();
+            RegisterDisposableTempTestObject(disposableObject);
+            Assert.IsNotNull(disposableObject);
+            Assert.IsFalse(disposableObject.IsDisposed);
+
+            disposableFuncObject = RegisterDisposableTempTestObject(() => new SomeDisposable());
+            Assert.IsNotNull(disposableFuncObject);
+            Assert.IsFalse(disposableFuncObject.IsDisposed);
+        }
+
+        [Test, Order(6)]
+        public void CheckIfDisposableObjectHasDisposed()
+        {
+            Assert.IsNotNull(disposableObject);
+            Assert.IsTrue(disposableObject.IsDisposed);
+
+            disposableObject = null;
+
+            Assert.IsNotNull(disposableFuncObject);
+            Assert.IsTrue(disposableFuncObject.IsDisposed);
+
+            disposableObject = null;
+        }
+
+        private GameObject GetNewObject() => new GameObject();
+    }
+}

Assets/Scripts/Tests/Objects/ObjectLifetimeTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 78520c491186453a91097eac4579ed75
+timeCreated: 1778931474

Assets/Scripts/Tests/Objects/ObjectMockTests.cs

@@ -0,0 +1,55 @@
+using System.Collections;
+using Moq;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace BracerLib.Tests.Objects
+{
+    public interface ITester
+    {
+        void Test();
+    }
+
+    public class Tester : ITester
+    {
+        public void Test() {}
+    }
+
+    public class MockComponent : MonoBehaviour
+    {
+        private ITester tester;
+
+        public void DoTest()
+        {
+            tester.Test();
+        }
+    }
+
+    public class ObjectMockTests : TestBase
+    {
+        private MockComponent mockComponent;
+        private Mock<ITester> testerMock;
+
+        protected override IEnumerator UnityOneTimeSetUp()
+        {
+            testerMock = new Mock<ITester>();
+
+            var go = new GameObject("mock test obj");
+            mockComponent = go.AddComponent<MockComponent>();
+            RegisterOneTimeTestObject(go);
+            SetReflectedValue(mockComponent, "tester", testerMock.Object);
+
+            yield return null;
+        }
+
+        [Test]
+        public void TestMock()
+        {
+            testerMock.Setup(x => x.Test());
+
+            mockComponent.DoTest();
+
+            testerMock.Verify(x => x.Test(), Times.Once);
+        }
+    }
+}

Assets/Scripts/Tests/Objects/ObjectMockTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 45e688432fb9423e8efb7c88cdbd9785
+timeCreated: 1779762115