Skip to content

Add IEqualityComparer and Func predicate overloads to equality assertions #196

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
MrKWatkins merged 3 commits into from
Feb 21, 2026
Merged

Add IEqualityComparer and Func predicate overloads to equality assertions #196

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
0adcd41
Initial plan
Copilot Feb 21, 2026
a232995
Add IEqualityComparer and Func predicate overloads to Equal, NotEqual…
Copilot Feb 21, 2026
61c5c1c
Address code review: simplify NotEqual predicate null handling
Copilot Feb 21, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
78 changes: 78 additions & 0 deletions src/MrKWatkins.Assertions.Tests/EnumerableAssertionsTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -132,6 +132,44 @@ public async Task SequenceEqual_Chain()
await Assert.That(chain.And.Value).IsEqualTo(value);
}

[Test]
public async Task SequenceEqual_Comparer()
{
var value = new List<string> { "a", "b", "c" };

await Assert.That(() => value.Should().SequenceEqual(new List<string> { "A", "B", "D" }, StringComparer.OrdinalIgnoreCase)).Throws<AssertionException>();
await Assert.That(() => value.Should().SequenceEqual(new List<string> { "A", "B", "C" }, StringComparer.OrdinalIgnoreCase)).ThrowsNothing();
}

[Test]
public async Task SequenceEqual_Comparer_Chain()
{
var value = new List<string> { "a", "b", "c" };

var chain = value.Should().SequenceEqual(new List<string> { "A", "B", "C" }, StringComparer.OrdinalIgnoreCase);
await Assert.That(chain.Value).IsEqualTo(value);
await Assert.That(chain.And.Value).IsEqualTo(value);
}

