Simplify IsIn / IsNotIn assertions

TUnit.Assertions.SourceGenerator/Generators/MethodAssertionGenerator.cs

@@ -19,7 +19,7 @@
 public sealed class MethodAssertionGenerator : IIncrementalGenerator
 {
     private static readonly DiagnosticDescriptor MethodMustBeStaticRule = new DiagnosticDescriptor(
         id: "TUNITGEN001",
         title: "Method must be static",
         messageFormat: "Method '{0}' decorated with [GenerateAssertion] must be static",
         category: "TUnit.Assertions.SourceGenerator",
@@ -28,7 +28,7 @@
         description: "Methods decorated with [GenerateAssertion] must be static to be used in generated assertions.");
 
     private static readonly DiagnosticDescriptor MethodMustHaveParametersRule = new DiagnosticDescriptor(
         id: "TUNITGEN002",
         title: "Method must have at least one parameter",
         messageFormat: "Method '{0}' decorated with [GenerateAssertion] must have at least one parameter (the value to assert)",
         category: "TUnit.Assertions.SourceGenerator",
@@ -37,9 +37,9 @@
         description: "Methods decorated with [GenerateAssertion] must have at least one parameter representing the value being asserted.");
 
     private static readonly DiagnosticDescriptor UnsupportedReturnTypeRule = new DiagnosticDescriptor(
         id: "TUNITGEN003",
         title: "Unsupported return type",
         messageFormat: "Method '{0}' decorated with [GenerateAssertion] has unsupported return type '{1}'. Supported types are: bool, AssertionResult, Task<bool>, Task<AssertionResult>",
         category: "TUnit.Assertions.SourceGenerator",
         defaultSeverity: DiagnosticSeverity.Error,
         isEnabledByDefault: true,
@@ -459,9 +459,10 @@
 
         if (data.IsExtensionMethod)
         {
-            // Extension method syntax: value.MethodName<T1, T2>(params)
+            // Extension method syntax: value!.MethodName<T1, T2>(params)
+            // Use null-forgiving operator since we've already checked for null above
             var paramList = string.Join(", ", data.AdditionalParameters.Select(p => $"_{p.Name}"));
-            return $"value.{methodName}{typeArguments}({paramList})";
+            return $"value!.{methodName}{typeArguments}({paramList})";
         }
         else
         {
@@ -502,14 +503,18 @@
         // Additional parameters
         foreach (var param in data.AdditionalParameters)
         {
-            sb.Append($", {param.Type.ToDisplayString()} {param.Name}");
+            var paramsModifier = param.IsParams ? "params " : "";
+            sb.Append($", {paramsModifier}{param.Type.ToDisplayString()} {param.Name}");
         }
 
-        // CallerArgumentExpression parameters
+        // CallerArgumentExpression parameters (skip for params since params must be last)
         for (int i = 0; i < data.AdditionalParameters.Length; i++)
         {
             var param = data.AdditionalParameters[i];
-            sb.Append($", [CallerArgumentExpression(nameof({param.Name}))] string? {param.Name}Expression = null");
+            if (!param.IsParams)
+            {
+                sb.Append($", [CallerArgumentExpression(nameof({param.Name}))] string? {param.Name}Expression = null");
+            }
         }
 
         sb.AppendLine(")");
@@ -528,7 +533,9 @@
         // Build expression string
         if (data.AdditionalParameters.Length > 0)
         {
-            var exprList = string.Join(", ", data.AdditionalParameters.Select(p => $"{{{p.Name}Expression}}"));
+            // For params parameters, use parameter name directly (no Expression suffix since we didn't generate it)
+            var exprList = string.Join(", ", data.AdditionalParameters.Select(p =>
+                p.IsParams ? $"{{{p.Name}}}" : $"{{{p.Name}Expression}}"));
             sb.AppendLine($"        source.Context.ExpressionBuilder.Append($\".{methodName}({exprList})\");");
         }
         else

TUnit.Assertions/Assertions/GenericAssertions.cs

@@ -0,0 +1,42 @@
+using TUnit.Assertions.Attributes;
+
+namespace TUnit.Assertions.Assertions;
+
+internal static class GenericAssertions
+{
+    [GenerateAssertion]
+    public static bool IsIn<T>(this T value, IEnumerable<T> collection)
+    {
+        return collection.Contains(value);
+    }
+
+    [GenerateAssertion]
+    public static bool IsIn<T>(this T value, IEnumerable<T> collection, IEqualityComparer<T> equalityComparer)
+    {
+        return collection.Contains(value, equalityComparer);
+    }
+
+    [GenerateAssertion]
+    public static bool IsIn<T>(this T value, params T[] collection)
+    {
+        return collection.Contains(value);
+    }
+
+    [GenerateAssertion]
+    public static bool IsNotIn<T>(this T value, IEnumerable<T> collection)
+    {
+        return !collection.Contains(value);
+    }
+
+    [GenerateAssertion]
+    public static bool IsNotIn<T>(this T value, IEnumerable<T> collection, IEqualityComparer<T> equalityComparer)
+    {
+        return !collection.Contains(value, equalityComparer);
+    }
+
+    [GenerateAssertion]
+    public static bool IsNotIn<T>(this T value, params T[] collection)
+    {
+        return !collection.Contains(value);
+    }
+}

TUnit.Assertions/Extensions/AssertionExtensions.cs

@@ -753,16 +753,22 @@ public static NotStructuralEquivalencyAssertion<TValue> IsNotEquivalentTo<TValue
     }
 
     /// <summary>
-    /// Asserts that the value satisfies the specified predicate.
-    /// Example: await Assert.That(x).Satisfies(v => v > 0 && v < 100);
+    /// Asserts that a mapped Task value satisfies custom assertions on the unwrapped result.
+    /// Maps the source value using a selector that returns a Task, then runs assertions on the awaited result.
+    /// Example: await Assert.That(model).Satisfies(m => m.AsyncValue, assert => assert.IsEqualTo("Hello"));
     /// </summary>
-    public static SatisfiesAssertion<TValue> Satisfies<TValue>(
+    public static AsyncMappedSatisfiesAssertion<TValue, TMapped> Satisfies<TValue, TMapped>(
         this IAssertionSource<TValue> source,
-        Func<TValue?, bool> predicate,
-        [CallerArgumentExpression(nameof(predicate))] string? expression = null)
+        Func<TValue?, Task<TMapped?>> selector,
+        Func<ValueAssertion<TMapped>, Assertion<TMapped>> assertions,
+        [CallerArgumentExpression(nameof(selector))] string? selectorExpression = null)
     {
-        source.Context.ExpressionBuilder.Append($".Satisfies({expression})");
-        return new SatisfiesAssertion<TValue>(source.Context, predicate, expression ?? "predicate");
+        source.Context.ExpressionBuilder.Append($".Satisfies({selectorExpression}, ...)");
+        return new AsyncMappedSatisfiesAssertion<TValue, TMapped>(
+            source.Context,
+            selector!,
+            assertions,
+            selectorExpression ?? "selector");
     }
 
     /// <summary>
@@ -785,46 +791,16 @@ public static MappedSatisfiesAssertion<TValue, TMapped> Satisfies<TValue, TMappe
     }
 
     /// <summary>
-    /// Asserts that an async-mapped value satisfies custom assertions.
-    /// Maps the source value using an async selector, then runs assertions on the mapped value.
-    /// Example: await Assert.That(model).Satisfies(m => m.GetNameAsync(), assert => assert.IsEqualTo("John"));
-    /// </summary>
-    public static AsyncMappedSatisfiesAssertion<TValue, TMapped> Satisfies<TValue, TMapped>(
-        this IAssertionSource<TValue> source,
-        Func<TValue?, Task<TMapped>> selector,
-        Func<ValueAssertion<TMapped>, Assertion<TMapped>?> assertions,
-        [CallerArgumentExpression(nameof(selector))] string? selectorExpression = null)
-    {
-        source.Context.ExpressionBuilder.Append($".Satisfies({selectorExpression}, ...)");
-        return new AsyncMappedSatisfiesAssertion<TValue, TMapped>(
-            source.Context,
-            selector,
-            assertions,
-            selectorExpression ?? "selector");
-    }
-
-    /// <summary>
-    /// Asserts that the value is in the specified collection (params array convenience method).
-    /// Example: await Assert.That(5).IsIn(1, 3, 5, 7, 9);
-    /// </summary>
-    public static IsInAssertion<TValue> IsIn<TValue>(
-        this IAssertionSource<TValue> source,
-        params TValue[] collection)
-    {
-        source.Context.ExpressionBuilder.Append($".IsIn({string.Join(", ", collection)})");
-        return new IsInAssertion<TValue>(source.Context, collection);
-    }
-
-    /// <summary>
-    /// Asserts that the value is NOT in the specified collection (params array convenience method).
-    /// Example: await Assert.That(4).IsNotIn(1, 3, 5, 7, 9);
+    /// Asserts that the value satisfies the specified predicate.
+    /// Example: await Assert.That(x).Satisfies(v => v > 0 && v < 100);
     /// </summary>
-    public static IsNotInAssertion<TValue> IsNotIn<TValue>(
+    public static SatisfiesAssertion<TValue> Satisfies<TValue>(
         this IAssertionSource<TValue> source,
-        params TValue[] collection)
+        Func<TValue?, bool> predicate,
+        [CallerArgumentExpression(nameof(predicate))] string? expression = null)
     {
-        source.Context.ExpressionBuilder.Append($".IsNotIn({string.Join(", ", collection)})");
-        return new IsNotInAssertion<TValue>(source.Context, collection);
+        source.Context.ExpressionBuilder.Append($".Satisfies({expression})");
+        return new SatisfiesAssertion<TValue>(source.Context, predicate, expression ?? "predicate");
     }
 
     /// <summary>