Skip to content

More Covariant Generic Assertions for Enumerable.Contains(Func) #1700

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
thomhurst merged 5 commits into from
Jan 28, 2025
Merged

More Covariant Generic Assertions for Enumerable.Contains(Func) #1700

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
aeb5a5a
More Covariant Generic Assertions for `Enumerable.Contains(Func)`
thomhurst Jan 27, 2025
b3c818f
More co-variant methods
thomhurst Jan 27, 2025
faf2f0d
Remove equality comparer parameter
thomhurst Jan 27, 2025
d0c80bf
EqualityComparer<TInner>.Default)
thomhurst Jan 27, 2025
eaf3e56
Merge branch 'main' into feature/more-covariant-assertions
thomhurst Jan 27, 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
12 changes: 6 additions & 6 deletions TUnit.Assertions.Tests/EnumerableTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -27,7 +27,7 @@ public async Task Enumerable_Contains_Matcher_Good()
{
int[] array = [1, 2, 3];

await Assert.That(array).Contains((int x) => x == 1);
await Assert.That(array).Contains(x => x == 1);
}

[Test]
Expand All @@ -36,7 +36,7 @@ public async Task Enumerable_Contains_Matcher_Bad()
int[] array = [1, 2, 3];

await Assert.That(
async () => await Assert.That(array).Contains((int x) => x == 4)
async () => await Assert.That(array).Contains(x => x == 4)
).Throws<AssertionException>();
}

Expand All @@ -45,7 +45,7 @@ public async Task Enumerable_ContainsOnly_Matcher_Good()
{
int[] array = [1, 2, 3];

await Assert.That(array).ContainsOnly((int x) => x < 10);
await Assert.That(array).ContainsOnly(x => x < 10);
}

[Test]
Expand All @@ -54,7 +54,7 @@ public async Task Enumerable_ContainsOnly_Matcher_Bad()
int[] array = [1, 2, 3];

await Assert.That(
async () => await Assert.That(array).ContainsOnly((int x) => x < 3)
async () => await Assert.That(array).ContainsOnly(x => x < 3)
).Throws<AssertionException>();
}

Expand All @@ -81,7 +81,7 @@ public async Task Enumerable_DoesNotContain_Matcher_Good()
{
int[] array = [1, 2, 3];

await Assert.That(array).DoesNotContain((int x) => x > 10);
await Assert.That(array).DoesNotContain(x => x > 10);
}

[Test]
Expand All @@ -90,7 +90,7 @@ public async Task Enumerable_DoesNotContain_Matcher_Bad()
int[] array = [1, 2, 3];

await Assert.That(
async () => await Assert.That(array).DoesNotContain((int x) => x < 3)
async () => await Assert.That(array).DoesNotContain(x => x < 3)
).Throws<AssertionException>();
}
}
36 changes: 36 additions & 0 deletions TUnit.Assertions.Tests/TypeInferenceTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,36 @@
namespace TUnit.Assertions.Tests;

public class TypeInferenceTests
{
[Test]
public async Task Enumerables()
{
IEnumerable<int> enumerable = [];

try
{
await Assert.That(enumerable)
.IsEmpty()
.And
.IsNotEmpty()
.And
.Contains(x => x > 1)
.And
.ContainsOnly(x => x > 1)
.And
.DoesNotContain(x => x > 1)
.And
.DoesNotContain(x => x > 1)
.And
.HasDistinctItems()
.And
.HasSingleItem()
.And.HasCount().EqualTo(0);
}
catch
{
// Don't care for assertion failures
// Just want to surface any compiler errors if we knock out type inference
}
}
}
16 changes: 8 additions & 8 deletions TUnit.Assertions/AssertConditions/Operators/DelegateAnd.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,21 +11,21 @@ public static DelegateAnd<TActual> Create(AssertionBuilder assertionBuilder)
return new DelegateAnd<TActual>(assertionBuilder);
}

public string? ActualExpression => assertionBuilder.ActualExpression;
string? ISource.ActualExpression => ((ISource)assertionBuilder).ActualExpression;

