Skip to content

feat: add support for cross-type equality assertions with IEquatable #3366

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
merged 5 commits into from
Oct 14, 2025
Merged

feat: add support for cross-type equality assertions with IEquatable #3366

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
a6ae1cf
feat: add support for cross-type equality assertions with IEquatable …
thomhurst Oct 14, 2025
e70d591
Add EquatableAssertion and NullableEquatableAssertion classes to asse…
thomhurst Oct 14, 2025
f22336c
feat: add overload resolution priorities to IsEqualTo assertions for …
thomhurst Oct 14, 2025
eac8a33
feat: Enhance assertion chaining and exception message assertions
thomhurst Oct 14, 2025
1b6dd66
feat: Add support for And/Or assertion chaining with evaluation logic…
thomhurst Oct 14, 2025
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
276 changes: 276 additions & 0 deletions TUnit.Assertions.Tests/AssertionBuilders/AndAssertionTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -31,4 +31,280 @@ public async Task Does_Not_Throw_For_Multiple_And()

await Assert.That(action).ThrowsNothing();
}

[Test]
public async Task Both_Assertions_Pass()
{
var value = 5;

await Assert.That(value)
.IsGreaterThan(3)
.And
.IsLessThan(10);
}

[Test]
public async Task Both_Assertions_Are_Evaluated_When_First_Passes()
{
var firstEvaluated = false;
var secondEvaluated = false;

var value = 5;

await Assert.That(value)
.Satisfies(_ =>
{
firstEvaluated = true;
return _ > 3;
})
.And
.Satisfies(_ =>
{
secondEvaluated = true;
return _ < 10;
});

await Assert.That(firstEvaluated).IsTrue();
await Assert.That(secondEvaluated).IsTrue();
}

[Test]
public async Task Second_Assertion_Not_Evaluated_When_First_Fails()
{
var firstEvaluated = false;
var secondEvaluated = false;

var value = 5;

var action = async () => await Assert.That(value)
.Satisfies(_ =>
{
firstEvaluated = true;
return _ > 10; // This will fail
})
.And
.Satisfies(_ =>
{
secondEvaluated = true;
return _ < 20;
});

await Assert.That(action).Throws<AssertionException>();
await Assert.That(firstEvaluated).IsTrue();
await Assert.That(secondEvaluated).IsFalse();
}

[Test]
public async Task Error_Message_Shows_Combined_Expectations_When_Second_Fails()
{
var value = 5;

var action = async () => await Assert.That(value)
.IsGreaterThan(3)
.And
.IsLessThan(4);

var exception = await Assert.That(action).Throws<AssertionException>();

await Assert.That(exception.Message)
.Contains("to be greater than 3")
.And
.Contains("to be less than 4");
}

[Test]
public async Task Error_Message_Shows_First_Expectation_When_First_Fails()
{
var value = 5;

var action = async () => await Assert.That(value)
.IsGreaterThan(10)
.And
.IsLessThan(20);

var exception = await Assert.That(action).Throws<AssertionException>();

await Assert.That(exception.Message)
.Contains("to be greater than 10");
}

[Test]
public async Task Three_Way_And_Chain_All_Pass()
{
var value = 5;

await Assert.That(value)
.IsGreaterThan(3)
.And
.IsLessThan(10)
.And
.IsEqualTo(5);
}

[Test]
public async Task Three_Way_And_Chain_Middle_Fails()
{
var firstEvaluated = false;
var secondEvaluated = false;
var thirdEvaluated = false;

var value = 5;

var action = async () => await Assert.That(value)
.Satisfies(_ =>
{
firstEvaluated = true;
return _ > 3; // Passes
})
.And
.Satisfies(_ =>
{
secondEvaluated = true;
return _ > 10; // Fails
})
.And
.Satisfies(_ =>
{
thirdEvaluated = true;
return _ < 20;
});

await Assert.That(action).Throws<AssertionException>();
await Assert.That(firstEvaluated).IsTrue();
await Assert.That(secondEvaluated).IsTrue();
await Assert.That(thirdEvaluated).IsFalse();
}

[Test]
public async Task Three_Way_And_Chain_Last_Fails()
{
var firstEvaluated = false;
var secondEvaluated = false;
var thirdEvaluated = false;

var value = 5;

var action = async () => await Assert.That(value)
.Satisfies(_ =>
{
firstEvaluated = true;
return _ > 3; // Passes
})
.And
.Satisfies(_ =>
{
secondEvaluated = true;
return _ < 10; // Passes
})
.And
.Satisfies(_ =>
{
thirdEvaluated = true;
return _ > 20; // Fails
});

await Assert.That(action).Throws<AssertionException>();
await Assert.That(firstEvaluated).IsTrue();
await Assert.That(secondEvaluated).IsTrue();
await Assert.That(thirdEvaluated).IsTrue();
}

[Test]
public async Task Within_Assert_Multiple_Both_Assertions_Evaluated()
{
var firstEvaluated = false;
var secondEvaluated = false;

var action = async () =>
{
using (Assert.Multiple())
{
await Assert.That(5)
.Satisfies(_ =>
{
firstEvaluated = true;
return _ > 10; // Fails
})
.And
.Satisfies(_ =>
{
secondEvaluated = true;
return _ < 20;
});
}
};

await Assert.That(action).Throws<Exception>();
await Assert.That(firstEvaluated).IsTrue();
await Assert.That(secondEvaluated).IsFalse();
}

[Test]
public async Task Within_Assert_Multiple_Combined_Error_Message_When_Second_Fails()
{
var action = async () =>
{
using (Assert.Multiple())
{
await Assert.That(5)
.IsGreaterThan(3)
.And
.IsLessThan(4);
}
};

var exception = await Assert.That(action).Throws<Exception>();

await Assert.That(exception.Message)
.Contains("to be greater than 3")
.And
.Contains("to be less than 4");
}

[Test]
public async Task Evaluation_Order_Verified_With_Counter()
{
var evaluationOrder = new List<int>();

var value = 5;

await Assert.That(value)
.Satisfies(_ =>
{
evaluationOrder.Add(1);
return _ > 3;
})
.And
.Satisfies(_ =>
{
evaluationOrder.Add(2);
return _ < 10;
});

await Assert.That(evaluationOrder).HasCount().EqualTo(2);
await Assert.That(evaluationOrder[0]).IsEqualTo(1);
await Assert.That(evaluationOrder[1]).IsEqualTo(2);
}

[Test]
public async Task And_With_Collection_Assertions()
{
var collection = new[] { 1, 2, 3, 4, 5 };

await Assert.That(collection)
.Contains(3)
.And
.HasCount().EqualTo(5);
}

[Test]
public async Task And_With_String_Assertions()
{
var text = "Hello World";

await Assert.That(text)
.Contains("Hello")
.And
.HasLength(11);
}
}
Loading
Loading