Fix TUnit0014 on interface implementations, Aspire exit-code culture and [AssertionFrom] expectation messages

docs/docs/assertions/extensibility/source-generator-assertions.md

@@ -238,9 +238,9 @@ Use `[AssertionFrom]` to create assertions from existing methods in libraries or
 ```csharp
 using TUnit.Assertions.Attributes;
 
-[AssertionFrom<string>(nameof(string.IsNullOrEmpty), CustomName = "IsBlank", ExpectationMessage = "to be null or empty")]
-[AssertionFrom<string>(nameof(string.StartsWith), CustomName = "BeginsWithText", ExpectationMessage = "to start with {value}")]
-[AssertionFrom<string>(nameof(string.EndsWith), CustomName = "EndsWithText", ExpectationMessage = "to end with {value}")]
+[AssertionFrom<string>(nameof(string.IsNullOrEmpty), CustomName = "IsBlank", ExpectationMessage = "be null or empty")]
+[AssertionFrom<string>(nameof(string.StartsWith), CustomName = "BeginsWithText", ExpectationMessage = "start with '{value}'")]
+[AssertionFrom<string>(nameof(string.EndsWith), CustomName = "EndsWithText", ExpectationMessage = "end with '{value}'")]
 public static partial class StringAssertionExtensions
 {
 }
@@ -256,7 +256,7 @@ await Assert.That("hello").BeginsWithText("he");
 ### With Custom Names
 
 ```csharp
-[AssertionFrom<string>(nameof(string.Contains), CustomName = "Has", ExpectationMessage = "to have '{value}'")]
+[AssertionFrom<string>(nameof(string.Contains), CustomName = "Has", ExpectationMessage = "have '{value}'")]
 public static partial class StringAssertionExtensions
 {
 }
@@ -271,7 +271,7 @@ await Assert.That("hello").Has("world");        // ❌ Fails: "Expected to have
 For `bool`-returning methods, you can generate negated versions:
 
 ```csharp
-[AssertionFrom<string>(nameof(string.Contains), CustomName = "LacksText", NegateLogic = true, ExpectationMessage = "to not contain '{value}'")]
+[AssertionFrom<string>(nameof(string.Contains), CustomName = "LacksText", NegateLogic = true, ExpectationMessage = "contain '{value}'")]
 public static partial class StringAssertionExtensions
 {
 }
@@ -283,11 +283,19 @@ await Assert.That("hello").LacksText("ell");  // ❌ Fails: "Expected to not con
 
 **Note:** Negation only works with `bool`-returning methods. `AssertionResult` methods determine their own pass/fail logic.
 
+### How `ExpectationMessage` Is Rendered
+
+For `[AssertionFrom]`, the message is the phrase that follows "Expected to". Write it in the positive form, without the leading "to", as in the examples above:
+
+- The generator adds "to", plus "not" when `NegateLogic = true`: `"contain '{value}'"` renders as "to contain 'x'", or "to not contain 'x'" when negated.
+- For compatibility, a leading "to" is ignored (`"to be null or empty"` renders the same as `"be null or empty"`), and a phrase that already starts with "not" (`"to not contain '{value}'"`) is used as written rather than negated again.
+- `{paramName}` is replaced with that parameter's value. Everything else is literal text: write `{{` and `}}` for literal braces, and a placeholder that names no parameter is printed as is.
+
 ### Referencing Methods on Different Types
 
 ```csharp
 // Reference static methods from another type
-[AssertionFrom<string>(typeof(StringHelper), nameof(StringHelper.IsValidEmail), ExpectationMessage = "to be a valid email")]
+[AssertionFrom<string>(typeof(StringHelper), nameof(StringHelper.IsValidEmail), ExpectationMessage = "be a valid email")]
 public static partial class StringAssertionExtensions
 {
 }

src/TUnit.Analyzers/PublicMethodMissingTestAttributeAnalyzer.cs

@@ -54,6 +54,7 @@ private void AnalyzeSymbol(SymbolAnalysisContext context)
                      .Where(x => !IsDisposableDispose(x))
                      .Where(x => !IsAsyncDisposableDispose(x))
                      .Where(x => !IsInitializeAsync(x))