public Stack<BaseAssertCondition> Assertions => ((ISource)assertionBuilder).Assertions;
public ValueTask<AssertionData> AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
public StringBuilder ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;
Stack<BaseAssertCondition> ISource.Assertions => ((ISource)assertionBuilder).Assertions;
ValueTask<AssertionData> ISource.AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
StringBuilder ISource.ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;

public ISource AppendExpression(string expression)
ISource ISource.AppendExpression(string expression)
{
assertionBuilder.AppendExpression(expression);
((ISource)assertionBuilder).AppendExpression(expression);
return this;
}

public ISource WithAssertion(BaseAssertCondition assertCondition)
ISource ISource.WithAssertion(BaseAssertCondition assertCondition)
{
assertionBuilder.WithAssertion(assertCondition);
((ISource)assertionBuilder).WithAssertion(assertCondition);
return this;
}
}
16 changes: 8 additions & 8 deletions TUnit.Assertions/AssertConditions/Operators/DelegateOr.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,21 +11,21 @@ public static DelegateOr<TActual> Create(AssertionBuilder assertionBuilder)
return new DelegateOr<TActual>(assertionBuilder);
}

public string? ActualExpression => assertionBuilder.ActualExpression;
string? ISource.ActualExpression => ((ISource)assertionBuilder).ActualExpression;

public Stack<BaseAssertCondition> Assertions => ((ISource)assertionBuilder).Assertions;
public ValueTask<AssertionData> AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
public StringBuilder ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;
Stack<BaseAssertCondition> ISource.Assertions => ((ISource)assertionBuilder).Assertions;
ValueTask<AssertionData> ISource.AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
StringBuilder ISource.ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;

public ISource AppendExpression(string expression)
ISource ISource.AppendExpression(string expression)
{
assertionBuilder.AppendExpression(expression);
((ISource)assertionBuilder).AppendExpression(expression);
return this;
}

public ISource WithAssertion(BaseAssertCondition assertCondition)
ISource ISource.WithAssertion(BaseAssertCondition assertCondition)
{
assertionBuilder.WithAssertion(assertCondition);
((ISource)assertionBuilder).WithAssertion(assertCondition);
return this;
}
}
17 changes: 8 additions & 9 deletions TUnit.Assertions/AssertConditions/Operators/ValueAnd.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,21 +11,20 @@ public static ValueAnd<TActual> Create(AssertionBuilder assertionBuilder)
return new ValueAnd<TActual>(assertionBuilder);
}

public Stack<BaseAssertCondition> Assertions => ((ISource)assertionBuilder).Assertions;
public ValueTask<AssertionData> AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
public StringBuilder ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;

public string? ActualExpression => assertionBuilder.ActualExpression;
Stack<BaseAssertCondition> ISource.Assertions => ((ISource)assertionBuilder).Assertions;
ValueTask<AssertionData> ISource.AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
StringBuilder ISource.ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;
string? ISource.ActualExpression => ((ISource)assertionBuilder).ActualExpression;

public ISource AppendExpression(string expression)
ISource ISource.AppendExpression(string expression)
{
assertionBuilder.AppendExpression(expression);
((ISource)assertionBuilder).AppendExpression(expression);
return this;
}

public ISource WithAssertion(BaseAssertCondition assertCondition)
ISource ISource.WithAssertion(BaseAssertCondition assertCondition)
{
assertionBuilder.WithAssertion(assertCondition);
((ISource)assertionBuilder).WithAssertion(assertCondition);
return this;
}
}
16 changes: 8 additions & 8 deletions TUnit.Assertions/AssertConditions/Operators/ValueDelegateAnd.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,21 +11,21 @@ public static ValueDelegateAnd<TActual> Create(AssertionBuilder assertionBuilder
return new ValueDelegateAnd<TActual>(assertionBuilder);
}

public string? ActualExpression => assertionBuilder.ActualExpression;
string? ISource.ActualExpression => ((ISource)assertionBuilder).ActualExpression;

public Stack<BaseAssertCondition> Assertions => ((ISource)assertionBuilder).Assertions;
public ValueTask<AssertionData> AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
public StringBuilder ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;
Stack<BaseAssertCondition> ISource.Assertions => ((ISource)assertionBuilder).Assertions;
ValueTask<AssertionData> ISource.AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
StringBuilder ISource.ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;

