diff --git a/.github/workflows/build-test-publish.yml b/.github/workflows/build-test-publish.yml
index 12dcd08..712e622 100644
--- a/.github/workflows/build-test-publish.yml
+++ b/.github/workflows/build-test-publish.yml
@@ -45,11 +45,13 @@ jobs:
       - name: Build Debug
         run: dotnet build -c Debug R4Utils
       - name: Create Name
-        run: echo "SUFFIX=dev.$(tr /- .. <<<$GITHUB_REF).${GITHUB_RUN_ID}" >> $GITHUB_ENV
+        run: |
+          export RAW_SUFFIX="dev.$(tr /- .. <<<$GITHUB_REF)"
+          echo "SUFFIX=${RAW_SUFFIX:0:44}.${GITHUB_RUN_ID}" >> $GITHUB_ENV
       - name: Pack
         run: dotnet pack --no-build --no-dependencies -c Debug -p:PackageId=R4UtilsDev --version-suffix $SUFFIX
       - name: Push
-        run: dotnet nuget push R4Utils/bin/Debug/R4UtilsDev.1.2.0-$SUFFIX.nupkg --source https://api.nuget.org/v3/index.json --api-key ${{ secrets.NUGET_API_KEY }} --skip-duplicate
+        run: dotnet nuget push R4Utils/bin/Debug/R4UtilsDev.1.2.1-$SUFFIX.nupkg --source https://api.nuget.org/v3/index.json --api-key ${{ secrets.NUGET_API_KEY }} --skip-duplicate
         
   publish-pre:
     runs-on: ubuntu-latest
@@ -73,7 +75,7 @@ jobs:
       - name: Pack
         run: dotnet pack -c Release --no-build --no-dependencies --version-suffix $SUFFIX
       - name: Push
-        run: dotnet nuget push R4Utils/bin/Release/R4Utils.1.2.0-$SUFFIX.nupkg --source https://api.nuget.org/v3/index.json --api-key ${{ secrets.NUGET_API_KEY }} --skip-duplicate
+        run: dotnet nuget push R4Utils/bin/Release/R4Utils.1.2.1-$SUFFIX.nupkg --source https://api.nuget.org/v3/index.json --api-key ${{ secrets.NUGET_API_KEY }} --skip-duplicate
         
   publish-production:
     runs-on: ubuntu-latest
@@ -95,4 +97,4 @@ jobs:
       - name: Pack
         run: dotnet pack -c Release --no-build --no-dependencies
       - name: Push
-        run: dotnet nuget push R4Utils/bin/Release/R4Utils.1.2.0.nupkg --source https://api.nuget.org/v3/index.json --api-key ${{ secrets.NUGET_API_KEY }} --skip-duplicate
+        run: dotnet nuget push R4Utils/bin/Release/R4Utils.1.2.1.nupkg --source https://api.nuget.org/v3/index.json --api-key ${{ secrets.NUGET_API_KEY }} --skip-duplicate
diff --git a/R4Utils/R4Utils.csproj b/R4Utils/R4Utils.csproj
index ffd9c75..7051670 100644
--- a/R4Utils/R4Utils.csproj
+++ b/R4Utils/R4Utils.csproj
@@ -5,7 +5,7 @@
         <Nullable>enable</Nullable>
         <ImplicitUsings>enable</ImplicitUsings>
         <PackageId>R4Utils</PackageId>
-        <VersionPrefix>1.2.0</VersionPrefix>
+        <VersionPrefix>1.2.1</VersionPrefix>
         <Authors>Ronto4</Authors>
         <LangVersion>13</LangVersion>
         <RepositoryUrl>https://github.com/Ronto4/R4Utils</RepositoryUrl>
