Initial commit

2026-06-02 18:57:47 -04:00
commit 59d26a915d
268 changed files with 41240 additions and 0 deletions
@@ -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();
+    }
+}