public ISource AppendExpression(string expression)
ISource ISource.AppendExpression(string expression)
{
assertionBuilder.AppendExpression(expression);
((ISource)assertionBuilder).AppendExpression(expression);
return this;
}

public ISource WithAssertion(BaseAssertCondition assertCondition)
ISource ISource.WithAssertion(BaseAssertCondition assertCondition)
{
assertionBuilder.WithAssertion(assertCondition);
((ISource)assertionBuilder).WithAssertion(assertCondition);
return this;
}
}
16 changes: 8 additions & 8 deletions TUnit.Assertions/AssertConditions/Operators/ValueDelegateOr.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,21 +11,21 @@ public static ValueDelegateOr<TActual> Create(AssertionBuilder assertionBuilder)
return new ValueDelegateOr<TActual>(assertionBuilder);
}

public string? ActualExpression => assertionBuilder.ActualExpression;
string? ISource.ActualExpression => ((ISource)assertionBuilder).ActualExpression;

public Stack<BaseAssertCondition> Assertions => ((ISource)assertionBuilder).Assertions;
public ValueTask<AssertionData> AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
public StringBuilder ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;
Stack<BaseAssertCondition> ISource.Assertions => ((ISource)assertionBuilder).Assertions;
ValueTask<AssertionData> ISource.AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
StringBuilder ISource.ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;

public ISource AppendExpression(string expression)
ISource ISource.AppendExpression(string expression)
{
assertionBuilder.AppendExpression(expression);
((ISource)assertionBuilder).AppendExpression(expression);
return this;
}

public ISource WithAssertion(BaseAssertCondition assertCondition)
ISource ISource.WithAssertion(BaseAssertCondition assertCondition)
{
assertionBuilder.WithAssertion(assertCondition);
((ISource)assertionBuilder).WithAssertion(assertCondition);
return this;
}
}
16 changes: 8 additions & 8 deletions TUnit.Assertions/AssertConditions/Operators/ValueOr.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,21 +6,21 @@ namespace TUnit.Assertions.AssertConditions.Operators;