diff --git a/R4Utils/ValueEqualityCollections/Extensions.cs b/R4Utils/ValueEqualityCollections/Extensions.cs
index dfb6161..bfc63cf 100644
--- a/R4Utils/ValueEqualityCollections/Extensions.cs
+++ b/R4Utils/ValueEqualityCollections/Extensions.cs
@@ -18,4 +18,25 @@ public static ValueEqualityCollection<T> AsOrderedValueEqualityCollection<T>(thi
     /// </summary>
     public static ValueEqualityCollection<T> AsValueEqualityCollection<T>(this ICollection<T> collection)
         where T : IEquatable<T> => new(collection, ValueEqualityCollection<T>.OrderMode.Ignore);
+
+    /// <summary>
+    /// Transform this collection into a collection that performs value equality on its items for deducing collection equality.
+    /// <br/><br/>
+    /// The resulting will consider ordering whenever compared to another instance also considering ordering.
+    /// </summary>
+    public static ValueEqualityCollection<T, TCollection>
+        AsGenericOrderedValueEqualityCollection<T, TCollection>(this TCollection collection)
+        where T : IEquatable<T> where TCollection : IList<T> =>
+        new(collection, ValueEqualityCollection<T, TCollection>.OrderMode.Consider);
+
+    /// <summary>
+    /// Transform this collection into a collection that performs value equality on its items for deducing collection equality.
+    /// <br/><br/>
+    /// As the underlying <paramref name="collection"/> does not support ordering (does not inherit <see cref="IList{T}"/>),
+    /// the resulting <see cref="ValueEqualityCollection{T}"/> will ignore ordering whenever it is compared.
+    /// </summary>
+    public static ValueEqualityCollection<T, TCollection>
+        AsGenericValueEqualityCollection<T, TCollection>(this TCollection collection)
+        where T : IEquatable<T> where TCollection : ICollection<T> =>
+        new(collection, ValueEqualityCollection<T, TCollection>.OrderMode.Ignore);
 }
diff --git a/R4Utils/ValueEqualityCollections/ValueEqualityCollection.cs b/R4Utils/ValueEqualityCollections/ValueEqualityCollection.cs
index c7e2a64..3b0a89f 100644
--- a/R4Utils/ValueEqualityCollections/ValueEqualityCollection.cs
+++ b/R4Utils/ValueEqualityCollections/ValueEqualityCollection.cs
@@ -3,6 +3,37 @@
 
 namespace R4Utils.ValueEqualityCollections;
 
+file static class Helpers
+{
+    // Source: https://stackoverflow.com/a/3670089/13849454
+    public static bool ScrambledEquals<T>(ICollection<T> collection1, ICollection<T> collection2) where T : notnull
+    {
+        var cnt = new Dictionary<T, int>();
+        // ReSharper disable once ForeachCanBePartlyConvertedToQueryUsingAnotherGetEnumerator
+        foreach (var s in collection1)
+        {
+            if (!cnt.TryAdd(s, 1))
+            {
+                cnt[s]++;
+            }
+        }
+
+        foreach (var s in collection2)
+        {
+            if (cnt.TryGetValue(s, out var value))
+            {
+                cnt[s] = --value;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        return cnt.Values.All(c => c == 0);
+    }
+}
+
 /// <summary>
 /// A wrapper around an <see cref="ICollection{T}"/> that uses value equality of its elements for equality of the collections.
 /// </summary>
@@ -73,40 +104,11 @@ private bool EqualityDispatch(ValueEqualityCollection<T> other)
             return OrderedEquality(list1, list2);
         }
 
-        return ScrambledEquals(Collection, other.Collection);
+        return Helpers.ScrambledEquals(Collection, other.Collection);
     }
 
     private static bool OrderedEquality(IList<T> list1, IList<T> list2) => list1.SequenceEqual(list2);
 
-    // Source: https://stackoverflow.com/a/3670089/13849454
-    private static bool ScrambledEquals(ICollection<T> collection1, ICollection<T> collection2)
-    {
-        var cnt = new Dictionary<T, int>();
-        // ReSharper disable once ForeachCanBePartlyConvertedToQueryUsingAnotherGetEnumerator
-        foreach (var s in collection1)
-        {
-            if (!cnt.TryAdd(s, 1))
-            {
-                cnt[s]++;
-            }
-        }
-
-        foreach (var s in collection2)
-        {
-            if (cnt.TryGetValue(s, out var value))
-            {
-                cnt[s] = --value;
-            }
-            else
-            {
-                return false;
-            }
-        }
-
-        return cnt.Values.All(c => c == 0);
-    }
-
-
     // ICollection<T> implementation
 
     public IEnumerator<T> GetEnumerator() => Collection.GetEnumerator();
@@ -119,7 +121,7 @@ public override bool Equals(object? obj)
     }
 
     // TODO: Look into this, this might in fact be wrong.
-    public override int GetHashCode() => Collection.Aggregate(0, HashCode.Combine);
+    public override int GetHashCode() => HashCode.Combine(Collection.Aggregate(0, HashCode.Combine), Ordering);
 
     public void Add(T item) => Collection.Add(item);
 
