diff --git a/Source/SuperLinq/UnreachableException.cs b/Source/SuperLinq/UnreachableException.cs
index ce012fed..385d2194 100644
--- a/Source/SuperLinq/UnreachableException.cs
+++ b/Source/SuperLinq/UnreachableException.cs
@@ -1,14 +1,19 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
#pragma warning disable IDE0130
+#if !NET7_0_OR_GREATER
+using System.Diagnostics.CodeAnalysis;
+#endif
+
namespace System.Diagnostics;
#if !NET7_0_OR_GREATER
///
/// Exception thrown when the program executes an instruction that was thought to be unreachable.
///
+[ExcludeFromCodeCoverage]
public sealed class UnreachableException : Exception
{
///
diff --git a/Tests/SuperLinq.Test/SuperLinq.Test.csproj b/Tests/SuperLinq.Test/SuperLinq.Test.csproj
index 8424db6f..94d0bd12 100644
--- a/Tests/SuperLinq.Test/SuperLinq.Test.csproj
+++ b/Tests/SuperLinq.Test/SuperLinq.Test.csproj
@@ -14,6 +14,7 @@
+
diff --git a/Tests/SuperLinq.Test/ValueTupleComparerTest.cs b/Tests/SuperLinq.Test/ValueTupleComparerTest.cs
new file mode 100644
index 00000000..cdb6a277
--- /dev/null
+++ b/Tests/SuperLinq.Test/ValueTupleComparerTest.cs
@@ -0,0 +1,48 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Test;
+
+public class ValueTupleComparerTest
+{
+ private class TestComparer : IComparer
+ {
+ public int Compare([AllowNull] string x, [AllowNull] string y)
+ {
+ var xLen = x?.Length ?? 0;
+ var yLen = y?.Length ?? 0;
+ return xLen.CompareTo(yLen);
+ }
+ }
+
+ [Fact]
+ public void ValueTupleComparerShouldCreateWithDefaultComparers()
+ {
+ var comparer = ValueTupleComparer.Create(null, null);
+ ValueTuple left = new(1, 2);
+ ValueTuple right = new(3, 4);
+ var result = comparer.Compare(left, right);
+ Assert.Equal(-1, result);
+ }
+
+ [Fact]
+ public void ValueTupleComparerShouldCheckSecondItemIfFirstIsZero()
+ {
+ var comparer = ValueTupleComparer.Create(null, null);
+ ValueTuple left = new(1, 3);
+ ValueTuple right = new(1, 2);
+ var result = comparer.Compare(left, right);
+ Assert.Equal(1, result);
+ }
+
+ [Fact]
+ public void ValueTupleComparerShouldAcceptCustomComparers()
+ {
+ TestComparer innerLeftComparer = new();
+ TestComparer innerRightComparer = new();
+ var comparer = ValueTupleComparer.Create(innerLeftComparer, innerRightComparer);
+ ValueTuple left = new("123", "1");
+ ValueTuple right = new("123", "123");
+ var result = comparer.Compare(left, right);
+ Assert.Equal(-1, result);
+ }
+}
diff --git a/Tests/SuperLinq.Test/ValueTupleEqualityComparerTest.cs b/Tests/SuperLinq.Test/ValueTupleEqualityComparerTest.cs
new file mode 100644
index 00000000..f9ee88e3
--- /dev/null
+++ b/Tests/SuperLinq.Test/ValueTupleEqualityComparerTest.cs
@@ -0,0 +1,79 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Test;
+
+public class ValueTupleEqualityComparerTest
+{
+ private record TestObject(string Value);
+ private class TestComparer(Func comparer) : IEqualityComparer
+ {
+ public bool Equals(T? x, T? y) => comparer(x, y);
+ public int GetHashCode([DisallowNull] T obj) => obj.GetHashCode();
+ }
+
+ [Fact]
+ public void ValueTupleEqualityComparerWithOneTypeArgShouldCreateWhenNoComparerProvided()
+ {
+ var comparer = ValueTupleEqualityComparer.Create(null);
+ ValueTuple left = new(1);
+ ValueTuple right = new(1);
+ var result = comparer.Equals(left, right);
+ Assert.True(result);
+ }
+
+ [Fact]
+ public void ValueTupleEqualityComparerWithOneTypeArgShouldGetHashCode()
+ {
+ var comparer = ValueTupleEqualityComparer.Create(null);
+ ValueTuple first = new(null);
+ var firstHashCode = comparer.GetHashCode(first);
+ Assert.Equal(0, firstHashCode);
+
+ ValueTuple second = new(2);
+ var secondHashCode = comparer.GetHashCode(second);
+ Assert.Equal(2.GetHashCode(), secondHashCode);
+ }
+
+ [Fact]
+ public void ValueTupleEqualityComparerWithOneTypeArgShouldCreateWhenComparerProvided()
+ {
+ var innerComparer = new TestComparer((x, y) => x?.Value == y?.Value);
+ var comparer = ValueTupleEqualityComparer.Create(innerComparer);
+ ValueTuple left = new(new("testing"));
+ ValueTuple right = new(new("testing"));
+ var result = comparer.Equals(left, right);
+ Assert.True(result);
+ }
+
+ [Fact]
+ public void ValueTupleEqualityComparerWithTwoTypeArgsShouldCreateWhenNoComparerProvided()
+ {
+ var comparer = ValueTupleEqualityComparer.Create(null, null);
+ ValueTuple left = new(1, 2);
+ ValueTuple right = new(1, 2);
+ var result = comparer.Equals(left, right);
+ Assert.True(result);
+ }
+
+ [Fact]
+ public void ValueTupleEqualityComparerWithTwoTypeArgsShouldCreateWhenComparerProvided()
+ {
+ var innerComparerLeft = new TestComparer((x, y) => x?.Value == y?.Value);
+ var innerComparerRight = new TestComparer((x, y) => x?.Value == y?.Value);
+ var comparer = ValueTupleEqualityComparer.Create(innerComparerLeft, innerComparerRight);
+ ValueTuple left = new(new("1"), new("2"));
+ ValueTuple right = new(new("1"), new("2"));
+ var result = comparer.Equals(left, right);
+ Assert.True(result);
+ }
+
+ [Fact]
+ public void ValueTupleEqualityComparerWithTwoTypeArgsShouldGetHashCode()
+ {
+ var comparer = ValueTupleEqualityComparer.Create(null, null);
+ ValueTuple first = new(1, 2);
+ var firstHashCode = comparer.GetHashCode(first);
+ var expectedHashCode = HashCode.Combine(1.GetHashCode(), 2.GetHashCode());
+ Assert.Equal(expectedHashCode, firstHashCode);
+ }
+}