public class ValueOr<TActual>(AssertionBuilder assertionBuilder) : IValueSource<TActual>
{
public string? ActualExpression => assertionBuilder.ActualExpression;
string? ISource.ActualExpression => ((ISource)assertionBuilder).ActualExpression;

public Stack<BaseAssertCondition> Assertions => ((ISource)assertionBuilder).Assertions;
public ValueTask<AssertionData> AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
public StringBuilder ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;
Stack<BaseAssertCondition> ISource.Assertions => ((ISource)assertionBuilder).Assertions;
ValueTask<AssertionData> ISource.AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
StringBuilder ISource.ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;

public ISource AppendExpression(string expression)
ISource ISource.AppendExpression(string expression)
{
assertionBuilder.AppendExpression(expression);
((ISource)assertionBuilder).AppendExpression(expression);
return this;
}

public ISource WithAssertion(BaseAssertCondition assertCondition)
ISource ISource.WithAssertion(BaseAssertCondition assertCondition)
{
assertionBuilder.WithAssertion(assertCondition);
((ISource)assertionBuilder).WithAssertion(assertCondition);
return this;
}
}
2 changes: 1 addition & 1 deletion TUnit.Assertions/AssertConditions/SatisfiesAssertCondition.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -37,7 +37,7 @@ protected override async Task<AssertionResult> GetResult(TActual? actualValue, E

var assertion = _assertionBuilder(innerAssertionBuilder);

foreach (var baseAssertCondition in assertion.Assertions)
foreach (var baseAssertCondition in ((ISource)assertion).Assertions)
{
var result = await baseAssertCondition.Assert(innerItem, exception, "");

Expand Down
5 changes: 3 additions & 2 deletions TUnit.Assertions/AssertionBuilders/AndAssertionBuilder.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,9 +4,10 @@

namespace TUnit.Assertions.AssertionBuilders;

public class AndAssertionBuilder<TActual> : AssertionBuilder, IAndAssertionBuilder
public class AndAssertionBuilder : AssertionBuilder, IAndAssertionBuilder
{
internal AndAssertionBuilder(AssertionBuilder assertionBuilder) : base(((ISource)assertionBuilder).AssertionDataTask, assertionBuilder.ActualExpression!, (
internal AndAssertionBuilder(AssertionBuilder assertionBuilder) : base(((ISource)assertionBuilder).AssertionDataTask, (
(ISource)assertionBuilder).ActualExpression!, (
(ISource)assertionBuilder).ExpressionBuilder, ((ISource)assertionBuilder).Assertions)
{
if (((ISource)assertionBuilder).Assertions.Any(a => a is OrAssertCondition))
Expand Down
3 changes: 1 addition & 2 deletions TUnit.Assertions/AssertionBuilders/AndConvertedTypeAssertionBuilder.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,4 @@
using System.Text;
using TUnit.Assertions.AssertConditions;
using TUnit.Assertions.AssertConditions;
using TUnit.Assertions.AssertConditions.Interfaces;
using TUnit.Assertions.Assertions.Generics.Conditions;

Expand Down
19 changes: 10 additions & 9 deletions TUnit.Assertions/AssertionBuilders/AssertionBuilder.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,32 +18,32 @@ public abstract class AssertionBuilder : ISource
public AssertionBuilder(ISource source)
{
_assertionDataTask = source.AssertionDataTask;
ActualExpression = source.ActualExpression;
_actualExpression = source.ActualExpression;
_expressionBuilder = source.ExpressionBuilder;
_assertions = source.Assertions;
}

public AssertionBuilder(ValueTask<AssertionData> assertionDataTask, string actualExpression, StringBuilder expressionBuilder, Stack<BaseAssertCondition> assertions)
{
_assertionDataTask = assertionDataTask;
ActualExpression = actualExpression;
_actualExpression = actualExpression;
_expressionBuilder = expressionBuilder;
_assertions = assertions;
}

public AssertionBuilder(ValueTask<AssertionData> assertionDataTask, string? actualExpression)
{
_assertionDataTask = assertionDataTask;
ActualExpression = actualExpression;
_actualExpression = actualExpression;

if (string.IsNullOrEmpty(actualExpression))
{
ActualExpression = null;
_actualExpression = null;
_expressionBuilder = new StringBuilder("Assert.That(UNKNOWN)");
}
else
{
ActualExpression = actualExpression;
_actualExpression = actualExpression;
_expressionBuilder = new StringBuilder("Assert.That(");
_expressionBuilder.Append(actualExpression);
_expressionBuilder.Append(')');
Expand All @@ -52,7 +52,7 @@ public AssertionBuilder(ValueTask<AssertionData> assertionDataTask, string? actu

StringBuilder ISource.ExpressionBuilder => _expressionBuilder;

public string? ActualExpression { get; }
string? ISource.ActualExpression => _actualExpression;

ValueTask<AssertionData> ISource.AssertionDataTask => _assertionDataTask;

Expand All @@ -62,8 +62,9 @@ public AssertionBuilder(ValueTask<AssertionData> assertionDataTask, string? actu
private readonly StringBuilder _expressionBuilder;
private readonly ValueTask<AssertionData> _assertionDataTask;
private readonly Stack<BaseAssertCondition> _assertions = new();
private readonly string? _actualExpression;

public ISource AppendExpression(string expression)
ISource ISource.AppendExpression(string expression)
{
if (!string.IsNullOrEmpty(expression))
{
Expand All @@ -81,7 +82,7 @@ internal AssertionBuilder AppendConnector(ChainType chainType)
return this;
}

return (AssertionBuilder)AppendExpression(chainType.ToString());
return (AssertionBuilder)((ISource)this).AppendExpression(chainType.ToString());
}

protected internal void AppendCallerMethod(string?[] expressions, [CallerMemberName] string methodName = "")
Expand Down Expand Up @@ -110,7 +111,7 @@ protected internal void AppendCallerMethod(string?[] expressions, [CallerMemberN
_expressionBuilder.Append(')');
}

public ISource WithAssertion(BaseAssertCondition assertCondition)
ISource ISource.WithAssertion(BaseAssertCondition assertCondition)
{
assertCondition = this switch
{
Expand Down
Loading