@@ -135,3 +137,104 @@ public override bool Equals(object? obj)
 
     public bool IsReadOnly => Collection.IsReadOnly;
 }
+
+/// <summary>
+/// A wrapper around a <typeparamref name="TCollection"/> that uses value equality of its elements for equality of the collections.
+/// </summary>
+public class ValueEqualityCollection<T, TCollection> : ICollection<T>,
+    IEquatable<ValueEqualityCollection<T, TCollection>>,
+    IEqualityOperators<ValueEqualityCollection<T, TCollection>, ValueEqualityCollection<T, TCollection>, bool>
+    where T : IEquatable<T> where TCollection : ICollection<T>
+{
+    public override bool Equals(object? obj)
+    {
+        if (obj is null) return false;
+        if (ReferenceEquals(this, obj)) return true;
+        if (obj.GetType() != GetType()) return false;
+        return Equals((ValueEqualityCollection<T, TCollection>)obj);
+    }
+
+    // TODO: Look into this, this might in fact be wrong.
+    public override int GetHashCode() => HashCode.Combine(Underlying.Aggregate(0, HashCode.Combine), Ordering);
+
+    /// <summary>
+    /// Defines strategies of dealing with ordering when comparing two instances.
+    /// </summary>
+    public enum OrderMode
+    {
+        /// <summary>
+        /// Consider ordering when comparing this instance with another one.
+        /// </summary>
+        Consider,
+
+        /// <summary>
+        /// Ignore ordering when comparing this instance with another one.
+        /// <br/><br/>
+        /// If any of the compared instances has this set, the ordering will be ignored.
+        /// </summary>
+        Ignore,
+    }
+
+    /// <summary>
+    /// The collection used to create this instance.
+    /// </summary>
+    public TCollection Underlying { get; }
+
+    /// <summary>
+    /// Whether to consider ordering when comparing this instance with another one.
+    /// <br/><br/>
+    /// This is always <see cref="OrderMode.Ignore"/> unless <typeparamref name="TCollection"/> inherits <see cref="IList{T}"/>.
+    /// </summary>
+    public OrderMode Ordering { get; }
+
+    internal ValueEqualityCollection(TCollection underlying, OrderMode ordering)
+    {
+        Underlying = underlying;
+        Ordering = underlying is IList<T> ? ordering : OrderMode.Ignore;
+    }
+
+    // Equality
+    public bool Equals(ValueEqualityCollection<T, TCollection>? other)
+    {
+        if (other is null) return false;
+        return ReferenceEquals(this, other) || EqualityDispatch(other);
+    }
+
+    private bool EqualityDispatch(ValueEqualityCollection<T, TCollection> other)
+    {
+        if (Ordering is OrderMode.Consider && other.Ordering is OrderMode.Consider && Underlying is IList<T> list1 &&
+            other.Underlying is IList<T> list2)
+        {
+            return OrderedEquality(list1, list2);
+        }
+
+        return Helpers.ScrambledEquals(Underlying, other.Underlying);
+    }
+
+    private static bool OrderedEquality(IList<T> list1, IList<T> list2) => list1.SequenceEqual(list2);
+
+    public static bool operator ==(ValueEqualityCollection<T, TCollection>? left,
+        ValueEqualityCollection<T, TCollection>? right) => right?.Equals(left) ?? left is null;
+
+    public static bool operator !=(ValueEqualityCollection<T, TCollection>? left,
+        ValueEqualityCollection<T, TCollection>? right) => !(left == right);
+
+    // Collection
+    public IEnumerator<T> GetEnumerator() => Underlying.GetEnumerator();
+
+    IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable)Underlying).GetEnumerator();
+
+    public void Add(T item) => Underlying.Add(item);
+
+    public void Clear() => Underlying.Clear();
+
+    public bool Contains(T item) => Underlying.Contains(item);
+
+    public void CopyTo(T[] array, int arrayIndex) => Underlying.CopyTo(array, arrayIndex);
+
+    public bool Remove(T item) => Underlying.Remove(item);
+
+    public int Count => Underlying.Count;
+
+    public bool IsReadOnly => Underlying.IsReadOnly;
+}
diff --git a/R4UtilsTester/ValueEqualityCollections/TestValueEqualityCollection.cs b/R4UtilsTester/ValueEqualityCollections/TestValueEqualityCollection.cs
index c108f99..2ee87e4 100644
--- a/R4UtilsTester/ValueEqualityCollections/TestValueEqualityCollection.cs
+++ b/R4UtilsTester/ValueEqualityCollections/TestValueEqualityCollection.cs
@@ -8,136 +8,278 @@ namespace R4UtilsTester.ValueEqualityCollections;
 [TestFixture]
 public class TestValueEqualityCollection
 {
-    private static void AssertEqual<T>(ValueEqualityCollection<T> wrapper1, ValueEqualityCollection<T> wrapper2,
-        bool unequal = false) where T : IEquatable<T>
+    public class NonGeneric
     {
-        if (unequal)
+        private static void AssertEqual<T>(ValueEqualityCollection<T> wrapper1, ValueEqualityCollection<T> wrapper2,
+            bool unequal = false) where T : IEquatable<T>
         {
-            Assert.AreNotEqual(wrapper1, wrapper2);
-            Assert.IsFalse(wrapper1.Equals(wrapper2));
-            Assert.IsFalse(wrapper1 == wrapper2);
-            Assert.IsTrue(wrapper1 != wrapper2);
+            if (unequal)
+            {
+                Assert.AreNotEqual(wrapper1, wrapper2);
+                Assert.IsFalse(wrapper1.Equals(wrapper2));
+                Assert.IsFalse(wrapper1 == wrapper2);
+                Assert.IsTrue(wrapper1 != wrapper2);
+            }
+            else
+            {
+                Assert.AreEqual(wrapper1, wrapper2);
+                Assert.IsTrue(wrapper1.Equals(wrapper2));
+                Assert.IsTrue(wrapper1 == wrapper2);
+                Assert.IsFalse(wrapper1 != wrapper2);
+            }
         }
-        else
+
+        [Test]
+        public void TestEqualArraysEqual()
         {
-            Assert.AreEqual(wrapper1, wrapper2);
-            Assert.IsTrue(wrapper1.Equals(wrapper2));
-            Assert.IsTrue(wrapper1 == wrapper2);
-            Assert.IsFalse(wrapper1 != wrapper2);
+            int[] data1 = [1, 2, 3];
+            int[] data2 = [1, 2, 3];
+            var wrapper1 = data1.AsOrderedValueEqualityCollection();
+            var wrapper2 = data2.AsOrderedValueEqualityCollection();
+            AssertEqual(wrapper1, wrapper2);
         }
-    }
-
-    [Test]
-    public void TestEqualArraysEqual()
-    {
-        int[] data1 = [1, 2, 3];
-        int[] data2 = [1, 2, 3];
-        var wrapper1 = data1.AsOrderedValueEqualityCollection();
-        var wrapper2 = data2.AsOrderedValueEqualityCollection();
-        AssertEqual(wrapper1, wrapper2);
-    }
 
-    [Test]
-    public void TestConsidersOrderingOfElements()
-    {
-        int[] data1 = [1, 2, 3];
-        int[] data2 = [2, 1, 3];
-        var wrapper1 = data1.AsOrderedValueEqualityCollection();
-        var wrapper2 = data2.AsOrderedValueEqualityCollection();
-        AssertEqual(wrapper1, wrapper2, true);
-    }
+        [Test]
+        public void TestConsidersOrderingOfElements()
+        {
+            int[] data1 = [1, 2, 3];
+            int[] data2 = [2, 1, 3];
+            var wrapper1 = data1.AsOrderedValueEqualityCollection();
+            var wrapper2 = data2.AsOrderedValueEqualityCollection();
+            AssertEqual(wrapper1, wrapper2, true);
+        }
 
-    [Test]
-    public void TestHandlesSetsCorrectly()
-    {
-        HashSet<int> data1 = [1, 2, 3];
-        HashSet<int> data2 = [2, 1, 3];
-        var wrapper1 = data1.AsValueEqualityCollection();
-        var wrapper2 = data2.AsValueEqualityCollection();
-        AssertEqual(wrapper1, wrapper2);
-    }
+        [Test]
+        public void TestHandlesSetsCorrectly()
+        {
+            HashSet<int> data1 = [1, 2, 3];
+            HashSet<int> data2 = [2, 1, 3];
+            var wrapper1 = data1.AsValueEqualityCollection();
+            var wrapper2 = data2.AsValueEqualityCollection();
+            AssertEqual(wrapper1, wrapper2);
+        }
 
-    [Test]
-    public void TestHandlesSetsMixedWithArraysCorrectly()
-    {
-        HashSet<int> data1 = [1, 2, 3];
-        int[] data2 = [2, 1, 3];
-        var wrapper1 = data1.AsValueEqualityCollection();
-        var wrapper2 = data2.AsOrderedValueEqualityCollection();
-        AssertEqual(wrapper1, wrapper2);
-    }
+        [Test]
+        public void TestHandlesSetsMixedWithArraysCorrectly()
+        {
+            HashSet<int> data1 = [1, 2, 3];
+            int[] data2 = [2, 1, 3];
+            var wrapper1 = data1.AsValueEqualityCollection();
+            var wrapper2 = data2.AsOrderedValueEqualityCollection();
+            AssertEqual(wrapper1, wrapper2);
+        }
 
-    [Test]
-    public void TestIgnoreOrdering()
-    {
-        bool[] bools = [true, false];
-        foreach (var data1IgnoreOrdering in bools)
+        [Test]
+        public void TestIgnoreOrdering()
         {
-            foreach (var data2IgnoreOrdering in bools)
+            bool[] bools = [true, false];
+            foreach (var data1IgnoreOrdering in bools)
             {
-                int[] data1 = [1, 2, 3];
-                int[] data2 = [2, 1, 3];
-                var wrapper1 = data1IgnoreOrdering
-                    ? data1.AsValueEqualityCollection()
-                    : data1.AsOrderedValueEqualityCollection();
-                var wrapper2 = data2IgnoreOrdering
-                    ? data2.AsValueEqualityCollection()
-                    : data2.AsOrderedValueEqualityCollection();
-                Assert.AreEqual(wrapper1.Ordering,
-                    data1IgnoreOrdering
-                        ? ValueEqualityCollection<int>.OrderMode.Ignore
-                        : ValueEqualityCollection<int>.OrderMode.Consider);
-                Assert.AreEqual(wrapper2.Ordering,
-                    data2IgnoreOrdering
-                        ? ValueEqualityCollection<int>.OrderMode.Ignore
-                        : ValueEqualityCollection<int>.OrderMode.Consider);
-                if (data1IgnoreOrdering || data2IgnoreOrdering)
+                foreach (var data2IgnoreOrdering in bools)
                 {
-                    AssertEqual(wrapper1, wrapper2);
+                    int[] data1 = [1, 2, 3];
+                    int[] data2 = [2, 1, 3];
+                    var wrapper1 = data1IgnoreOrdering
+                        ? data1.AsValueEqualityCollection()
+                        : data1.AsOrderedValueEqualityCollection();
+                    var wrapper2 = data2IgnoreOrdering
+                        ? data2.AsValueEqualityCollection()
+                        : data2.AsOrderedValueEqualityCollection();
+                    Assert.AreEqual(wrapper1.Ordering,
+                        data1IgnoreOrdering
+                            ? ValueEqualityCollection<int>.OrderMode.Ignore
+                            : ValueEqualityCollection<int>.OrderMode.Consider);
+                    Assert.AreEqual(wrapper2.Ordering,
+                        data2IgnoreOrdering
+                            ? ValueEqualityCollection<int>.OrderMode.Ignore
+                            : ValueEqualityCollection<int>.OrderMode.Consider);
+                    if (data1IgnoreOrdering || data2IgnoreOrdering)
+                    {
+                        AssertEqual(wrapper1, wrapper2);
+                    }
+                    else
+                    {
+                        AssertEqual(wrapper1, wrapper2, true);
+                    }
                 }
-                else
+            }
+        }
+
+        [Test]
+        public void TestRecursiveWrapper()
+        {
+            HashSet<int> data1 = [1, 2, 3];
+            int[] data2 = [2, 1, 3];
+            var wrapper1 = data1.AsValueEqualityCollection().AsValueEqualityCollection();
+            var wrapper2 = data2.AsOrderedValueEqualityCollection();
+            AssertEqual(wrapper1, wrapper2);
+        }
+
+        [Test]
+        public void TestDuplicateElements()
+        {
+            bool[] bools = [true, false];
+            foreach (var data1IgnoreOrdering in bools)
+            {
+                foreach (var data2IgnoreOrdering in bools)
                 {
+                    int[] data1 = [1, 2, 3];
+                    int[] data2 = [1, 2, 3, 3];
+                    var wrapper1 = data1IgnoreOrdering
+                        ? data1.AsValueEqualityCollection()
+                        : data1.AsOrderedValueEqualityCollection();
+                    var wrapper2 = data2IgnoreOrdering
+                        ? data2.AsValueEqualityCollection()
+                        : data2.AsOrderedValueEqualityCollection();
+                    Assert.AreEqual(wrapper1.Ordering,
+                        data1IgnoreOrdering
+                            ? ValueEqualityCollection<int>.OrderMode.Ignore
+                            : ValueEqualityCollection<int>.OrderMode.Consider);
+                    Assert.AreEqual(wrapper2.Ordering,
+                        data2IgnoreOrdering
+                            ? ValueEqualityCollection<int>.OrderMode.Ignore
+                            : ValueEqualityCollection<int>.OrderMode.Consider);
                     AssertEqual(wrapper1, wrapper2, true);
                 }
             }
         }
     }
 
-    [Test]
-    public void TestRecursiveWrapper()
+    public class Generic
     {
-        HashSet<int> data1 = [1, 2, 3];
-        int[] data2 = [2, 1, 3];
-        var wrapper1 = data1.AsValueEqualityCollection().AsValueEqualityCollection();
-        var wrapper2 = data2.AsOrderedValueEqualityCollection();
-        AssertEqual(wrapper1, wrapper2);
-    }
+        private static void AssertEqual<T, TCollection>(ValueEqualityCollection<T, TCollection> wrapper1,
+            ValueEqualityCollection<T, TCollection> wrapper2,
+            bool unequal = false) where T : IEquatable<T> where TCollection : ICollection<T>
+        {
+            if (unequal)
+            {
+                Assert.AreNotEqual(wrapper1, wrapper2);
+                Assert.IsFalse(wrapper1.Equals(wrapper2));
+                Assert.IsFalse(wrapper1 == wrapper2);
+                Assert.IsTrue(wrapper1 != wrapper2);
+            }
+            else
+            {
+                Assert.AreEqual(wrapper1, wrapper2);
+                Assert.IsTrue(wrapper1.Equals(wrapper2));
+                Assert.IsTrue(wrapper1 == wrapper2);
+                Assert.IsFalse(wrapper1 != wrapper2);
+            }
+        }
 
-    [Test]
-    public void TestDuplicateElements()
-    {
-        bool[] bools = [true, false];
-        foreach (var data1IgnoreOrdering in bools)
+        [Test]
+        public void TestEqualArraysEqual()
+        {
+            int[] data1 = [1, 2, 3];
+            int[] data2 = [1, 2, 3];
+            var wrapper1 = data1.AsGenericOrderedValueEqualityCollection<int, int[]>();
+            var wrapper2 = data2.AsGenericOrderedValueEqualityCollection<int, int[]>();
+            AssertEqual(wrapper1, wrapper2);
+        }
+
+        [Test]
+        public void TestConsidersOrderingOfElements()
+        {
+            int[] data1 = [1, 2, 3];
+            int[] data2 = [2, 1, 3];
+            var wrapper1 = data1.AsGenericOrderedValueEqualityCollection<int, int[]>();
+            var wrapper2 = data2.AsGenericOrderedValueEqualityCollection<int, int[]>();
+            AssertEqual(wrapper1, wrapper2, true);
+        }
+
+        [Test]
+        public void TestHandlesSetsCorrectly()
         {
-            foreach (var data2IgnoreOrdering in bools)
+            HashSet<int> data1 = [1, 2, 3];
+            HashSet<int> data2 = [2, 1, 3];
+            var wrapper1 = data1.AsGenericValueEqualityCollection<int, HashSet<int>>();
+            var wrapper2 = data2.AsGenericValueEqualityCollection<int, HashSet<int>>();
+            AssertEqual(wrapper1, wrapper2);
+        }
+
+        [Test]
+        public void TestHandlesSetsMixedWithArraysCorrectly()
+        {
+            HashSet<int> data1 = [1, 2, 3];
+            int[] data2 = [2, 1, 3];
+            var wrapper1 = data1.AsGenericValueEqualityCollection<int, ICollection<int>>();
+            var wrapper2 = data2.AsGenericValueEqualityCollection<int, ICollection<int>>();
+            AssertEqual(wrapper1, wrapper2);
+        }
+
+        [Test]
+        public void TestIgnoreOrdering()
+        {
+            bool[] bools = [true, false];
+            foreach (var data1IgnoreOrdering in bools)
             {
-                int[] data1 = [1, 2, 3];
-                int[] data2 = [1, 2, 3, 3];
-                var wrapper1 = data1IgnoreOrdering
-                    ? data1.AsValueEqualityCollection()
-                    : data1.AsOrderedValueEqualityCollection();
-                var wrapper2 = data2IgnoreOrdering
-                    ? data2.AsValueEqualityCollection()
-                    : data2.AsOrderedValueEqualityCollection();
-                Assert.AreEqual(wrapper1.Ordering,
-                    data1IgnoreOrdering
-                        ? ValueEqualityCollection<int>.OrderMode.Ignore
-                        : ValueEqualityCollection<int>.OrderMode.Consider);
-                Assert.AreEqual(wrapper2.Ordering,
-                    data2IgnoreOrdering
-                        ? ValueEqualityCollection<int>.OrderMode.Ignore
-                        : ValueEqualityCollection<int>.OrderMode.Consider);
-                AssertEqual(wrapper1, wrapper2, true);
+                foreach (var data2IgnoreOrdering in bools)
+                {
+                    int[] data1 = [1, 2, 3];
+                    int[] data2 = [2, 1, 3];
+                    var wrapper1 = data1IgnoreOrdering
+                        ? data1.AsGenericValueEqualityCollection<int, int[]>()
+                        : data1.AsGenericOrderedValueEqualityCollection<int, int[]>();
+                    var wrapper2 = data2IgnoreOrdering
+                        ? data2.AsGenericValueEqualityCollection<int, int[]>()
+                        : data2.AsGenericOrderedValueEqualityCollection<int, int[]>();
+                    Assert.AreEqual(wrapper1.Ordering,
+                        data1IgnoreOrdering
+                            ? ValueEqualityCollection<int, int[]>.OrderMode.Ignore
+                            : ValueEqualityCollection<int, int[]>.OrderMode.Consider);
+                    Assert.AreEqual(wrapper2.Ordering,
+                        data2IgnoreOrdering
+                            ? ValueEqualityCollection<int, int[]>.OrderMode.Ignore
+                            : ValueEqualityCollection<int, int[]>.OrderMode.Consider);
+                    if (data1IgnoreOrdering || data2IgnoreOrdering)
+                    {
+                        AssertEqual(wrapper1, wrapper2);
+                    }
+                    else
+                    {
+                        AssertEqual(wrapper1, wrapper2, true);
+                    }
+                }
+            }
+        }
+
+        [Test]
+        public void TestRecursiveWrapper()
+        {
+            HashSet<int> data1 = [1, 2, 3];
+            int[] data2 = [2, 1, 3];
+            var wrapper1 = data1.AsGenericValueEqualityCollection<int, ICollection<int>>()
+                .AsGenericValueEqualityCollection<int, ICollection<int>>();
+            var wrapper2 = data2.AsGenericValueEqualityCollection<int, ICollection<int>>();
+            AssertEqual(wrapper1, wrapper2);
+        }
+
+        [Test]
+        public void TestDuplicateElements()
+        {
+            bool[] bools = [true, false];
+            foreach (var data1IgnoreOrdering in bools)
+            {
+                foreach (var data2IgnoreOrdering in bools)
+                {
+                    int[] data1 = [1, 2, 3];
+                    int[] data2 = [1, 2, 3, 3];
+                    var wrapper1 = data1IgnoreOrdering
+                        ? data1.AsGenericValueEqualityCollection<int, int[]>()
+                        : data1.AsGenericOrderedValueEqualityCollection<int, int[]>();
+                    var wrapper2 = data2IgnoreOrdering
+                        ? data2.AsGenericValueEqualityCollection<int, int[]>()
+                        : data2.AsGenericOrderedValueEqualityCollection<int, int[]>();
+                    Assert.AreEqual(wrapper1.Ordering,
+                        data1IgnoreOrdering
+                            ? ValueEqualityCollection<int, int[]>.OrderMode.Ignore
+                            : ValueEqualityCollection<int, int[]>.OrderMode.Consider);
+                    Assert.AreEqual(wrapper2.Ordering,
+                        data2IgnoreOrdering
+                            ? ValueEqualityCollection<int, int[]>.OrderMode.Ignore
+                            : ValueEqualityCollection<int, int[]>.OrderMode.Consider);
+                    AssertEqual(wrapper1, wrapper2, true);
+                }
             }
         }
     }