[Test]
public async Task SequenceEqual_Predicate()
{
var value = new List<string> { "a", "b", "c" };

await Assert.That(() => value.Should().SequenceEqual(new List<string> { "A", "B", "D" }, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).Throws<AssertionException>();
await Assert.That(() => value.Should().SequenceEqual(new List<string> { "A", "B", "C" }, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).ThrowsNothing();
}

[Test]
public async Task SequenceEqual_Predicate_Chain()
{
var value = new List<string> { "a", "b", "c" };

var chain = value.Should().SequenceEqual(new List<string> { "A", "B", "C" }, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase));
await Assert.That(chain.Value).IsEqualTo(value);
await Assert.That(chain.And.Value).IsEqualTo(value);
}

[Test]
public async Task NotSequenceEqual_Null()
{
Expand Down Expand Up @@ -169,6 +207,46 @@ public async Task NotSequenceEqual_Chain()
await Assert.That(chain.And.Value).IsEqualTo(value);
}

[Test]
public async Task NotSequenceEqual_Comparer()
{
var value = new List<string> { "a", "b", "c" };

await Assert.That(() => value.Should().NotSequenceEqual(new List<string> { "A", "B", "C" }, StringComparer.OrdinalIgnoreCase)).Throws<AssertionException>()
.WithMessage("Value should not sequence equal [\"A\", \"B\", \"C\"].");
await Assert.That(() => value.Should().NotSequenceEqual(new List<string> { "A", "B", "D" }, StringComparer.OrdinalIgnoreCase)).ThrowsNothing();
}

[Test]
public async Task NotSequenceEqual_Comparer_Chain()
{
var value = new List<string> { "a", "b", "c" };

var chain = value.Should().NotSequenceEqual(new List<string> { "x", "y", "z" }, StringComparer.OrdinalIgnoreCase);
await Assert.That(chain.Value).IsEqualTo(value);
await Assert.That(chain.And.Value).IsEqualTo(value);
}

[Test]
public async Task NotSequenceEqual_Predicate()
{
var value = new List<string> { "a", "b", "c" };

await Assert.That(() => value.Should().NotSequenceEqual(new List<string> { "A", "B", "C" }, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).Throws<AssertionException>()
.WithMessage("Value should not sequence equal [\"A\", \"B\", \"C\"].");
await Assert.That(() => value.Should().NotSequenceEqual(new List<string> { "A", "B", "D" }, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).ThrowsNothing();
}

[Test]
public async Task NotSequenceEqual_Predicate_Chain()
{
var value = new List<string> { "a", "b", "c" };

var chain = value.Should().NotSequenceEqual(new List<string> { "x", "y", "z" }, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase));
await Assert.That(chain.Value).IsEqualTo(value);
await Assert.That(chain.And.Value).IsEqualTo(value);
}

[Test]
public async Task Contain_Null()
{
Expand Down
134 changes: 134 additions & 0 deletions src/MrKWatkins.Assertions.Tests/ObjectAssertionsTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -112,6 +112,72 @@ public async Task Equal_Chain()
await Assert.That(and.Value).IsEqualTo(value);
}

[Test]
public async Task Equal_Comparer_Null()
{
string? nullValue = null;
const string nonNullValue = "Not Null";

await Assert.That(() => nullValue.Should().Equal(nonNullValue, StringComparer.OrdinalIgnoreCase)).Throws<AssertionException>().WithMessage("Value should equal \"Not Null\" but was null.");
await Assert.That(() => nullValue.Should().Equal(nullValue, StringComparer.OrdinalIgnoreCase)).ThrowsNothing();
}

[Test]
public async Task Equal_Comparer()
{
const string value = "Test";
const string sameValueDifferentCase = "test";
const string otherValue = "Not Test";

await Assert.That(() => value.Should().Equal(otherValue, StringComparer.OrdinalIgnoreCase)).Throws<AssertionException>().WithMessage("Value should equal \"Not Test\" but was \"Test\".");
await Assert.That(() => value.Should().Equal(sameValueDifferentCase, StringComparer.OrdinalIgnoreCase)).ThrowsNothing();
}

[Test]
public async Task Equal_Comparer_Chain()
{
const string value = "Test";

var chain = value.Should().Equal("test", StringComparer.OrdinalIgnoreCase);
await Assert.That(chain.Value).IsEqualTo(value);

var and = chain.And;
await Assert.That(and.Value).IsEqualTo(value);
}

[Test]
public async Task Equal_Predicate_Null()
{
string? nullValue = null;
const string nonNullValue = "Not Null";

await Assert.That(() => nullValue.Should().Equal(nonNullValue, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).Throws<AssertionException>().WithMessage("Value should equal \"Not Null\" but was null.");
await Assert.That(() => nullValue.Should().Equal(nullValue, (a, b) => a is null && b is null)).ThrowsNothing();
}

[Test]
public async Task Equal_Predicate()
{
const string value = "Test";
const string sameValueDifferentCase = "test";
const string otherValue = "Not Test";

await Assert.That(() => value.Should().Equal(otherValue, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).Throws<AssertionException>().WithMessage("Value should equal \"Not Test\" but was \"Test\".");
await Assert.That(() => value.Should().Equal(sameValueDifferentCase, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).ThrowsNothing();
}

[Test]
public async Task Equal_Predicate_Chain()
{
const string value = "Test";

var chain = value.Should().Equal("test", (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase));
await Assert.That(chain.Value).IsEqualTo(value);

var and = chain.And;
await Assert.That(and.Value).IsEqualTo(value);
}

[Test]
public async Task NotEqual_Null()
{
Expand Down Expand Up @@ -145,6 +211,74 @@ public async Task NotEqual_Chain()
await Assert.That(and.Value).IsEqualTo(value);
}

[Test]
public async Task NotEqual_Comparer_Null()
{
string? nullValue = null;
const string nonNullValue = "Not Null";

await Assert.That(() => nullValue.Should().NotEqual(nonNullValue, StringComparer.OrdinalIgnoreCase)).ThrowsNothing();
await Assert.That(() => nullValue.Should().NotEqual(nullValue, StringComparer.OrdinalIgnoreCase)).Throws<AssertionException>().WithMessage("Value should not equal null.");
}

[Test]
public async Task NotEqual_Comparer()
{
const string value = "Test";
const string sameValueDifferentCase = "test";
const string otherValue = "Not Test";

await Assert.That(() => value.Should().NotEqual(otherValue, StringComparer.OrdinalIgnoreCase)).ThrowsNothing();
await Assert.That(() => value.Should().NotEqual(sameValueDifferentCase, StringComparer.OrdinalIgnoreCase)).Throws<AssertionException>().WithMessage("Value should not equal \"test\".");
}

[Test]
public async Task NotEqual_Comparer_Chain()
{
const string value = "Test";
const string otherValue = "Not Test";

var chain = value.Should().NotEqual(otherValue, StringComparer.OrdinalIgnoreCase);
await Assert.That(chain.Value).IsEqualTo(value);

var and = chain.And;
await Assert.That(and.Value).IsEqualTo(value);
}

[Test]
public async Task NotEqual_Predicate_Null()
{
string? nullValue = null;
const string nonNullValue = "Not Null";

await Assert.That(() => nullValue.Should().NotEqual(nonNullValue, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).ThrowsNothing();
await Assert.That(() => nullValue.Should().NotEqual(nullValue, (a, b) => a is null && b is null)).Throws<AssertionException>().WithMessage("Value should not equal null.");
}

[Test]
public async Task NotEqual_Predicate()
{
const string value = "Test";
const string sameValueDifferentCase = "test";
const string otherValue = "Not Test";

await Assert.That(() => value.Should().NotEqual(otherValue, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).ThrowsNothing();
await Assert.That(() => value.Should().NotEqual(sameValueDifferentCase, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase))).Throws<AssertionException>().WithMessage("Value should not equal \"test\".");
}

[Test]
public async Task NotEqual_Predicate_Chain()
{
const string value = "Test";
const string otherValue = "Not Test";

var chain = value.Should().NotEqual(otherValue, (a, b) => string.Equals(a, b, StringComparison.OrdinalIgnoreCase));
await Assert.That(chain.Value).IsEqualTo(value);

var and = chain.And;
await Assert.That(and.Value).IsEqualTo(value);
}

[Test]
public async Task BeTheSameInstanceAs()
{
Expand Down
Loading
Loading