[Test] Add unit tests for base code

Assets/Tests/EditMode/PickupItemDataTests.cs

@@ -0,0 +1,198 @@
+using NUnit.Framework;
+using UnityEngine;
+using System.Collections.Generic;
+
+namespace Tests.EditMode
+{
+    public class PickupItemDataTests
+    {
+        private PickupItemData item1;
+        private PickupItemData item2;
+        private PickupItemData item3;
+
+        [SetUp]
+        public void SetUp()
+        {
+            // Create test instances using ScriptableObject.CreateInstance
+            item1 = ScriptableObject.CreateInstance<PickupItemData>();
+            item1.itemName = "Apple";
+            item1.description = "A red fruit";
+
+            item2 = ScriptableObject.CreateInstance<PickupItemData>();
+            item2.itemName = "Apple";
+            item2.description = "A different description"; // Different description but same name
+
+            item3 = ScriptableObject.CreateInstance<PickupItemData>();
+            item3.itemName = "Orange";
+            item3.description = "A citrus fruit";
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            // Clean up created ScriptableObjects
+            if (item1 != null) Object.DestroyImmediate(item1);
+            if (item2 != null) Object.DestroyImmediate(item2);
+            if (item3 != null) Object.DestroyImmediate(item3);
+        }
+
+        #region AreEquivalent Tests
+
+        [Test]
+        public void AreEquivalent_SameReference_ReturnsTrue()
+        {
+            // Arrange
+            var item = item1;
+
+            // Act
+            bool result = PickupItemData.AreEquivalent(item, item);
+
+            // Assert
+            Assert.IsTrue(result, "Same reference should be equivalent");
+        }
+
+        [Test]
+        public void AreEquivalent_SameItemName_ReturnsTrue()
+        {
+            // Arrange - item1 and item2 have the same itemName but different descriptions
+
+            // Act
+            bool result = PickupItemData.AreEquivalent(item1, item2);
+
+            // Assert
+            Assert.IsTrue(result, "Items with the same itemName should be equivalent");
+        }
+
+        [Test]
+        public void AreEquivalent_DifferentItemName_ReturnsFalse()
+        {
+            // Arrange - item1 and item3 have different itemNames
+
+            // Act
+            bool result = PickupItemData.AreEquivalent(item1, item3);
+
+            // Assert
+            Assert.IsFalse(result, "Items with different itemName should not be equivalent");
+        }
+
+        [Test]
+        public void AreEquivalent_FirstItemNull_ReturnsFalse()
+        {
+            // Arrange
+
+            // Act
+            bool result = PickupItemData.AreEquivalent(null, item1);
+
+            // Assert
+            Assert.IsFalse(result, "Null item should not be equivalent to a non-null item");
+        }
+
+        [Test]
+        public void AreEquivalent_SecondItemNull_ReturnsFalse()
+        {
+            // Arrange
+
+            // Act
+            bool result = PickupItemData.AreEquivalent(item1, null);
+
+            // Assert
+            Assert.IsFalse(result, "Non-null item should not be equivalent to a null item");
+        }
+
+        [Test]
+        public void AreEquivalent_BothItemsNull_ReturnsTrue()
+        {
+            // Arrange
+
+            // Act
+            bool result = PickupItemData.AreEquivalent(null, null);
+
+            // Assert
+            Assert.IsTrue(result, "Two null items should be equivalent (ReferenceEquals)");
+        }
+
+        #endregion
+
+        #region ListContainsEquivalent Tests
+
+        [Test]
+        public void ListContainsEquivalent_EmptyList_ReturnsFalse()
+        {
+            // Arrange
+            var list = new List<PickupItemData>();
+
+            // Act
+            bool result = PickupItemData.ListContainsEquivalent(list, item1);
+
+            // Assert
+            Assert.IsFalse(result, "Empty list should not contain any item");
+        }
+
+        [Test]
+        public void ListContainsEquivalent_ListContainsSameReference_ReturnsTrue()
+        {
+            // Arrange
+            var list = new List<PickupItemData> { item1 };
+
+            // Act
+            bool result = PickupItemData.ListContainsEquivalent(list, item1);
+
+            // Assert
+            Assert.IsTrue(result, "List should contain the same reference");
+        }
+
+        [Test]
+        public void ListContainsEquivalent_ListContainsEquivalentItem_ReturnsTrue()
+        {
+            // Arrange - item1 and item2 have the same itemName but are different instances
+            var list = new List<PickupItemData> { item1 };
+
+            // Act
+            bool result = PickupItemData.ListContainsEquivalent(list, item2);
+
+            // Assert
+            Assert.IsTrue(result, "List should contain an equivalent item with the same itemName");
+        }
+
+        [Test]
+        public void ListContainsEquivalent_ListDoesNotContainEquivalentItem_ReturnsFalse()
+        {
+            // Arrange - item1 and item3 have different itemNames
+            var list = new List<PickupItemData> { item1 };
+
+            // Act
+            bool result = PickupItemData.ListContainsEquivalent(list, item3);
+
+            // Assert
+            Assert.IsFalse(result, "List should not contain an item with a different itemName");
+        }
+
+        [Test]
+        public void ListContainsEquivalent_SearchForNullInNonEmptyList_ReturnsFalse()
+        {
+            // Arrange
+            var list = new List<PickupItemData> { item1, item2 };
+
+            // Act
+            bool result = PickupItemData.ListContainsEquivalent(list, null);
+
+            // Assert
+            Assert.IsFalse(result, "List should not contain a null item");
+        }
+
+        [Test]
+        public void ListContainsEquivalent_SearchInListWithNull_HandlesNullGracefully()
+        {
+            // Arrange
+            var list = new List<PickupItemData> { item1, null, item3 };
+
+            // Act
+            bool result = PickupItemData.ListContainsEquivalent(list, item2);
+
+            // Assert
+            Assert.IsTrue(result, "List with null element should still find equivalent item");
+        }
+
+        #endregion
+    }
+}