+                     .Where(x => !ImplementsInterfaceMember(x))
                      .Where(x => !IsTestDataSource(x, testMethods)))
         {
             context.ReportDiagnostic(Diagnostic.Create(Rules.PublicMethodMissingTestAttribute, method.Locations.FirstOrDefault()));
@@ -74,6 +75,29 @@ private bool IsTestDataSource(IMethodSymbol methodSymbol, IMethodSymbol[] testMe
         return false;
     }
 
+    /// <summary>
+    /// Whether <paramref name="method"/> implicitly implements an interface member of its containing type (e.g.
+    /// <c>ITestStartEventReceiver.OnTestStart</c>). Such a method cannot be made private, so the diagnostic's advice
+    /// would not apply.
+    /// </summary>
+    private static bool ImplementsInterfaceMember(IMethodSymbol method)
+    {
+        var containingType = method.ContainingType;
+
+        foreach (var @interface in containingType.AllInterfaces)
+        {
+            foreach (var member in @interface.GetMembers(method.Name))
+            {
+                if (SymbolEqualityComparer.Default.Equals(containingType.FindImplementationForInterfaceMember(member), method))
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
     private bool IsDisposableDispose(IMethodSymbol method)
     {
         return method is { ReturnsVoid: true, Name: "Dispose" } &&

src/TUnit.Aspire.Core/AspireFixture.cs

@@ -1,6 +1,7 @@
 using System.Collections.Concurrent;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using System.Globalization;
 using System.Text;
 using Aspire.Hosting;
 using Aspire.Hosting.ApplicationModel;
@@ -1705,13 +1706,22 @@ internal static string FormatExitCode(int? exitCode)
             return "(unknown)";
         }
 
-        return DecodeExitCode(code) is { } meaning ? $"{code} ({meaning})" : code.ToString();
+        var number = FormatExitCodeNumber(code);
+        return DecodeExitCode(code) is { } meaning ? $"{number} ({meaning})" : number;
     }
 
+    /// <summary>
+    /// Formats an exit code with the invariant culture: exit codes are identifiers to search for, and cultures such
+    /// as sv-SE would otherwise print negative Windows codes with U+2212 MINUS SIGN.
+    /// </summary>
+    private static string FormatExitCodeNumber(int code) => code.ToString(CultureInfo.InvariantCulture);
+
     /// <summary>One-line human description of a resource's failure state for the concise exception message.</summary>
     internal static string DescribeState(in ResourceDiagnosis d) => d.Class switch
     {
-        ResourceFailureClass.OutOfMemory => $"{d.State}, exit code {d.ExitCode} (OOM / SIGKILL)",
+        ResourceFailureClass.OutOfMemory => d.ExitCode is int oomCode
+            ? $"{d.State}, exit code {FormatExitCodeNumber(oomCode)} (OOM / SIGKILL)"
+            : $"{d.State} (OOM / SIGKILL)",
         ResourceFailureClass.NonZeroExit => $"{d.State}, exit code {FormatExitCode(d.ExitCode)}",
         ResourceFailureClass.CrashedNoCode => $"{d.State} (no exit code)",
         ResourceFailureClass.HealthCheckFailing => d.Detail is { Length: > 0 } health
@@ -1807,7 +1817,7 @@ private static string SummarizeHealthReport(HealthReportSnapshot report)
                 }
 
                 return dep.Snapshot.ExitCode is int code
-                    ? $"'{depName}' ({depState}, exit code {code})"
+                    ? $"'{depName}' ({depState}, exit code {FormatExitCodeNumber(code)})"
                     : $"'{depName}' ({depState})";
             }
 
@@ -1987,7 +1997,7 @@ private void AppendResourceDiagnosticBlock(
         sb.AppendLine($"  State:      {diagnosis.State}");
         if (diagnosis.ExitCode is int code)
         {
-            sb.Append($"  Exit code:  {code}");
+            sb.Append($"  Exit code:  {FormatExitCodeNumber(code)}");
             if (DecodeExitCode(code) is { } meaning)
             {
                 sb.Append($" ({meaning})");
@@ -2078,7 +2088,7 @@ private static void AppendDependencyChain(StringBuilder sb, ResourceNotification
             if (notificationService.TryGetCurrentState(depName, out var dep) && dep is not null)
             {
                 var depState = dep.Snapshot.State?.Text ?? "unknown";
-                description = dep.Snapshot.ExitCode is int code ? $"{depState}, exit code {code}" : depState;
+                description = dep.Snapshot.ExitCode is int code ? $"{depState}, exit code {FormatExitCodeNumber(code)}" : depState;
             }
             else
             {