diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ArrayEqualityComparer/EqualityComparerTestsFactory.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ArrayEqualityComparer/EqualityComparerTestsFactory.cs
new file mode 100644
index 0000000..33603cb
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ArrayEqualityComparer/EqualityComparerTestsFactory.cs
@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ArrayEqualityComparer;
+
+public static class EqualityComparerTestsFactory
+{
+    private static Type ComparerType => typeof(ArrayEqualityComparer<object>);
+
+    [Theory]
+    [MemberData(nameof(Test_Factory_ExpectItemComparer_Cases))]
+    public static void Test_Factory_ExpectItemComparer(ArrayEqualityComparer<object> comparer, object expectedItemComparer)
+        =>
+        FactoryTestHelper.AssertItemComparerMatch(ComparerType, comparer, expectedItemComparer);
+
+    public static IEnumerable<object[]> Test_Factory_ExpectItemComparer_Cases()
+    {
+        yield return new object[]
+        {
+            ArrayEqualityComparer<object>.Default,
+            EqualityComparer<object>.Default
+        };
+        yield return new object[]
+        {
+            ArrayEqualityComparer<object>.Create(),
+            EqualityComparer<object>.Default
+        };
+        yield return new object[]
+        {
+            ArrayEqualityComparer<object>.Create(null),
+            EqualityComparer<object>.Default
+        };
+        yield return new object[]
+        {
+            ArrayEqualityComparer<object>.Create(EqualityComparer<object>.Default),
+            EqualityComparer<object>.Default
+        };
+        yield return new object[]
+        {
+            ArrayEqualityComparer<object>.Create(CustomEqualityComparer<object>.Default),
+            CustomEqualityComparer<object>.Default
+        };
+    }
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ArrayEqualityComparer/EqualityComparerTestsGeneral.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ArrayEqualityComparer/EqualityComparerTestsGeneral.cs
new file mode 100644
index 0000000..da39029
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ArrayEqualityComparer/EqualityComparerTestsGeneral.cs
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ArrayEqualityComparer;
+
+public static class EqualityComparerTestsGeneral
+{
+    private static readonly ArrayEqualityComparer<object> comparer
+        = ArrayEqualityComparer<object>.Create(CustomEqualityComparer<object>.Default);
+
+    [Fact]
+    public static void Test_GetHashCode_SourceIsNull_ExpectZero()
+    {
+        object[]? nullObj = null;
+        var actual = comparer.GetHashCode(nullObj);
+        Assert.StrictEqual(0, actual);
+    }
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ArrayEqualityComparer/EqualityComparerTestsRef.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ArrayEqualityComparer/EqualityComparerTestsRef.cs
new file mode 100644
index 0000000..d8d0c3e
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ArrayEqualityComparer/EqualityComparerTestsRef.cs
@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ArrayEqualityComparer;
+
+public static class EqualityComparerTestsRef
+{
+    private static readonly ArrayEqualityComparer<string?> comparer
+        = ArrayEqualityComparer<string?>.Create(CustomEqualityComparer<string?>.Default);
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_GetHashCode_SourceAreEqual_ExpectHashCodesAreEqual(CaseParamOfArray<string?> source1, CaseParamOfArray<string?> source2)
+    {
+        var hashCode1 = comparer.GetHashCode(source1.Items);
+        var hashCode2 = comparer.GetHashCode(source2.Items);
+        Assert.StrictEqual(hashCode1, hashCode2);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_Equals_SourceAreEqual_ExpectTrue(CaseParamOfArray<string?> source1, CaseParamOfArray<string?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.True(actualEquals);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreNotEqualCases))]
+    public static void Test_Equals_SourceAreNotEqual_ExpectTrue(CaseParamOfArray<string?> source1, CaseParamOfArray<string?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.False(actualEquals);
+    }
+
+    public static IEnumerable<object[]> SourceAreEqualCases()
+        =>
+        CaseSourcesArrayRef.SourceAreEqualCases();
+
+    public static IEnumerable<object[]> SourceAreNotEqualCases()
+        =>
+        CaseSourcesArrayRef.SourceAreNotEqualCases();
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ArrayEqualityComparer/EqualityComparerTestsStruct.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ArrayEqualityComparer/EqualityComparerTestsStruct.cs
new file mode 100644
index 0000000..595de32
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ArrayEqualityComparer/EqualityComparerTestsStruct.cs
@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ArrayEqualityComparer;
+
+public static class EqualityComparerTestsStruct 
+{
+    private static readonly ArrayEqualityComparer<int?> comparer
+        = ArrayEqualityComparer<int?>.Create(CustomEqualityComparer<int?>.Default);
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_GetHashCode_SourceAreEqual_ExpectHashCodesAreEqual(CaseParamOfArray<int?> source1, CaseParamOfArray<int?> source2)
+    {
+        var hashCode1 = comparer.GetHashCode(source1.Items);
+        var hashCode2 = comparer.GetHashCode(source2.Items);
+        Assert.StrictEqual(hashCode1, hashCode2);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_Equals_SourceAreEqual_ExpectTrue(CaseParamOfArray<int?> source1, CaseParamOfArray<int?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.True(actualEquals);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreNotEqualCases))]
+    public static void Test_Equals_SourceAreNotEqual_ExpectTrue(CaseParamOfArray<int?> source1, CaseParamOfArray<int?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.False(actualEquals);
+    }
+
+    public static IEnumerable<object[]> SourceAreEqualCases()
+        =>
+        CaseSourcesArrayStruct.SourceAreEqualCases();
+
+    public static IEnumerable<object[]> SourceAreNotEqualCases()
+        =>
+        CaseSourcesArrayStruct.SourceAreNotEqualCases();
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CaseMapper.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CaseMapper.cs
new file mode 100644
index 0000000..4fd5048
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CaseMapper.cs
@@ -0,0 +1,70 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests;
+
+internal static class CaseMapper
+{
+    internal static CaseParamOfIReadOnlyList<T>[] MapToOfIReadOnlyList<T>(params CaseParamOfArray<T>[] @case)
+        =>
+        @case.Select(param => CaseParamMapper.MapToOfIReadOnlyList(param)).ToArray();
+
+    internal static CaseParamOfIList<T>[] MapToOfIList<T>(params CaseParamOfArray<T>[] @case)
+        =>
+        @case.Select(param => CaseParamMapper.MapToOfIList(param)).ToArray();
+
+    internal static CaseParamOfList<T>[] MapToOfList<T>(params CaseParamOfArray<T>[] @case)
+    {
+        var defaultEmpty = new List<T>(); // the empty per case
+        return @case.Select(param => CaseParamMapper.MapToOfList(param, () => defaultEmpty)).ToArray();
+    }
+
+    internal static CaseParamOfImmutableArray<T>[] MapToOfImmutableArray<T>(params CaseParamOfArray<T>[] @case)
+        =>
+        @case.Select(param => CaseParamMapper.MapToOfImmutableArray(param)).ToArray();
+
+    internal static IEnumerable<CaseParamOfImmutableArrayNullable<T>[]> MapToOfImmutableArrayNullable<T>(
+        params CaseParamOfArray<T>[] @case)
+    {
+        var param0 = @case[0];
+        var param1 = @case[1];
+
+        yield return new[]
+        {
+            CaseParamMapper.MapToOfImmutableArrayNullable(param0),
+            CaseParamMapper.MapToOfImmutableArrayNullable(param1)
+        };
+
+        switch (param0.Items, param1.Items)
+        {
+            case (null, null):
+                yield return new[]
+                {
+                    BuildWrappedDefaultCase(),
+                    BuildWrappedDefaultCase()
+                };
+                yield break;
+
+            case (null, _):
+                yield return new[]
+                {
+                    BuildWrappedDefaultCase(),
+                    CaseParamMapper.MapToOfImmutableArrayNullable(param1)
+                };
+                yield break;
+
+            case (_, null):
+                yield return new[]
+                {
+                    CaseParamMapper.MapToOfImmutableArrayNullable(param0),
+                    BuildWrappedDefaultCase()
+                };
+                yield break;
+        }
+
+        static CaseParamOfImmutableArrayNullable<T> BuildWrappedDefaultCase()
+            =>
+            new(new ImmutableArray<T>?(default));
+    }
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CaseParam.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CaseParam.cs
new file mode 100644
index 0000000..1b64cbe
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CaseParam.cs
@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests;
+
+// This classes in intended to make xUnit not to merge test cases of collections equal by value.
+// There is a difference between the test cases with collections equal by value and by reference.
+
+public sealed record class CaseParamOfArray<T>(T[]? Items);
+
+public sealed record class CaseParamOfIReadOnlyList<T>(IReadOnlyList<T>? Items);
+
+public sealed record class CaseParamOfIList<T>(IList<T>? Items);
+
+public sealed record class CaseParamOfList<T>(List<T>? Items);
+
+public sealed record class CaseParamOfImmutableArray<T>(ImmutableArray<T> Items);
+
+public sealed record class CaseParamOfImmutableArrayNullable<T>(ImmutableArray<T>? Items);
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CaseParamMapper.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CaseParamMapper.cs
new file mode 100644
index 0000000..95ece67
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CaseParamMapper.cs
@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests;
+
+internal static class CaseParamMapper
+{
+    internal static CaseParamOfIReadOnlyList<T> MapToOfIReadOnlyList<T>(CaseParamOfArray<T> param)
+        =>
+        new(InnerMapCase(
+            param.Items,
+            () => null,
+            () => CustomReadOnlyList<T>.Empty,
+            items => new CustomReadOnlyList<T>(items)));
+
+    internal static CaseParamOfIList<T> MapToOfIList<T>(CaseParamOfArray<T> param)
+        =>
+        new(InnerMapCase(
+            param.Items,
+            () => null,
+            () => CustomList<T>.Empty,
+            items => new CustomList<T>(items)));
+
+    internal static CaseParamOfList<T> MapToOfList<T>(CaseParamOfArray<T> param, Func<List<T>> defaultEmptySupplier)
+        =>
+        new(InnerMapCase(
+            param.Items,
+            () => null,
+            defaultEmptySupplier,
+            items => new List<T>(items)));
+
+    internal static CaseParamOfImmutableArray<T> MapToOfImmutableArray<T>(CaseParamOfArray<T> param)
+        =>
+        new(InnerMapCase(
+            param.Items,
+            () => default,
+            () => ImmutableArray<T>.Empty,
+            items => ImmutableArray.Create(items)));
+
+    internal static CaseParamOfImmutableArrayNullable<T> MapToOfImmutableArrayNullable<T>(CaseParamOfArray<T> param)
+        =>
+        new(InnerMapCase(
+            param.Items,
+            () => default(ImmutableArray<T>?),
+            () => ImmutableArray<T>.Empty,
+            items => ImmutableArray.Create(items)));
+
+    private static TResult? InnerMapCase<T, TResult>(
+        T[]? items,
+        Func<TResult?> nullSupplier,
+        Func<TResult> defaultEmptySupplier,
+        Func<T[], TResult> map)
+        =>
+        items switch
+        {
+            null => nullSupplier.Invoke(),
+            _ when ReferenceEquals(items, EmptyArray<T>.Value) => defaultEmptySupplier.Invoke(),
+            _ => map.Invoke(items)
+        };
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CaseSourcesArrayRef.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CaseSourcesArrayRef.cs
new file mode 100644
index 0000000..8d2d4d0
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CaseSourcesArrayRef.cs
@@ -0,0 +1,172 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests;
+
+internal static class CaseSourcesArrayRef
+{
+    internal static IEnumerable<CaseParamOfArray<string?>[]> SourceAreEqualCases()
+        =>
+        InnerSourceAreEqualCases().Select(InnerMapCase);
+
+    internal static IEnumerable<CaseParamOfArray<string?>[]> SourceAreNotEqualCases()
+        =>
+        InnerSourceAreNotEqualCases().Select(InnerMapCase);
+
+    private static CaseParamOfArray<string?>[] InnerMapCase(string?[]?[] @case)
+        =>
+        @case.Select(caseParam => new CaseParamOfArray<string?>(caseParam)).ToArray();
+
+    private static IEnumerable<string?[]?[]> InnerSourceAreEqualCases()
+    {
+        yield return new string[]?[]
+        {
+            null,
+            null,
+        };
+        yield return new[]
+        {
+            EmptyArray<string>.Value,
+            EmptyArray<string>.Value,
+        };
+        yield return new[]
+        {
+            EmptyArray<string>.Create(),
+            EmptyArray<string>.Create(),
+        };
+        yield return new[]
+        {
+            new[] { (string?)null },
+            new[] { (string?)null },
+        };
+        yield return new[]
+        {
+            new[] { "1" },
+            new[] { "1" },
+        };
+        yield return new[]
+        {
+            new[] { "1", "2" },
+            new[] { "1", "2" },
+        };
+        yield return new[]
+        {
+            new[] { "1", "2", "3" },
+            new[] { "1", "2", "3" },
+        };
+        yield return new[]
+        {
+            new[] { "1", "2", "3", "4" },
+            new[] { "1", "2", "3", "4" },
+        };
+
+        var array1 = new[] { "1" };
+        var array2 = new[] { "1", "2" };
+        var array3 = new[] { "1", "2", "3" };
+        var array4 = new[] { "1", "2", "3", "4" };
+        yield return new[]
+        {
+            array1,
+            array1,
+        };
+        yield return new[]
+        {
+            array2,
+            array2,
+        };
+        yield return new[]
+        {
+            array3,
+            array3,
+        };
+        yield return new[]
+        {
+            array4,
+            array4,
+        };
+    }
+
+    private static IEnumerable<string?[]?[]> InnerSourceAreNotEqualCases()
+    {
+        yield return new[]
+        {
+            null,
+            new[] { "1" },
+        };
+        yield return new[]
+        {
+            new[] { "1" },
+            null,
+        };
+        yield return new[]
+        {
+            EmptyArray<string>.Value,
+            new[] { "1" },
+        };
+        yield return new[]
+        {
+            new[] { "1" },
+            EmptyArray<string>.Value,
+        };
+        yield return new[]
+        {
+            new[] { "1" },
+            new[] { "1", "2" },
+        };
+        yield return new[]
+        {
+            new[] { "1", "2" },
+            new[] { "1" },
+        };
+        yield return new[]
+        {
+            new[] { "1", "2" },
+            new[] { "1", "2", "3" },
+        };
+        yield return new[]
+        {
+            new[] { "1", "2", "3" },
+            new[] { "1", "2" },
+        };
+        yield return new[]
+        {
+            new[] { "1", "2", "3" },
+            new[] { "1", "2", "3", "4" },
+        };
+        yield return new[]
+        {
+            new[] { "1", "2", "3", "4" },
+            new[] { "1", "2", "3" },
+        };
+        yield return new[]
+        {
+            new[] { (string?)null },
+            new[] { "1" },
+        };
+        yield return new[]
+        {
+            new[] { "1" },
+            new[] { (string?)null },
+        };
+        yield return new[]
+        {
+            new[] { "1", "2", "3", "3" },
+            new[] { "1", "2", "3", "4" },
+        };
+        yield return new[]
+        {
+            new[] { "1", "2", "2", "4" },
+            new[] { "1", "2", "3", "4" },
+        };
+        yield return new[]
+        {
+            new[] { "1", "1", "3", "4" },
+            new[] { "1", "2", "3", "4" },
+        };
+        yield return new[]
+        {
+            new[] { "0", "2", "3", "4" },
+            new[] { "1", "2", "3", "4" },
+        };
+    }
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CaseSourcesArrayStruct.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CaseSourcesArrayStruct.cs
new file mode 100644
index 0000000..fc8f38c
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CaseSourcesArrayStruct.cs
@@ -0,0 +1,172 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests;
+
+internal static class CaseSourcesArrayStruct
+{
+    public static IEnumerable<CaseParamOfArray<int?>[]> SourceAreEqualCases()
+        =>
+        InnerSourceAreEqualCases().Select(InnerMapCase);
+
+    public static IEnumerable<CaseParamOfArray<int?>[]> SourceAreNotEqualCases()
+        =>
+        InnerSourceAreNotEqualCases().Select(InnerMapCase);
+
+    private static CaseParamOfArray<int?>[] InnerMapCase(int?[]?[] @case)
+        =>
+        @case.Select(caseParam => new CaseParamOfArray<int?>(caseParam)).ToArray();
+
+    private static IEnumerable<int?[]?[]> InnerSourceAreEqualCases()
+    {
+        yield return new int?[]?[]
+        {
+            null,
+            null,
+        };
+        yield return new[]
+        {
+            EmptyArray<int?>.Value,
+            EmptyArray<int?>.Value,
+        };
+        yield return new[]
+        {
+            EmptyArray<int?>.Create(),
+            EmptyArray<int?>.Create(),
+        };
+        yield return new[]
+        {
+            new int?[] { null },
+            new int?[] { null },
+        };
+        yield return new[]
+        {
+            new int?[] { 1 },
+            new int?[] { 1 },
+        };
+        yield return new[]
+        {
+            new int?[] { 1, 2 },
+            new int?[] { 1, 2 },
+        };
+        yield return new[]
+        {
+            new int?[] { 1, 2, 3 },
+            new int?[] { 1, 2, 3 },
+        };
+        yield return new[]
+        {
+            new int?[] { 1, 2, 3, 4 },
+            new int?[] { 1, 2, 3, 4 },
+        };
+
+        var array1 = new int?[] { 1 };
+        var array2 = new int?[] { 1, 2 };
+        var array3 = new int?[] { 1, 2, 3 };
+        var array4 = new int?[] { 1, 2, 3, 4 };
+        yield return new[]
+        {
+            array1,
+            array1,
+        };
+        yield return new[]
+        {
+            array2,
+            array2,
+        };
+        yield return new[]
+        {
+            array3,
+            array3,
+        };
+        yield return new[]
+        {
+            array4,
+            array4,
+        };
+    }
+
+    private static IEnumerable<int?[]?[]> InnerSourceAreNotEqualCases()
+    {
+        yield return new[]
+        {
+            null,
+            new int?[] { 1 },
+        };
+        yield return new[]
+        {
+            new int?[] { 1 },
+            null,
+        };
+        yield return new[]
+        {
+            EmptyArray<int?>.Value,
+            new int?[] { 1 },
+        };
+        yield return new[]
+        {
+            new int?[] { 1 },
+            EmptyArray<int?>.Value,
+        };
+        yield return new[]
+        {
+            new int?[] { 1 },
+            new int?[] { 1, 2 },
+        };
+        yield return new[]
+        {
+            new int?[] { 1, 2 },
+            new int?[] { 1 },
+        };
+        yield return new[]
+        {
+            new int?[] { 1, 2 },
+            new int?[] { 1, 2, 3 },
+        };
+        yield return new[]
+        {
+            new int?[] { 1, 2, 3 },
+            new int?[] { 1, 2 },
+        };
+        yield return new[]
+        {
+            new int?[] { 1, 2, 3 },
+            new int?[] { 1, 2, 3, 4 },
+        };
+        yield return new[]
+        {
+            new int?[] { 1, 2, 3, 4 },
+            new int?[] { 1, 2, 3 },
+        };
+        yield return new[]
+        {
+            new int?[] { null },
+            new int?[] { 1 },
+        };
+        yield return new[]
+        {
+            new int?[] { 1 },
+            new int?[] { null },
+        };
+        yield return new[]
+        {
+            new int?[] { 1, 2, 3, 3 },
+            new int?[] { 1, 2, 3, 4 },
+        };
+        yield return new[]
+        {
+            new int?[] { 1, 2, 2, 4 },
+            new int?[] { 1, 2, 3, 4 },
+        };
+        yield return new[]
+        {
+            new int?[] { 1, 1, 3, 4 },
+            new int?[] { 1, 2, 3, 4 },
+        };
+        yield return new[]
+        {
+            new int?[] { 0, 2, 3, 4 },
+            new int?[] { 1, 2, 3, 4 },
+        };
+    }
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CustomEqualityComparer.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CustomEqualityComparer.cs
new file mode 100644
index 0000000..778b414
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CustomEqualityComparer.cs
@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests;
+
+internal sealed class CustomEqualityComparer<T> : IEqualityComparer<T>
+{
+    public bool Equals(T? x, T? y)
+        =>
+        EqualityComparer<T>.Default.Equals(x, y);
+
+    public int GetHashCode([DisallowNull] T obj)
+        =>
+        EqualityComparer<T>.Default.GetHashCode(obj);
+
+    public static CustomEqualityComparer<T> Default { get; } = new();
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CustomList.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CustomList.cs
new file mode 100644
index 0000000..f350a7d
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CustomList.cs
@@ -0,0 +1,63 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests;
+
+internal sealed class CustomList<T> : IList<T>
+{
+    private readonly T[] items;
+
+    public CustomList(params T[] items) => this.items = items;
+
+    public static CustomList<T> Empty { get; } = new();
+
+    public bool IsReadOnly => true;
+
+    public int Count => items.Length;
+
+    public T this[int index]
+    {
+        get => items[index];
+        set => throw new NotImplementedException();
+    }
+
+    public IEnumerator<T> GetEnumerator()
+    {
+        foreach (var item in items) yield return item;
+    }
+
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+    int IList<T>.IndexOf(T item)
+        =>
+        throw new NotImplementedException();
+
+    void IList<T>.Insert(int index, T item)
+        =>
+        throw new NotImplementedException();
+
+    void IList<T>.RemoveAt(int index)
+        =>
+        throw new NotImplementedException();
+
+    void ICollection<T>.Add(T item)
+        =>
+        throw new NotImplementedException();
+
+    void ICollection<T>.Clear()
+        =>
+        throw new NotImplementedException();
+
+    bool ICollection<T>.Contains(T item)
+        =>
+        throw new NotImplementedException();
+
+    void ICollection<T>.CopyTo(T[] array, int arrayIndex)
+        =>
+        throw new NotImplementedException();
+
+    bool ICollection<T>.Remove(T item)
+        =>
+        throw new NotImplementedException();
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CustomReadOnlyList.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CustomReadOnlyList.cs
new file mode 100644
index 0000000..51c56c6
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/CustomReadOnlyList.cs
@@ -0,0 +1,24 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests;
+
+internal sealed class CustomReadOnlyList<T> : IReadOnlyList<T>
+{
+    private readonly T[] items;
+
+    public CustomReadOnlyList(params T[] items) => this.items = items;
+
+    public static CustomReadOnlyList<T> Empty { get; } = new();
+
+    public int Count => items.Length;
+
+    public T this[int index] => items[index];
+
+    public IEnumerator<T> GetEnumerator()
+    {
+        foreach (var item in items) yield return item;
+    }
+
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/EmptyArray.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/EmptyArray.cs
new file mode 100644
index 0000000..2e74923
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/EmptyArray.cs
@@ -0,0 +1,15 @@
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests;
+
+internal static class EmptyArray<T>
+{
+#pragma warning disable CA1825 // Avoid zero-length array allocations
+    internal static T[] Create() => new T[0];
+#pragma warning restore CA1825 // Avoid zero-length array allocations
+
+    internal static T[] Value => InnerEmpty.Value;
+
+    private static class InnerEmpty
+    {
+        internal static readonly T[] Value = Create();
+    }
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/FactoryTestHelper.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/FactoryTestHelper.cs
new file mode 100644
index 0000000..ead3f37
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/FactoryTestHelper.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Reflection;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests;
+
+internal static class FactoryTestHelper
+{
+    internal static void AssertItemComparerMatch<TCollectionComparer>(
+        Type type,
+        TCollectionComparer collectionComparer,
+        object itemComparerMatch)
+    {
+        var field = type.GetField("comparer", BindingFlags.Instance | BindingFlags.NonPublic);
+
+        Assert.NotNull(field);
+        Assert.True(field.IsPrivate);
+
+        var itemComparer = field.GetValue(collectionComparer);
+        Assert.True(ReferenceEquals(itemComparer, itemComparerMatch));
+    }
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer/EqualityComparerTestsFactory.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer/EqualityComparerTestsFactory.cs
new file mode 100644
index 0000000..cffb9f7
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer/EqualityComparerTestsFactory.cs
@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ImmutableArrayEqualityComparer;
+
+public static class EqualityComparerTestsFactory
+{
+    private static Type ComparerType => typeof(ImmutableArrayEqualityComparer<object>);
+
+    [Theory]
+    [MemberData(nameof(Test_Factory_ExpectItemComparer_Cases))]
+    public static void Test_Factory_ExpectItemComparer(ImmutableArrayEqualityComparer<object> comparer, object expectedItemComparer)
+        =>
+        FactoryTestHelper.AssertItemComparerMatch(ComparerType, comparer, expectedItemComparer);
+
+    public static IEnumerable<object[]> Test_Factory_ExpectItemComparer_Cases()
+    {
+        yield return new object[]
+        {
+            ImmutableArrayEqualityComparer<object>.Default,
+            EqualityComparer<object>.Default
+        };
+        yield return new object[]
+        {
+            ImmutableArrayEqualityComparer<object>.Create(),
+            EqualityComparer<object>.Default
+        };
+        yield return new object[]
+        {
+            ImmutableArrayEqualityComparer<object>.Create(null),
+            EqualityComparer<object>.Default
+        };
+        yield return new object[]
+        {
+            ImmutableArrayEqualityComparer<object>.Create(EqualityComparer<object>.Default),
+            EqualityComparer<object>.Default
+        };
+        yield return new object[]
+        {
+            ImmutableArrayEqualityComparer<object>.Create(CustomEqualityComparer<object>.Default),
+            CustomEqualityComparer<object>.Default
+        };
+    }
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer_Normal/EqualityComparerTestsGeneral.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer_Normal/EqualityComparerTestsGeneral.cs
new file mode 100644
index 0000000..680512d
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer_Normal/EqualityComparerTestsGeneral.cs
@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ImmutableArrayEqualityComparer_Normal;
+
+public static class EqualityComparerTestsGeneral
+{
+    private static readonly ImmutableArrayEqualityComparer<object> comparer
+        = ImmutableArrayEqualityComparer<object>.Create(CustomEqualityComparer<object>.Default);
+
+    [Fact]
+    public static void Test_GetHashCode_SourceIsDefault_ExpectZero()
+    {
+        ImmutableArray<object> defaultObj = default;
+        var actual = comparer.GetHashCode(defaultObj);
+        Assert.StrictEqual(0, actual);
+    }
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer_Normal/EqualityComparerTestsRef.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer_Normal/EqualityComparerTestsRef.cs
new file mode 100644
index 0000000..f869b7b
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer_Normal/EqualityComparerTestsRef.cs
@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ImmutableArrayEqualityComparer_Normal;
+
+public static class EqualityComparerTestsRef
+{
+    private static readonly ImmutableArrayEqualityComparer<string?> comparer
+        = ImmutableArrayEqualityComparer<string?>.Create(CustomEqualityComparer<string?>.Default);
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_GetHashCode_SourceAreEqual_ExpectHashCodesAreEqual(CaseParamOfImmutableArray<string?> source1, CaseParamOfImmutableArray<string?> source2)
+    {
+        var hashCode1 = comparer.GetHashCode(source1.Items);
+        var hashCode2 = comparer.GetHashCode(source2.Items);
+        Assert.StrictEqual(hashCode1, hashCode2);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_Equals_SourceAreEqual_ExpectTrue(CaseParamOfImmutableArray<string?> source1, CaseParamOfImmutableArray<string?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.True(actualEquals);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreNotEqualCases))]
+    public static void Test_Equals_SourceAreNotEqual_ExpectTrue(CaseParamOfImmutableArray<string?> source1, CaseParamOfImmutableArray<string?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.False(actualEquals);
+    }
+
+    public static IEnumerable<object[]> SourceAreEqualCases()
+        =>
+        CaseSourcesArrayRef.SourceAreEqualCases()
+        .Select(@case => CaseMapper.MapToOfImmutableArray(@case));
+
+    public static IEnumerable<object[]> SourceAreNotEqualCases()
+        =>
+        CaseSourcesArrayRef.SourceAreNotEqualCases()
+        .Select(@case => CaseMapper.MapToOfImmutableArray(@case));
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer_Normal/EqualityComparerTestsStruct.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer_Normal/EqualityComparerTestsStruct.cs
new file mode 100644
index 0000000..5c927e2
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer_Normal/EqualityComparerTestsStruct.cs
@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ImmutableArrayEqualityComparer_Normal;
+
+public static class EqualityComparerTestsStruct
+{
+    private static readonly ImmutableArrayEqualityComparer<int?> comparer
+        = ImmutableArrayEqualityComparer<int?>.Create(CustomEqualityComparer<int?>.Default);
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_GetHashCode_SourceAreEqual_ExpectHashCodesAreEqual(CaseParamOfImmutableArray<int?> source1, CaseParamOfImmutableArray<int?> source2)
+    {
+        var hashCode1 = comparer.GetHashCode(source1.Items);
+        var hashCode2 = comparer.GetHashCode(source2.Items);
+        Assert.StrictEqual(hashCode1, hashCode2);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_Equals_SourceAreEqual_ExpectTrue(CaseParamOfImmutableArray<int?> source1, CaseParamOfImmutableArray<int?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.True(actualEquals);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreNotEqualCases))]
+    public static void Test_Equals_SourceAreNotEqual_ExpectTrue(CaseParamOfImmutableArray<int?> source1, CaseParamOfImmutableArray<int?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.False(actualEquals);
+    }
+
+    public static IEnumerable<object[]> SourceAreEqualCases()
+        =>
+        CaseSourcesArrayStruct.SourceAreEqualCases()
+        .Select(@case => CaseMapper.MapToOfImmutableArray(@case));
+
+    public static IEnumerable<object[]> SourceAreNotEqualCases()
+        =>
+        CaseSourcesArrayStruct.SourceAreNotEqualCases()
+        .Select(@case => CaseMapper.MapToOfImmutableArray(@case));
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer_Nullable/EqualityComparerTestsGeneral.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer_Nullable/EqualityComparerTestsGeneral.cs
new file mode 100644
index 0000000..7ef86ff
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer_Nullable/EqualityComparerTestsGeneral.cs
@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ImmutableArrayEqualityComparer_Nullable;
+
+public static class EqualityComparerTestsGeneral
+{
+    private static readonly ImmutableArrayEqualityComparer<object> comparer
+        = ImmutableArrayEqualityComparer<object>.Create(CustomEqualityComparer<object>.Default);
+
+    [Fact]
+    public static void Test_GetHashCode_SourceIsNull_ExpectZero()
+    {
+        ImmutableArray<object>? nullObj = default;
+        var actual = comparer.GetHashCode(nullObj);
+        Assert.StrictEqual(0, actual);
+    }
+
+    [Fact]
+    public static void Test_GetHashCode_SourceIsWrappedDefault_ExpectZero()
+    {
+        var wrappedDefaultObj = new ImmutableArray<object>?(default);
+        var actual = comparer.GetHashCode(wrappedDefaultObj);
+        Assert.StrictEqual(0, actual);
+    }
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer_Nullable/EqualityComparerTestsRef.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer_Nullable/EqualityComparerTestsRef.cs
new file mode 100644
index 0000000..1735de9
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer_Nullable/EqualityComparerTestsRef.cs
@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ImmutableArrayEqualityComparer_Nullable;
+
+public static class EqualityComparerTestsRef
+{
+    private static readonly ImmutableArrayEqualityComparer<string?> comparer
+        = ImmutableArrayEqualityComparer<string?>.Create(CustomEqualityComparer<string?>.Default);
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_GetHashCode_SourceAreEqual_ExpectHashCodesAreEqual(CaseParamOfImmutableArrayNullable<string?> source1, CaseParamOfImmutableArrayNullable<string?> source2)
+    {
+        var hashCode1 = comparer.GetHashCode(source1.Items);
+        var hashCode2 = comparer.GetHashCode(source2.Items);
+        Assert.StrictEqual(hashCode1, hashCode2);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_Equals_SourceAreEqual_ExpectTrue(CaseParamOfImmutableArrayNullable<string?> source1, CaseParamOfImmutableArrayNullable<string?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.True(actualEquals);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreNotEqualCases))]
+    public static void Test_Equals_SourceAreNotEqual_ExpectTrue(CaseParamOfImmutableArrayNullable<string?> source1, CaseParamOfImmutableArrayNullable<string?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.False(actualEquals);
+    }
+
+    public static IEnumerable<object[]> SourceAreEqualCases()
+        =>
+        CaseSourcesArrayRef.SourceAreEqualCases()
+        .SelectMany(@case => CaseMapper.MapToOfImmutableArrayNullable(@case));
+
+    public static IEnumerable<object[]> SourceAreNotEqualCases()
+        =>
+        CaseSourcesArrayRef.SourceAreNotEqualCases()
+        .SelectMany(@case => CaseMapper.MapToOfImmutableArrayNullable(@case));
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer_Nullable/EqualityComparerTestsStruct.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer_Nullable/EqualityComparerTestsStruct.cs
new file mode 100644
index 0000000..3cf6d71
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ImmutableArrayEqualityComparer_Nullable/EqualityComparerTestsStruct.cs
@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ImmutableArrayEqualityComparer_Nullable;
+
+public static class EqualityComparerTestsStruct
+{
+    private static readonly ImmutableArrayEqualityComparer<int?> comparer
+        = ImmutableArrayEqualityComparer<int?>.Create(CustomEqualityComparer<int?>.Default);
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_GetHashCode_SourceAreEqual_ExpectHashCodesAreEqual(CaseParamOfImmutableArrayNullable<int?> source1, CaseParamOfImmutableArrayNullable<int?> source2)
+    {
+        var hashCode1 = comparer.GetHashCode(source1.Items);
+        var hashCode2 = comparer.GetHashCode(source2.Items);
+        Assert.StrictEqual(hashCode1, hashCode2);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_Equals_SourceAreEqual_ExpectTrue(CaseParamOfImmutableArrayNullable<int?> source1, CaseParamOfImmutableArrayNullable<int?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.True(actualEquals);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreNotEqualCases))]
+    public static void Test_Equals_SourceAreNotEqual_ExpectTrue(CaseParamOfImmutableArrayNullable<int?> source1, CaseParamOfImmutableArrayNullable<int?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.False(actualEquals);
+    }
+
+    public static IEnumerable<object[]> SourceAreEqualCases()
+        =>
+        CaseSourcesArrayStruct.SourceAreEqualCases()
+        .SelectMany(@case => CaseMapper.MapToOfImmutableArrayNullable(@case));
+
+    public static IEnumerable<object[]> SourceAreNotEqualCases()
+        =>
+        CaseSourcesArrayStruct.SourceAreNotEqualCases()
+        .SelectMany(@case => CaseMapper.MapToOfImmutableArrayNullable(@case));
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer/EqualityComparerTestsFactory.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer/EqualityComparerTestsFactory.cs
new file mode 100644
index 0000000..b852f4e
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer/EqualityComparerTestsFactory.cs
@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ListEqualityComparer;
+
+public static class EqualityComparerTestsFactory
+{
+    private static Type ComparerType => typeof(ListEqualityComparer<object>);
+
+    [Theory]
+    [MemberData(nameof(Test_Factory_ExpectItemComparer_Cases))]
+    public static void Test_Factory_ExpectItemComparer(ListEqualityComparer<object> comparer, object expectedItemComparer)
+        =>
+        FactoryTestHelper.AssertItemComparerMatch(ComparerType, comparer, expectedItemComparer);
+
+    public static IEnumerable<object[]> Test_Factory_ExpectItemComparer_Cases()
+    {
+        yield return new object[]
+        {
+            ListEqualityComparer<object>.Default,
+            EqualityComparer<object>.Default
+        };
+        yield return new object[]
+        {
+            ListEqualityComparer<object>.Create(),
+            EqualityComparer<object>.Default
+        };
+        yield return new object[]
+        {
+            ListEqualityComparer<object>.Create(null),
+            EqualityComparer<object>.Default
+        };
+        yield return new object[]
+        {
+            ListEqualityComparer<object>.Create(EqualityComparer<object>.Default),
+            EqualityComparer<object>.Default
+        };
+        yield return new object[]
+        {
+            ListEqualityComparer<object>.Create(CustomEqualityComparer<object>.Default),
+            CustomEqualityComparer<object>.Default
+        };
+    }
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer_IList/EqualityComparerTestsGeneral.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer_IList/EqualityComparerTestsGeneral.cs
new file mode 100644
index 0000000..10f3212
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer_IList/EqualityComparerTestsGeneral.cs
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ListEqualityComparer_IList;
+
+public static class EqualityComparerTestsGeneral
+{
+    private static readonly ListEqualityComparer<object> comparer
+        = ListEqualityComparer<object>.Create(CustomEqualityComparer<object>.Default);
+
+    [Fact]
+    public static void Test_GetHashCode_SourceIsNull_ExpectZero()
+    {
+        IList<object>? nullObj = null;
+        var actual = comparer.GetHashCode(nullObj);
+        Assert.StrictEqual(0, actual);
+    }
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer_IList/EqualityComparerTestsRef.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer_IList/EqualityComparerTestsRef.cs
new file mode 100644
index 0000000..9d0a0fc
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer_IList/EqualityComparerTestsRef.cs
@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ListEqualityComparer_IList;
+
+public static class EqualityComparerTestsRef
+{
+    private static readonly ListEqualityComparer<string?> comparer
+        = ListEqualityComparer<string?>.Create(CustomEqualityComparer<string?>.Default);
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_GetHashCode_SourceAreEqual_ExpectHashCodesAreEqual(CaseParamOfIList<string?> source1, CaseParamOfIList<string?> source2)
+    {
+        var hashCode1 = comparer.GetHashCode(source1.Items);
+        var hashCode2 = comparer.GetHashCode(source2.Items);
+        Assert.StrictEqual(hashCode1, hashCode2);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_Equals_SourceAreEqual_ExpectTrue(CaseParamOfIList<string?> source1, CaseParamOfIList<string?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.True(actualEquals);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreNotEqualCases))]
+    public static void Test_Equals_SourceAreNotEqual_ExpectTrue(CaseParamOfIList<string?> source1, CaseParamOfIList<string?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.False(actualEquals);
+    }
+
+    public static IEnumerable<object[]> SourceAreEqualCases()
+        =>
+        CaseSourcesArrayRef.SourceAreEqualCases()
+        .Select(@case => CaseMapper.MapToOfIList(@case));
+
+    public static IEnumerable<object[]> SourceAreNotEqualCases()
+        =>
+        CaseSourcesArrayRef.SourceAreNotEqualCases()
+        .Select(@case => CaseMapper.MapToOfIList(@case));
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer_IList/EqualityComparerTestsStruct.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer_IList/EqualityComparerTestsStruct.cs
new file mode 100644
index 0000000..feb5e12
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer_IList/EqualityComparerTestsStruct.cs
@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ListEqualityComparer_IList;
+
+public static class EqualityComparerTestsStruct
+{
+    private static readonly ListEqualityComparer<int?> comparer
+        = ListEqualityComparer<int?>.Create(CustomEqualityComparer<int?>.Default);
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_GetHashCode_SourceAreEqual_ExpectHashCodesAreEqual(CaseParamOfIList<int?> source1, CaseParamOfIList<int?> source2)
+    {
+        var hashCode1 = comparer.GetHashCode(source1.Items);
+        var hashCode2 = comparer.GetHashCode(source2.Items);
+        Assert.StrictEqual(hashCode1, hashCode2);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_Equals_SourceAreEqual_ExpectTrue(CaseParamOfIList<int?> source1, CaseParamOfIList<int?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.True(actualEquals);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreNotEqualCases))]
+    public static void Test_Equals_SourceAreNotEqual_ExpectTrue(CaseParamOfIList<int?> source1, CaseParamOfIList<int?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.False(actualEquals);
+    }
+
+    public static IEnumerable<object[]> SourceAreEqualCases()
+        =>
+        CaseSourcesArrayStruct.SourceAreEqualCases()
+        .Select(@case => CaseMapper.MapToOfIList(@case));
+
+    public static IEnumerable<object[]> SourceAreNotEqualCases()
+        =>
+        CaseSourcesArrayStruct.SourceAreNotEqualCases()
+        .Select(@case => CaseMapper.MapToOfIList(@case));
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer_List/EqualityComparerTestsGeneral.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer_List/EqualityComparerTestsGeneral.cs
new file mode 100644
index 0000000..275f239
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer_List/EqualityComparerTestsGeneral.cs
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ListEqualityComparer_List;
+
+public static class EqualityComparerTestsGeneral
+{
+    private static readonly ListEqualityComparer<object> comparer
+        = ListEqualityComparer<object>.Create(CustomEqualityComparer<object>.Default);
+
+    [Fact]
+    public static void Test_GetHashCode_SourceIsNull_ExpectZero()
+    {
+        List<object>? nullObj = null;
+        var actual = comparer.GetHashCode(nullObj);
+        Assert.StrictEqual(0, actual);
+    }
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer_List/EqualityComparerTestsRef.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer_List/EqualityComparerTestsRef.cs
new file mode 100644
index 0000000..69b1ad3
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer_List/EqualityComparerTestsRef.cs
@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ListEqualityComparer_List;
+
+public static class EqualityComparerTestsRef
+{
+    private static readonly ListEqualityComparer<string?> comparer
+        = ListEqualityComparer<string?>.Create(CustomEqualityComparer<string?>.Default);
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_GetHashCode_SourceAreEqual_ExpectHashCodesAreEqual(CaseParamOfList<string?> source1, CaseParamOfList<string?> source2)
+    {
+        var hashCode1 = comparer.GetHashCode(source1.Items);
+        var hashCode2 = comparer.GetHashCode(source2.Items);
+        Assert.StrictEqual(hashCode1, hashCode2);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_Equals_SourceAreEqual_ExpectTrue(CaseParamOfList<string?> source1, CaseParamOfList<string?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.True(actualEquals);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreNotEqualCases))]
+    public static void Test_Equals_SourceAreNotEqual_ExpectTrue(CaseParamOfList<string?> source1, CaseParamOfList<string?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.False(actualEquals);
+    }
+
+    public static IEnumerable<object[]> SourceAreEqualCases()
+        =>
+        CaseSourcesArrayRef.SourceAreEqualCases()
+        .Select(@case => CaseMapper.MapToOfList(@case));
+
+    public static IEnumerable<object[]> SourceAreNotEqualCases()
+        =>
+        CaseSourcesArrayRef.SourceAreNotEqualCases()
+        .Select(@case => CaseMapper.MapToOfList(@case));
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer_List/EqualityComparerTestsStruct.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer_List/EqualityComparerTestsStruct.cs
new file mode 100644
index 0000000..ab28243
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ListEqualityComparer_List/EqualityComparerTestsStruct.cs
@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ListEqualityComparer_List;
+
+public static class EqualityComparerTestsStruct
+{
+    private static readonly ListEqualityComparer<int?> comparer
+        = ListEqualityComparer<int?>.Create(CustomEqualityComparer<int?>.Default);
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_GetHashCode_SourceAreEqual_ExpectHashCodesAreEqual(CaseParamOfList<int?> source1, CaseParamOfList<int?> source2)
+    {
+        var hashCode1 = comparer.GetHashCode(source1.Items);
+        var hashCode2 = comparer.GetHashCode(source2.Items);
+        Assert.StrictEqual(hashCode1, hashCode2);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_Equals_SourceAreEqual_ExpectTrue(CaseParamOfList<int?> source1, CaseParamOfList<int?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.True(actualEquals);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreNotEqualCases))]
+    public static void Test_Equals_SourceAreNotEqual_ExpectTrue(CaseParamOfList<int?> source1, CaseParamOfList<int?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.False(actualEquals);
+    }
+
+    public static IEnumerable<object[]> SourceAreEqualCases()
+        =>
+        CaseSourcesArrayStruct.SourceAreEqualCases()
+        .Select(@case => CaseMapper.MapToOfList(@case));
+
+    public static IEnumerable<object[]> SourceAreNotEqualCases()
+        =>
+        CaseSourcesArrayStruct.SourceAreNotEqualCases()
+        .Select(@case => CaseMapper.MapToOfList(@case));
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ReadOnlyListEqualityComparer/EqualityComparerTestsFactory.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ReadOnlyListEqualityComparer/EqualityComparerTestsFactory.cs
new file mode 100644
index 0000000..88c85a0
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ReadOnlyListEqualityComparer/EqualityComparerTestsFactory.cs
@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ReadOnlyListEqualityComparer;
+
+public static class EqualityComparerTestsFactory
+{
+    private static Type ComparerType => typeof(ReadOnlyListEqualityComparer<object>);
+
+    [Theory]
+    [MemberData(nameof(Test_Factory_ExpectItemComparer_Cases))]
+    public static void Test_Factory_ExpectItemComparer(ReadOnlyListEqualityComparer<object> comparer, object expectedItemComparer)
+        =>
+        FactoryTestHelper.AssertItemComparerMatch(ComparerType, comparer, expectedItemComparer);
+
+    public static IEnumerable<object[]> Test_Factory_ExpectItemComparer_Cases()
+    {
+        yield return new object[]
+        {
+            ReadOnlyListEqualityComparer<object>.Default,
+            EqualityComparer<object>.Default
+        };
+        yield return new object[]
+        {
+            ReadOnlyListEqualityComparer<object>.Create(),
+            EqualityComparer<object>.Default
+        };
+        yield return new object[]
+        {
+            ReadOnlyListEqualityComparer<object>.Create(null),
+            EqualityComparer<object>.Default
+        };
+        yield return new object[]
+        {
+            ReadOnlyListEqualityComparer<object>.Create(EqualityComparer<object>.Default),
+            EqualityComparer<object>.Default
+        };
+        yield return new object[]
+        {
+            ReadOnlyListEqualityComparer<object>.Create(CustomEqualityComparer<object>.Default),
+            CustomEqualityComparer<object>.Default
+        };
+    }
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ReadOnlyListEqualityComparer/EqualityComparerTestsGeneral.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ReadOnlyListEqualityComparer/EqualityComparerTestsGeneral.cs
new file mode 100644
index 0000000..e8fb21a
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ReadOnlyListEqualityComparer/EqualityComparerTestsGeneral.cs
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ReadOnlyListEqualityComparer;
+
+public static class EqualityComparerTestsGeneral
+{
+    private static readonly ReadOnlyListEqualityComparer<object> comparer
+        = ReadOnlyListEqualityComparer<object>.Create(CustomEqualityComparer<object>.Default);
+
+    [Fact]
+    public static void Test_GetHashCode_SourceIsNull_ExpectZero()
+    {
+        IReadOnlyList<object>? nullObj = null;
+        var actual = comparer.GetHashCode(nullObj);
+        Assert.StrictEqual(0, actual);
+    }
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ReadOnlyListEqualityComparer/EqualityComparerTestsRef.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ReadOnlyListEqualityComparer/EqualityComparerTestsRef.cs
new file mode 100644
index 0000000..810fc62
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ReadOnlyListEqualityComparer/EqualityComparerTestsRef.cs
@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ReadOnlyListEqualityComparer;
+
+public static class EqualityComparerTestsRef
+{
+    private static readonly ReadOnlyListEqualityComparer<string?> comparer
+        = ReadOnlyListEqualityComparer<string?>.Create(CustomEqualityComparer<string?>.Default);
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_GetHashCode_SourceAreEqual_ExpectHashCodesAreEqual(CaseParamOfIReadOnlyList<string?> source1, CaseParamOfIReadOnlyList<string?> source2)
+    {
+        var hashCode1 = comparer.GetHashCode(source1.Items);
+        var hashCode2 = comparer.GetHashCode(source2.Items);
+        Assert.StrictEqual(hashCode1, hashCode2);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_Equals_SourceAreEqual_ExpectTrue(CaseParamOfIReadOnlyList<string?> source1, CaseParamOfIReadOnlyList<string?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.True(actualEquals);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreNotEqualCases))]
+    public static void Test_Equals_SourceAreNotEqual_ExpectTrue(CaseParamOfIReadOnlyList<string?> source1, CaseParamOfIReadOnlyList<string?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.False(actualEquals);
+    }
+
+    public static IEnumerable<object[]> SourceAreEqualCases()
+        =>
+        CaseSourcesArrayRef.SourceAreEqualCases()
+        .Select(@case => CaseMapper.MapToOfIReadOnlyList(@case));
+
+    public static IEnumerable<object[]> SourceAreNotEqualCases()
+        =>
+        CaseSourcesArrayRef.SourceAreNotEqualCases()
+        .Select(@case => CaseMapper.MapToOfIReadOnlyList(@case));
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ReadOnlyListEqualityComparer/EqualityComparerTestsStruct.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ReadOnlyListEqualityComparer/EqualityComparerTestsStruct.cs
new file mode 100644
index 0000000..d110b07
--- /dev/null
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers.Tests/ReadOnlyListEqualityComparer/EqualityComparerTestsStruct.cs
@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace PrimeFuncPack.Collections.Generic.EqualityComparers.Tests.ReadOnlyListEqualityComparer;
+
+public static class EqualityComparerTestsStruct
+{
+    private static readonly ReadOnlyListEqualityComparer<int?> comparer
+        = ReadOnlyListEqualityComparer<int?>.Create(CustomEqualityComparer<int?>.Default);
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_GetHashCode_SourceAreEqual_ExpectHashCodesAreEqual(CaseParamOfIReadOnlyList<int?> source1, CaseParamOfIReadOnlyList<int?> source2)
+    {
+        var hashCode1 = comparer.GetHashCode(source1.Items);
+        var hashCode2 = comparer.GetHashCode(source2.Items);
+        Assert.StrictEqual(hashCode1, hashCode2);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreEqualCases))]
+    public static void Test_Equals_SourceAreEqual_ExpectTrue(CaseParamOfIReadOnlyList<int?> source1, CaseParamOfIReadOnlyList<int?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.True(actualEquals);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceAreNotEqualCases))]
+    public static void Test_Equals_SourceAreNotEqual_ExpectTrue(CaseParamOfIReadOnlyList<int?> source1, CaseParamOfIReadOnlyList<int?> source2)
+    {
+        var actualEquals = comparer.Equals(source1.Items, source2.Items);
+        Assert.False(actualEquals);
+    }
+
+    public static IEnumerable<object[]> SourceAreEqualCases()
+        =>
+        CaseSourcesArrayStruct.SourceAreEqualCases()
+        .Select(@case => CaseMapper.MapToOfIReadOnlyList(@case));
+
+    public static IEnumerable<object[]> SourceAreNotEqualCases()
+        =>
+        CaseSourcesArrayStruct.SourceAreNotEqualCases()
+        .Select(@case => CaseMapper.MapToOfIReadOnlyList(@case));
+}
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/Collections.Generic.EqualityComparers.csproj b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/Collections.Generic.EqualityComparers.csproj
index ab1a90e..f8b2fbd 100644
--- a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/Collections.Generic.EqualityComparers.csproj
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/Collections.Generic.EqualityComparers.csproj
@@ -16,8 +16,8 @@
     <Copyright>Copyright © 2022-2023 Andrei Sergeev, Pavel Moskovoy</Copyright>
     <Description>PrimeFuncPack Generic Collections.EqualityComparers is a core library for .NET consisting of collection value equality comparers.</Description>
     <RootNamespace>System.Collections.Generic</RootNamespace>
-    <AssemblyName>EarlyFuncPack.Collections.Generic.EqualityComparers</AssemblyName>
-    <Version>0.99.0</Version>
+    <AssemblyName>PrimeFuncPack.Collections.Generic.EqualityComparers</AssemblyName>
+    <Version>1.0.0</Version>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/EqualityComparers/ArrayEqualityComparer.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/EqualityComparers/ArrayEqualityComparer.cs
index 011f8e3..115177c 100644
--- a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/EqualityComparers/ArrayEqualityComparer.cs
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/EqualityComparers/ArrayEqualityComparer.cs
@@ -51,7 +51,7 @@ public bool Equals(T[]? x, T[]? y)
 
     public int GetHashCode(T[]? obj)
     {
-        if (obj is null) // Return zero instead of throwing ArgumentNullException
+        if (obj is null)
         {
             return default;
         }
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/EqualityComparers/ImmutableArrayEqualityComparer.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/EqualityComparers/ImmutableArrayEqualityComparer.cs
index 9861804..25673d6 100644
--- a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/EqualityComparers/ImmutableArrayEqualityComparer.cs
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/EqualityComparers/ImmutableArrayEqualityComparer.cs
@@ -29,7 +29,7 @@ public bool Equals(ImmutableArray<T> x, ImmutableArray<T> y)
             return true;
         }
 
-        if (x.IsDefault || y.IsDefault) // The default means null
+        if (x.IsDefault || y.IsDefault) // The null case
         {
             return false;
         }
@@ -53,7 +53,7 @@ public bool Equals(ImmutableArray<T> x, ImmutableArray<T> y)
 
     public int GetHashCode(ImmutableArray<T> obj)
     {
-        if (obj.IsDefault) // Return zero instead of throwing ArgumentNullException
+        if (obj.IsDefault) // The null case
         {
             return default;
         }
@@ -71,11 +71,11 @@ public int GetHashCode(ImmutableArray<T> obj)
 
     public bool Equals(ImmutableArray<T>? x, ImmutableArray<T>? y)
         =>
-        Equals(x ?? default, y ?? default); // The default means null
+        Equals(x.GetValueOrDefault(), y.GetValueOrDefault());
 
     public int GetHashCode(ImmutableArray<T>? obj)
         =>
-        GetHashCode(obj ?? default); // The default means null
+        GetHashCode(obj.GetValueOrDefault());
 
     private static class InnerDefault
     {
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/EqualityComparers/ListEqualityComparer.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/EqualityComparers/ListEqualityComparer.cs
index d83dc4a..23dbbc8 100644
--- a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/EqualityComparers/ListEqualityComparer.cs
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/EqualityComparers/ListEqualityComparer.cs
@@ -51,7 +51,7 @@ public bool Equals(IList<T>? x, IList<T>? y)
 
     public int GetHashCode(IList<T>? obj)
     {
-        if (obj is null) // Return zero instead of throwing ArgumentNullException
+        if (obj is null)
         {
             return default;
         }
diff --git a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/EqualityComparers/ReadOnlyListEqualityComparer.cs b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/EqualityComparers/ReadOnlyListEqualityComparer.cs
index e9e8c40..b5e2c3f 100644
--- a/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/EqualityComparers/ReadOnlyListEqualityComparer.cs
+++ b/src/collections-generic-equalitycomparers/Collections.Generic.EqualityComparers/EqualityComparers/ReadOnlyListEqualityComparer.cs
@@ -51,7 +51,7 @@ public bool Equals(IReadOnlyList<T>? x, IReadOnlyList<T>? y)
 
     public int GetHashCode(IReadOnlyList<T>? obj)
     {
-        if (obj is null) // Return zero instead of throwing ArgumentNullException
+        if (obj is null)
         {
             return default;
         }
diff --git a/src/collections-generic/Collections.Generic/Collections.Generic.csproj b/src/collections-generic/Collections.Generic/Collections.Generic.csproj
index d07d1a8..4ee9725 100644
--- a/src/collections-generic/Collections.Generic/Collections.Generic.csproj
+++ b/src/collections-generic/Collections.Generic/Collections.Generic.csproj
@@ -16,8 +16,8 @@
     <Copyright>Copyright © 2022-2023 Andrei Sergeev, Pavel Moskovoy</Copyright>
     <Description>PrimeFuncPack Generic Collections is a core library pack for .NET consisting of collection extensions such as collection value equality comparers.</Description>
     <RootNamespace>System.Collections.Generic</RootNamespace>
-    <AssemblyName>EarlyFuncPack.Collections.Generic</AssemblyName>
-    <Version>0.99.0</Version>
+    <AssemblyName>PrimeFuncPack.Collections.Generic</AssemblyName>
+    <Version>1.0.0</Version>
   </PropertyGroup>
 
   <ItemGroup>
@@ -32,7 +32,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="EarlyFuncPack.Collections.Generic.EqualityComparers" Version="0.99.0" />
+    <PackageReference Include="PrimeFuncPack.Collections.Generic.EqualityComparers" Version="1.0.0" />
   </ItemGroup>
 
 </Project>