com.wallstop-studios.unity-helpers 1.0.0-rc9 → 1.0.1-rc02

package/Tests/Runtime/Extensions/DictionaryExtensionTests.cs

@@ -0,0 +1,419 @@
+namespace UnityHelpers.Tests.Extensions
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Core.Extension;
+    using NUnit.Framework;
+
+    public sealed class DictionaryExtensionTests
+    {
+        [Test]
+        public void GetOrAddValueProducer()
+        {
+            Dictionary<string, int> dictionary = new();
+            int value = dictionary.GetOrAdd("test", () => 100);
+            Assert.AreEqual(100, value);
+            Assert.AreEqual(value, dictionary["test"]);
+
+            int newValue = dictionary.GetOrAdd(
+                "test", () =>
+                {
+                    Assert.Fail("Value Producer should not have been called!");
+                    return 200;
+                });
+            Assert.AreEqual(100, newValue);
+
+            newValue = dictionary.GetOrAdd("test2", () => 300);
+            Assert.AreEqual(300, newValue);
+            Assert.AreEqual(100, dictionary["test"]);
+        }
+
+        [Test]
+        public void GetOrAddKeyValueProducer()
+        {
+            Dictionary<string, int> dictionary = new();
+            int value = dictionary.GetOrAdd(
+                "test", key =>
+                {
+                    Assert.AreEqual("test", key);
+                    return 100;
+                });
+            Assert.AreEqual(100, value);
+            Assert.AreEqual(value, dictionary["test"]);
+
+            int newValue = dictionary.GetOrAdd(
+                "test", key =>
+                {
+                    Assert.Fail("Value Producer should not have been called!");
+                    return 200;
+                });
+            Assert.AreEqual(100, newValue);
+
+            newValue = dictionary.GetOrAdd(
+                "test2", key =>
+                {
+                    Assert.AreEqual("test2", key);
+                    return 300;
+                });
+            Assert.AreEqual(300, newValue);
+            Assert.AreEqual(100, dictionary["test"]);
+        }
+
+        [Test]
+        public void GetOrElseValue()
+        {
+            Dictionary<string, int> dictionary = new();
+            int value = dictionary.GetOrElse("test", 100);
+            Assert.AreEqual(100, value);
+            Assert.IsFalse(dictionary.ContainsKey("test"));
+            dictionary["test"] = 150;
+            value = dictionary.GetOrElse("test", 100);
+            Assert.AreEqual(150, value);
+            Assert.AreEqual(150, dictionary["test"]);
+        }
+
+        [Test]
+        public void GetOrElseValueProducer()
+        {
+            Dictionary<string, int> dictionary = new();
+            int value = dictionary.GetOrElse("test", () => 100);
+            Assert.AreEqual(100, value);
+            Assert.IsFalse(dictionary.ContainsKey("test"));
+            dictionary["test"] = 150;
+            value = dictionary.GetOrElse(
+                "test", () =>
+                {
+                    Assert.Fail("Producer should not be called.");
+                    return 100;
+                });
+            Assert.AreEqual(150, value);
+            Assert.AreEqual(150, dictionary["test"]);
+        }
+
+        [Test]
+        public void GetOrElseKeyValueProducer()
+        {
+            Dictionary<string, int> dictionary = new();
+            int value = dictionary.GetOrElse(
+                "test", key =>
+                {
+                    Assert.AreEqual("test", key);
+                    return 100;
+                });
+            Assert.AreEqual(100, value);
+            Assert.IsFalse(dictionary.ContainsKey("test"));
+            dictionary["test"] = 150;
+            value = dictionary.GetOrElse(
+                "test", () =>
+                {
+                    Assert.Fail("Producer should not be called.");
+                    return 100;
+                });
+            Assert.AreEqual(150, value);
+            Assert.AreEqual(150, dictionary["test"]);
+        }
+
+        [Test]
+        public void GetOrAddNew()
+        {
+            Dictionary<string, List<int>> dictionary = new();
+            List<int> value = dictionary.GetOrAdd("test");
+            Assert.IsNotNull(value);
+            Assert.AreEqual(value, dictionary["test"]);
+            value.Add(1);
+
+            List<int> newValue = dictionary.GetOrAdd("test");
+            Assert.AreEqual(value, newValue);
+        }
+
+        [Test]
+        public void GetOrElse()
+        {
+            IReadOnlyDictionary<string, int> dictionary = new Dictionary<string, int>();
+            int value = dictionary.GetOrElse("test", 100);
+            Assert.AreEqual(100, value);
+            Assert.AreEqual(0, dictionary.Count);
+        }
+
+        [Test]
+        public void AddOrUpdate()
+        {
+            Dictionary<string, int> dictionary = new();
+            int value = dictionary.AddOrUpdate("test", key => 100, (key, existing) => existing + 1);
+            Assert.AreEqual(100, value);
+            Assert.AreEqual(100, dictionary["test"]);
+            int expected = value;
+            for (int i = 0; i < 100; ++i)
+            {
+                value = dictionary.AddOrUpdate("test", key => 100, (key, existing) => existing + 1);
+                Assert.AreEqual(++expected, value);
+                Assert.AreEqual(value, dictionary["test"]);
+            }
+
+            value = dictionary.AddOrUpdate("test2", key => 150, (key, existing) => existing + 1);
+            Assert.AreEqual(150, value);
+            Assert.AreEqual(150, dictionary["test2"]);
+            Assert.AreEqual(expected, dictionary["test"]);
+        }
+
+        [Test]
+        public void TryAdd()
+        {
+            Dictionary<string, int> dictionary = new();
+            int value = dictionary.TryAdd(
+                "test", key =>
+                {
+                    Assert.AreEqual("test", key);
+                    return 150;
+                });
+            Assert.AreEqual(150, value);
+            Assert.AreEqual(value, dictionary["test"]);
+
+            value = dictionary.TryAdd(
+                "test", key =>
+                {
+                    Assert.Fail("Creator should not have been called.");
+                    return 200;
+                });
+            Assert.AreEqual(150, value);
+            Assert.AreEqual(value, dictionary["test"]);
+
+            value = dictionary.TryAdd(
+                "test2", key =>
+                {
+                    Assert.AreEqual("test2", key);
+                    return 350;
+                });
+            Assert.AreEqual(350, value);
+            Assert.AreEqual(value, dictionary["test2"]);
+            Assert.AreEqual(150, dictionary["test"]);
+        }
+
+        [Test]
+        public void Merge()
+        {
+            IReadOnlyDictionary<string, int> left = new Dictionary<string, int>()
+            {
+                ["only-on-left"] = 1,
+                ["both"] = 1,
+            };
+
+            IReadOnlyDictionary<string, int> right = new Dictionary<string, int>()
+            {
+                ["only-on-right"] = 3,
+                ["both"] = 2,
+            };
+
+            Dictionary<string, int> merged = left.Merge(right);
+            Assert.AreEqual(3, merged.Count);
+            Assert.AreEqual(1, merged["only-on-left"]);
+            Assert.AreEqual(2, merged["both"]);
+            Assert.AreEqual(3, merged["only-on-right"]);
+
+            merged = right.Merge(left);
+            Assert.AreEqual(3, merged.Count);
+            Assert.AreEqual(1, merged["only-on-left"]);
+            Assert.AreEqual(1, merged["both"]);
+            Assert.AreEqual(3, merged["only-on-right"]);
+
+            merged = left.Merge(left);
+            Assert.AreEqual(2, merged.Count);
+            Assert.AreEqual(1, merged["only-on-left"]);
+            Assert.AreEqual(1, merged["both"]);
+
+            merged = right.Merge(right);
+            Assert.AreEqual(2, merged.Count);
+            Assert.AreEqual(3, merged["only-on-right"]);
+            Assert.AreEqual(2, merged["both"]);
+        }
+
+        [Test]
+        public void Difference()
+        {
+            IReadOnlyDictionary<string, int> left = new Dictionary<string, int>()
+            {
+                ["only-on-left"] = 1,
+                ["both"] = 1,
+            };
+
+            IReadOnlyDictionary<string, int> right = new Dictionary<string, int>()
+            {
+                ["only-on-right"] = 3,
+                ["both"] = 2,
+            };
+
+            Dictionary<string, int> difference = left.Difference(right);
+            Assert.AreEqual(2, difference.Count);
+            Assert.AreEqual(2, difference["both"]);
+            Assert.AreEqual(3, difference["only-on-right"]);
+
+            difference = right.Difference(left);
+            Assert.AreEqual(2, difference.Count);
+            Assert.AreEqual(1, difference["both"]);
+            Assert.AreEqual(1, difference["only-on-left"]);
+
+            difference = left.Difference(left);
+            Assert.AreEqual(0, difference.Count);
+
+            difference = right.Difference(right);
+            Assert.AreEqual(0, difference.Count);
+        }
+
+        [Test]
+        public void Reverse()
+        {
+            IReadOnlyDictionary<string, int> initial = new Dictionary<string, int>()
+            {
+                ["one"] = 1,
+                ["one-duplicate"] = 1,
+                ["two"] = 2,
+                ["three"] = 3,
+            };
+
+            Dictionary<int, string> reversed = initial.Reverse();
+            Assert.AreEqual(3, reversed.Count);
+            Assert.AreEqual("one-duplicate", reversed[1]);
+            Assert.AreEqual("two", reversed[2]);
+            Assert.AreEqual("three", reversed[3]);
+        }
+
+        [Test]
+        public void ToDictionaryFromDictionary()
+        {
+            IReadOnlyDictionary<string, int> initial = new Dictionary<string, int>()
+            {
+                ["test"] = 1,
+                ["test2"] = 2,
+            };
+
+            Dictionary<string, int> copy = initial.ToDictionary();
+            Assert.AreEqual(2, copy.Count);
+            Assert.AreEqual(1, copy["test"]);
+            Assert.AreEqual(2, copy["test2"]);
+        }
+
+        [Test]
+        public void ToDictionaryFromEnumerableKeyValuePair()
+        {
+            IEnumerable<KeyValuePair<string, int>> initial = new Dictionary<string, int>()
+            {
+                ["test"] = 1,
+                ["test2"] = 2,
+            };
+
+            Dictionary<string, int> copy = initial.ToDictionary();
+            Assert.AreEqual(2, copy.Count);
+            Assert.AreEqual(1, copy["test"]);
+            Assert.AreEqual(2, copy["test2"]);
+        }
+
+        [Test]
+        public void ToDictionaryFromEnumerableValueTuple()
+        {
+            IEnumerable<(string, int)> initial = new Dictionary<string, int>()
+            {
+                ["test"] = 1,
+                ["test2"] = 2,
+            }.Select(kvp => (kvp.Key, kvp.Value));
+
+            Dictionary<string, int> copy = initial.ToDictionary();
+            Assert.AreEqual(2, copy.Count);
+            Assert.AreEqual(1, copy["test"]);
+            Assert.AreEqual(2, copy["test2"]);
+        }
+
+        [Test]
+        public void ContentEqualsSame()
+        {
+            IReadOnlyDictionary<string, int> left = new Dictionary<string, int>()
+            {
+                ["one"] = 1,
+                ["two"] = 2,
+            };
+
+            IReadOnlyDictionary<string, int> right = new Dictionary<string, int>()
+            {
+                ["one"] = 1,
+                ["two"] = 2,
+            };
+
+            Assert.IsTrue(left.ContentEquals(right));
+            Assert.IsTrue(left.ContentEquals(left));
+            Assert.IsTrue(right.ContentEquals(left));
+            Assert.IsTrue(right.ContentEquals(right));
+        }
+
+        [Test]
+        public void ContentEqualsDifferentCount()
+        {
+            IReadOnlyDictionary<string, int> left = new Dictionary<string, int>()
+            {
+                ["one"] = 1,
+                ["two"] = 2,
+            };
+
+            IReadOnlyDictionary<string, int> right = new Dictionary<string, int>()
+            {
+                ["one"] = 1,
+                ["two"] = 2,
+                ["three"] = 3,
+            };
+
+            Assert.IsFalse(left.ContentEquals(right));
+            Assert.IsTrue(left.ContentEquals(left));
+            Assert.IsFalse(right.ContentEquals(left));
+            Assert.IsTrue(right.ContentEquals(right));
+        }
+
+        [Test]
+        public void ContentEqualsDifferentValuesSameSize()
+        {
+            IReadOnlyDictionary<string, int> left = new Dictionary<string, int>()
+            {
+                ["one"] = 1,
+                ["two"] = 2,
+            };
+
+            IReadOnlyDictionary<string, int> right = new Dictionary<string, int>()
+            {
+                ["one"] = 1,
+                ["two"] = 20_000,
+            };
+
+            Assert.IsFalse(left.ContentEquals(right));
+            Assert.IsTrue(left.ContentEquals(left));
+            Assert.IsFalse(right.ContentEquals(left));
+            Assert.IsTrue(right.ContentEquals(right));
+        }
+
+        [Test]
+        public void ContentEqualsDifferentKeysSameSize()
+        {
+            IReadOnlyDictionary<string, int> left = new Dictionary<string, int>()
+            {
+                ["one"] = 1,
+                ["two"] = 2,
+            };
+
+            IReadOnlyDictionary<string, int> right = new Dictionary<string, int>()
+            {
+                ["one"] = 1,
+                ["three"] = 2,
+            };
+
+            Assert.IsFalse(left.ContentEquals(right));
+            Assert.IsTrue(left.ContentEquals(left));
+            Assert.IsFalse(right.ContentEquals(left));
+            Assert.IsTrue(right.ContentEquals(right));
+        }
+
+        [Test]
+        public void Deconstruct()
+        {
+            new KeyValuePair<string, int>("one", 1).Deconstruct(out string key, out int value);
+            Assert.AreEqual("one", key);
+            Assert.AreEqual(1, value);
+        }
+    }
+}

package/Tests/Runtime/Extensions/DictionaryExtensionTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 31368b65c8f54bed82bc38001ab86cba
+timeCreated: 1720405525

package/Tests/Runtime/Extensions/StringExtensionTests.cs

@@ -3,7 +3,7 @@
     using Core.Extension;
     using NUnit.Framework;
 
-    public class StringExtensionTests
+    public sealed class StringExtensionTests
     {
         [Test]
         public void ToPascalCaseNominal()