diff --git a/TUnit.Analyzers.CodeFixers/Base/AssertionRewriter.cs b/TUnit.Analyzers.CodeFixers/Base/AssertionRewriter.cs
index a5ef3fa98d..671ccf5c0f 100644
--- a/TUnit.Analyzers.CodeFixers/Base/AssertionRewriter.cs
+++ b/TUnit.Analyzers.CodeFixers/Base/AssertionRewriter.cs
@@ -41,7 +41,22 @@ protected AssertionRewriter(SemanticModel semanticModel)
public override SyntaxNode? VisitInvocationExpression(InvocationExpressionSyntax node)
{
- var convertedAssertion = ConvertAssertionIfNeeded(node);
+ // Wrap the conversion in try-catch to ensure one failing assertion doesn't break
+ // the conversion of all other assertions in the file
+ ExpressionSyntax? convertedAssertion;
+ try
+ {
+ convertedAssertion = ConvertAssertionIfNeeded(node);
+ }
+ catch (Exception ex) when (ex is InvalidOperationException or ArgumentException or NotSupportedException)
+ {
+ // If conversion fails for this specific assertion due to expected issues
+ // (e.g., invalid syntax, unsupported patterns), skip it and continue.
+ // This ensures partial conversion is better than no conversion.
+ // Unexpected exceptions will propagate for debugging.
+ return base.VisitInvocationExpression(node);
+ }
+
if (convertedAssertion != null)
{
var conversionTrivia = convertedAssertion.GetLeadingTrivia();
@@ -89,12 +104,88 @@ protected ExpressionSyntax CreateTUnitAssertion(
return CreateTUnitAssertionWithMessage(methodName, actualValue, null, additionalArguments);
}
+ ///
+ /// Creates a TUnit collection assertion for enumerable/collection types.
+ ///
+ ///
+ /// Note: We intentionally do NOT cast to IEnumerable<T> because:
+ /// 1. TUnit's Assert.That<T> overloads generally resolve correctly for arrays and collections
+ /// 2. Adding explicit casts creates noisy code that users would need to clean up
+ /// 3. If there's genuine overload ambiguity, users can add the cast manually
+ ///
+ protected ExpressionSyntax CreateTUnitCollectionAssertion(
+ string methodName,
+ ExpressionSyntax collectionValue,
+ params ArgumentSyntax[] additionalArguments)
+ {
+ return CreateTUnitAssertionWithMessage(methodName, collectionValue, null, additionalArguments);
+ }
+
+ ///
+ /// Ensures that ValueTask and Task types are properly awaited before being passed to Assert.That().
+ /// This is needed because TUnit's analyzer (TUnitAssertions0008) requires ValueTask to be awaited.
+ /// If the expression is already an await expression, it's returned as-is.
+ ///
+ private ExpressionSyntax EnsureTaskTypesAreAwaited(ExpressionSyntax expression)
+ {
+ // If already an await expression, no action needed
+ if (expression is AwaitExpressionSyntax)
+ {
+ return expression;
+ }
+
+ // Wrap semantic analysis in try-catch to handle TFM-specific failures
+ // This prevents AggregateException crashes in multi-target projects
+ try
+ {
+ // Try to get the type of the expression using semantic analysis
+ var typeInfo = SemanticModel.GetTypeInfo(expression);
+ if (typeInfo.Type is null || typeInfo.Type.TypeKind == TypeKind.Error)
+ {
+ return expression;
+ }
+
+ // Check if the type is ValueTask, ValueTask, Task, or Task
+ var typeName = typeInfo.Type.ToDisplayString();
+ var isTaskType = typeName.StartsWith("System.Threading.Tasks.ValueTask") ||
+ typeName.StartsWith("System.Threading.Tasks.Task") ||
+ typeName == "System.Threading.Tasks.ValueTask" ||
+ typeName == "System.Threading.Tasks.Task";
+
+ // Also check for the short names (when using directive is present)
+ if (!isTaskType && typeInfo.Type is INamedTypeSymbol namedType)
+ {
+ isTaskType = namedType.Name is "ValueTask" or "Task" &&
+ namedType.ContainingNamespace?.ToDisplayString() == "System.Threading.Tasks";
+ }
+
+ if (!isTaskType)
+ {
+ return expression;
+ }
+
+ // Wrap the expression in an await
+ var awaitKeyword = SyntaxFactory.Token(SyntaxKind.AwaitKeyword)
+ .WithTrailingTrivia(SyntaxFactory.Space);
+ return SyntaxFactory.AwaitExpression(awaitKeyword, expression);
+ }
+ catch (Exception ex) when (ex is InvalidOperationException or ArgumentException)
+ {
+ // Semantic analysis can fail in some TFM configurations (e.g., type not available
+ // in one target framework). Return expression unchanged and let the user handle it.
+ return expression;
+ }
+ }
+
protected ExpressionSyntax CreateTUnitAssertionWithMessage(
string methodName,
ExpressionSyntax actualValue,
ExpressionSyntax? message,
params ArgumentSyntax[] additionalArguments)
{
+ // Ensure ValueTask/Task types are properly awaited before passing to Assert.That
+ actualValue = EnsureTaskTypesAreAwaited(actualValue);
+
// Create Assert.That(actualValue)
var assertThatInvocation = SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
@@ -154,6 +245,9 @@ protected ExpressionSyntax CreateTUnitGenericAssertion(
TypeSyntax typeArg,
ExpressionSyntax? message)
{
+ // Ensure ValueTask/Task types are properly awaited before passing to Assert.That
+ actualValue = EnsureTaskTypesAreAwaited(actualValue);
+
// Create Assert.That(actualValue)
var assertThatInvocation = SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
@@ -414,24 +508,40 @@ protected static SyntaxTrivia CreateTodoComment(string message)
///
/// Determines if an invocation is a framework assertion method.
- /// Uses semantic analysis when available, with syntax-based fallback for resilience across TFMs.
+ /// IMPORTANT: Prioritizes syntax-based detection for deterministic results across TFMs.
+ /// This prevents AggregateException crashes in multi-target projects where semantic
+ /// analysis could produce different results for each target framework.
///
protected bool IsFrameworkAssertion(InvocationExpressionSyntax invocation)
{
- // Try semantic analysis first
- var symbolInfo = SemanticModel.GetSymbolInfo(invocation);
- if (symbolInfo.Symbol is IMethodSymbol methodSymbol)
+ // FIRST: Try syntax-based detection (deterministic across TFMs)
+ // This ensures consistent behavior for multi-target projects
+ if (IsFrameworkAssertionBySyntax(invocation))
{
- var namespaceName = methodSymbol.ContainingNamespace?.ToDisplayString() ?? "";
- if (IsFrameworkAssertionNamespace(namespaceName))
+ return true;
+ }
+
+ // SECOND: Fall back to semantic analysis for cases where syntax detection fails
+ // (e.g., aliased Assert types, extension methods, etc.)
+ try
+ {
+ var symbolInfo = SemanticModel.GetSymbolInfo(invocation);
+ if (symbolInfo.Symbol is IMethodSymbol methodSymbol)
{
- return true;
+ var namespaceName = methodSymbol.ContainingNamespace?.ToDisplayString() ?? "";
+ if (IsFrameworkAssertionNamespace(namespaceName))
+ {
+ return true;
+ }
}
}
+ catch (Exception ex) when (ex is InvalidOperationException or ArgumentException)
+ {
+ // Semantic analysis can fail in edge cases (e.g., incomplete compilation state).
+ // That's fine - we already tried syntax-based detection above.
+ }
- // Fallback: Syntax-based detection when semantic analysis fails
- // This ensures consistent behavior across TFMs
- return IsFrameworkAssertionBySyntax(invocation);
+ return false;
}
///
@@ -445,12 +555,28 @@ private bool IsFrameworkAssertionBySyntax(InvocationExpressionSyntax invocation)
return false;
}
- var targetType = memberAccess.Expression.ToString();
+ // Extract the simple type name from potentially qualified names
+ // e.g., "NUnit.Framework.Assert" -> "Assert", "Assert" -> "Assert"
+ var targetType = ExtractSimpleTypeName(memberAccess.Expression);
var methodName = memberAccess.Name.Identifier.Text;
return IsKnownAssertionTypeBySyntax(targetType, methodName);
}
+ ///
+ /// Extracts the simple type name from an expression.
+ /// Handles qualified names like "NUnit.Framework.Assert" by returning just "Assert".
+ ///
+ private static string ExtractSimpleTypeName(ExpressionSyntax expression)
+ {
+ return expression switch
+ {
+ IdentifierNameSyntax identifier => identifier.Identifier.Text,
+ MemberAccessExpressionSyntax memberAccess => memberAccess.Name.Identifier.Text,
+ _ => expression.ToString()
+ };
+ }
+
///
/// Checks if the target type and method name match known framework assertion patterns.
/// Override in derived classes to provide framework-specific patterns.
diff --git a/TUnit.Analyzers.CodeFixers/NUnitMigrationCodeFixProvider.cs b/TUnit.Analyzers.CodeFixers/NUnitMigrationCodeFixProvider.cs
index 35565a5051..fb439abeda 100644
--- a/TUnit.Analyzers.CodeFixers/NUnitMigrationCodeFixProvider.cs
+++ b/TUnit.Analyzers.CodeFixers/NUnitMigrationCodeFixProvider.cs
@@ -660,17 +660,15 @@ private UsingStatementSyntax CreateUsingMultipleStatement(ExpressionStatementSyn
protected override bool IsFrameworkAssertionNamespace(string namespaceName)
{
- // Exclude NUnit.Framework.Legacy - ClassicAssert should not be converted
- return (namespaceName == "NUnit.Framework" || namespaceName.StartsWith("NUnit.Framework."))
- && namespaceName != "NUnit.Framework.Legacy";
+ // Include NUnit.Framework.Legacy - ClassicAssert should be converted to TUnit assertions
+ return namespaceName == "NUnit.Framework" || namespaceName.StartsWith("NUnit.Framework.");
}
protected override bool IsKnownAssertionTypeBySyntax(string targetType, string methodName)
{
// NUnit assertion types that can be detected by syntax
- // NOTE: ClassicAssert is NOT included because it's in NUnit.Framework.Legacy namespace
- // and should not be auto-converted. The semantic check excludes it properly.
- return targetType is "Assert" or "CollectionAssert" or "StringAssert" or "FileAssert" or "DirectoryAssert";
+ // ClassicAssert is in NUnit.Framework.Legacy and should be converted
+ return targetType is "Assert" or "ClassicAssert" or "CollectionAssert" or "StringAssert" or "FileAssert" or "DirectoryAssert";
}
protected override ExpressionSyntax? ConvertAssertionIfNeeded(InvocationExpressionSyntax invocation)
@@ -717,15 +715,33 @@ protected override bool IsKnownAssertionTypeBySyntax(string targetType, string m
}
// Handle classic assertions like Assert.AreEqual, ClassicAssert.AreEqual, etc.
- if (invocation.Expression is MemberAccessExpressionSyntax classicMemberAccess &&
- classicMemberAccess.Expression is IdentifierNameSyntax { Identifier.Text: "Assert" or "ClassicAssert" })
+ // Also handles qualified names like NUnit.Framework.Assert.AreEqual
+ if (invocation.Expression is MemberAccessExpressionSyntax classicMemberAccess)
{
- return ConvertClassicAssertion(invocation, classicMemberAccess.Name.Identifier.Text);
+ var typeName = GetSimpleTypeName(classicMemberAccess.Expression);
+ if (typeName is "Assert" or "ClassicAssert")
+ {
+ return ConvertClassicAssertion(invocation, classicMemberAccess.Name.Identifier.Text);
+ }
}
return null;
}
-
+
+ ///
+ /// Extracts the simple type name from an expression.
+ /// Handles both simple identifiers and qualified names like "NUnit.Framework.Assert".
+ ///
+ private static string GetSimpleTypeName(ExpressionSyntax expression)
+ {
+ return expression switch
+ {
+ IdentifierNameSyntax identifier => identifier.Identifier.Text,
+ MemberAccessExpressionSyntax memberAccess => memberAccess.Name.Identifier.Text,
+ _ => expression.ToString()
+ };
+ }
+
private ExpressionSyntax ConvertAssertThat(InvocationExpressionSyntax invocation)
{
var arguments = invocation.ArgumentList.Arguments;
diff --git a/TUnit.Analyzers.CodeFixers/XUnitMigrationCodeFixProvider.cs b/TUnit.Analyzers.CodeFixers/XUnitMigrationCodeFixProvider.cs
index 411ce36b9a..aabff8af2e 100644
--- a/TUnit.Analyzers.CodeFixers/XUnitMigrationCodeFixProvider.cs
+++ b/TUnit.Analyzers.CodeFixers/XUnitMigrationCodeFixProvider.cs
@@ -16,7 +16,7 @@ public class XUnitMigrationCodeFixProvider : BaseMigrationCodeFixProvider
protected override string DiagnosticId => Rules.XunitMigration.Id;
protected override string CodeFixTitle => Rules.XunitMigration.Title.ToString();
- protected override bool ShouldAddTUnitUsings() => false;
+ protected override bool ShouldAddTUnitUsings() => true;
protected override AttributeRewriter CreateAttributeRewriter(Compilation compilation)
{
@@ -798,15 +798,33 @@ protected override bool IsKnownAssertionTypeBySyntax(string targetType, string m
return null;
}
- if (invocation.Expression is MemberAccessExpressionSyntax memberAccess &&
- memberAccess.Expression is IdentifierNameSyntax { Identifier.Text: "Assert" })
+ // Handle both simple (Assert.Equal) and qualified (Xunit.Assert.Equal) names
+ if (invocation.Expression is MemberAccessExpressionSyntax memberAccess)
{
- return ConvertXUnitAssertion(invocation, memberAccess.Name.Identifier.Text, memberAccess.Name);
+ var typeName = GetSimpleTypeName(memberAccess.Expression);
+ if (typeName == "Assert")
+ {
+ return ConvertXUnitAssertion(invocation, memberAccess.Name.Identifier.Text, memberAccess.Name);
+ }
}
return null;
}
+ ///
+ /// Extracts the simple type name from an expression.
+ /// Handles both simple identifiers and qualified names like "Xunit.Assert".
+ ///
+ private static string GetSimpleTypeName(ExpressionSyntax expression)
+ {
+ return expression switch
+ {
+ IdentifierNameSyntax identifier => identifier.Identifier.Text,
+ MemberAccessExpressionSyntax memberAccess => memberAccess.Name.Identifier.Text,
+ _ => expression.ToString()
+ };
+ }
+
private ExpressionSyntax? ConvertXUnitAssertion(InvocationExpressionSyntax invocation, string methodName, SimpleNameSyntax nameNode)
{
var arguments = invocation.ArgumentList.Arguments;
@@ -845,21 +863,21 @@ protected override bool IsKnownAssertionTypeBySyntax(string targetType, string m
"NotSame" when arguments.Count >= 2 =>
CreateTUnitAssertion("IsNotSameReferenceAs", arguments[1].Expression, arguments[0]),
- // String/Collection contains
+ // String/Collection contains - use collection assertion for proper overload resolution
"Contains" when arguments.Count >= 2 =>
- CreateTUnitAssertion("Contains", arguments[1].Expression, arguments[0]),
+ CreateTUnitCollectionAssertion("Contains", arguments[1].Expression, arguments[0]),
"DoesNotContain" when arguments.Count >= 2 =>
- CreateTUnitAssertion("DoesNotContain", arguments[1].Expression, arguments[0]),
+ CreateTUnitCollectionAssertion("DoesNotContain", arguments[1].Expression, arguments[0]),
"StartsWith" when arguments.Count >= 2 =>
CreateTUnitAssertion("StartsWith", arguments[1].Expression, arguments[0]),
"EndsWith" when arguments.Count >= 2 =>
CreateTUnitAssertion("EndsWith", arguments[1].Expression, arguments[0]),
- // Empty/Not empty
+ // Empty/Not empty - use collection assertion for proper overload resolution
"Empty" when arguments.Count >= 1 =>
- CreateTUnitAssertion("IsEmpty", arguments[0].Expression),
+ CreateTUnitCollectionAssertion("IsEmpty", arguments[0].Expression),
"NotEmpty" when arguments.Count >= 1 =>
- CreateTUnitAssertion("IsNotEmpty", arguments[0].Expression),
+ CreateTUnitCollectionAssertion("IsNotEmpty", arguments[0].Expression),
// Exception assertions
"Throws" => ConvertThrows(invocation, nameNode),
@@ -878,29 +896,29 @@ protected override bool IsKnownAssertionTypeBySyntax(string targetType, string m
"NotInRange" when arguments.Count >= 3 =>
CreateTUnitAssertion("IsNotInRange", arguments[0].Expression, arguments[1], arguments[2]),
- // Collection assertions
+ // Collection assertions - use collection assertion for proper overload resolution
"Single" when arguments.Count >= 1 =>
- CreateTUnitAssertion("HasSingleItem", arguments[0].Expression),
+ CreateTUnitCollectionAssertion("HasSingleItem", arguments[0].Expression),
"All" when arguments.Count >= 2 =>
CreateAllAssertion(arguments[0].Expression, arguments[1].Expression),
- // Subset/superset
+ // Subset/superset - use collection assertion for proper overload resolution
"Subset" when arguments.Count >= 2 =>
- CreateTUnitAssertion("IsSubsetOf", arguments[0].Expression, arguments[1]),
+ CreateTUnitCollectionAssertion("IsSubsetOf", arguments[0].Expression, arguments[1]),
"Superset" when arguments.Count >= 2 =>
- CreateTUnitAssertion("IsSupersetOf", arguments[0].Expression, arguments[1]),
+ CreateTUnitCollectionAssertion("IsSupersetOf", arguments[0].Expression, arguments[1]),
"ProperSubset" when arguments.Count >= 2 =>
CreateProperSubsetWithTodo(arguments),
"ProperSuperset" when arguments.Count >= 2 =>
CreateProperSupersetWithTodo(arguments),
- // Unique items
+ // Unique items - use collection assertion for proper overload resolution
"Distinct" when arguments.Count >= 1 =>
- CreateTUnitAssertion("HasDistinctItems", arguments[0].Expression),
+ CreateTUnitCollectionAssertion("HasDistinctItems", arguments[0].Expression),
- // Equivalent (order independent)
+ // Equivalent (order independent) - use collection assertion for proper overload resolution
"Equivalent" when arguments.Count >= 2 =>
- CreateTUnitAssertion("IsEquivalentTo", arguments[1].Expression, arguments[0]),
+ CreateTUnitCollectionAssertion("IsEquivalentTo", arguments[1].Expression, arguments[0]),
// Regex assertions
"Matches" when arguments.Count >= 2 =>
@@ -951,7 +969,7 @@ private ExpressionSyntax CreateCollectionWithTodo(SeparatedSyntaxList(action) -> await Assert.ThrowsAsync(action)
- // Note: ThrowsAny accepts derived types, ThrowsAsync should work similarly
+ // xUnit Assert.ThrowsAny(Action) -> TUnit Assert.Throws(Action)
+ // Both are synchronous - ThrowsAny accepts derived types, TUnit's Throws does too
+ if (nameNode is GenericNameSyntax genericName)
+ {
+ var exceptionType = genericName.TypeArgumentList.Arguments[0];
+ var action = invocation.ArgumentList.Arguments[0].Expression;
+
+ // Keep it synchronous - TUnit's Assert.Throws(Action) accepts derived types
+ return SyntaxFactory.InvocationExpression(
+ SyntaxFactory.MemberAccessExpression(
+ SyntaxKind.SimpleMemberAccessExpression,
+ SyntaxFactory.IdentifierName("Assert"),
+ SyntaxFactory.GenericName("Throws")
+ .WithTypeArgumentList(
+ SyntaxFactory.TypeArgumentList(
+ SyntaxFactory.SingletonSeparatedList(exceptionType)
+ )
+ )
+ ),
+ SyntaxFactory.ArgumentList(
+ SyntaxFactory.SingletonSeparatedList(
+ SyntaxFactory.Argument(action)
+ )
+ )
+ );
+ }
+
+ return CreateTUnitAssertion("Throws", invocation.ArgumentList.Arguments[0].Expression);
+ }
+
+ private ExpressionSyntax ConvertThrowsAnyAsync(InvocationExpressionSyntax invocation, SimpleNameSyntax nameNode)
+ {
+ // xUnit Assert.ThrowsAnyAsync(Func) -> await Assert.ThrowsAsync(Func)
+ // ThrowsAnyAsync accepts derived types, TUnit's ThrowsAsync does too
if (nameNode is GenericNameSyntax genericName)
{
var exceptionType = genericName.TypeArgumentList.Arguments[0];
@@ -1185,13 +1205,7 @@ private ExpressionSyntax ConvertThrowsAny(InvocationExpressionSyntax invocation,
return SyntaxFactory.AwaitExpression(awaitKeyword, invocationExpression);
}
- return CreateTUnitAssertion("Throws", invocation.ArgumentList.Arguments[0].Expression);
- }
-
- private ExpressionSyntax ConvertThrowsAnyAsync(InvocationExpressionSyntax invocation, SimpleNameSyntax nameNode)
- {
- // Same as ThrowsAny but for async
- return ConvertThrowsAny(invocation, nameNode);
+ return CreateTUnitAssertion("ThrowsAsync", invocation.ArgumentList.Arguments[0].Expression);
}
private ExpressionSyntax ConvertIsNotType(InvocationExpressionSyntax invocation, SimpleNameSyntax nameNode)
@@ -1237,17 +1251,20 @@ private ExpressionSyntax ConvertIsNotType(InvocationExpressionSyntax invocation,
private ExpressionSyntax ConvertThrows(InvocationExpressionSyntax invocation, SimpleNameSyntax nameNode)
{
- // Assert.Throws(action) -> await Assert.ThrowsAsync(action)
+ // xUnit Assert.Throws(Action) -> TUnit Assert.Throws(Action)
+ // Both are synchronous and return the exception directly
+ // NO async conversion needed - TUnit has a sync version that matches xUnit's signature
if (nameNode is GenericNameSyntax genericName)
{
var exceptionType = genericName.TypeArgumentList.Arguments[0];
var action = invocation.ArgumentList.Arguments[0].Expression;
- var invocationExpression = SyntaxFactory.InvocationExpression(
+ // Keep it synchronous - TUnit's Assert.Throws(Action) returns TException directly
+ return SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("Assert"),
- SyntaxFactory.GenericName("ThrowsAsync")
+ SyntaxFactory.GenericName("Throws")
.WithTypeArgumentList(
SyntaxFactory.TypeArgumentList(
SyntaxFactory.SingletonSeparatedList(exceptionType)
@@ -1260,13 +1277,9 @@ private ExpressionSyntax ConvertThrows(InvocationExpressionSyntax invocation, Si
)
)
);
-
- var awaitKeyword = SyntaxFactory.Token(SyntaxKind.AwaitKeyword)
- .WithTrailingTrivia(SyntaxFactory.Space);
- return SyntaxFactory.AwaitExpression(awaitKeyword, invocationExpression);
}
- // Fallback
+ // Fallback for non-generic Throws
return CreateTUnitAssertion("Throws", invocation.ArgumentList.Arguments[0].Expression);
}
diff --git a/TUnit.Analyzers.Tests/MSTestMigrationAnalyzerTests.cs b/TUnit.Analyzers.Tests/MSTestMigrationAnalyzerTests.cs
index edbea903d5..8140ac97c4 100644
--- a/TUnit.Analyzers.Tests/MSTestMigrationAnalyzerTests.cs
+++ b/TUnit.Analyzers.Tests/MSTestMigrationAnalyzerTests.cs
@@ -1,3 +1,4 @@
+using Microsoft.CodeAnalysis.Testing;
using Microsoft.CodeAnalysis.Text;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using CodeFixer = TUnit.Analyzers.Tests.Verifiers.CSharpCodeFixVerifier;
@@ -47,10 +48,6 @@ public void MyMethod() { }
""",
Verifier.Diagnostic(Rules.MSTestMigration).WithLocation(0),
$$"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -78,11 +75,6 @@ public void MyMethod() { }
""",
Verifier.Diagnostic(Rules.MSTestMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
-
public class MyClass
{
[Test]
@@ -115,10 +107,6 @@ public void MyMethod()
Verifier.Diagnostic(Rules.MSTestMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -167,10 +155,6 @@ public void MyMethod() { }
""",
Verifier.Diagnostic(Rules.MSTestMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -202,10 +186,6 @@ public void MyMethod() { }
""",
Verifier.Diagnostic(Rules.MSTestMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -244,10 +224,6 @@ public void MyMethod() { }
""",
Verifier.Diagnostic(Rules.MSTestMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -287,10 +263,6 @@ public void MyMethod()
Verifier.Diagnostic(Rules.MSTestMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -329,10 +301,6 @@ public void StringTests()
Verifier.Diagnostic(Rules.MSTestMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -377,10 +345,6 @@ public void OuterTest()
Verifier.Diagnostic(Rules.MSTestMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class OuterClass
{
@@ -424,10 +388,6 @@ public void GenericTest()
Verifier.Diagnostic(Rules.MSTestMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class GenericTestClass
{
@@ -514,10 +474,6 @@ public static void ClassTeardown()
"""
using System;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class CompleteTestClass
{
@@ -615,10 +571,6 @@ public void TestMultipleAssertionTypes()
Verifier.Diagnostic(Rules.MSTestMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -672,10 +624,6 @@ public void TestReferences()
Verifier.Diagnostic(Rules.MSTestMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -717,10 +665,6 @@ public void TestWithMessages()
Verifier.Diagnostic(Rules.MSTestMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -741,13 +685,16 @@ public async Task TestWithMessages()
[Test]
public async Task MSTest_Assertions_With_FormatStrings_Converted()
{
+ // Note: The diagnostic is on [TestMethod] because Assert.AreEqual with format strings
+ // isn't a valid MSTest overload, so semantic model doesn't resolve it.
+ // The analyzer detects the method attribute instead of the Assert call.
await CodeFixer.VerifyCodeFixAsync(
"""
using Microsoft.VisualStudio.TestTools.UnitTesting;
- {|#0:public class MyClass|}
+ public class MyClass
{
- [TestMethod]
+ {|#0:[TestMethod]|}
public void TestWithFormatStrings()
{
int x = 5;
@@ -759,10 +706,6 @@ public void TestWithFormatStrings()
Verifier.Diagnostic(Rules.MSTestMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -784,14 +727,16 @@ public async Task MSTest_Assertions_With_Comparer_AddsTodoComment()
{
// When a comparer is detected (via semantic or syntax-based detection),
// a TODO comment is added explaining that TUnit uses different comparison semantics.
+ // Note: The diagnostic is on [TestMethod] because Assert.AreEqual with comparer
+ // isn't a valid MSTest overload, so semantic model doesn't resolve it.
await CodeFixer.VerifyCodeFixAsync(
"""
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Collections.Generic;
- {|#0:public class MyClass|}
+ public class MyClass
{
- [TestMethod]
+ {|#0:[TestMethod]|}
public void TestWithComparer()
{
var comparer = StringComparer.OrdinalIgnoreCase;
@@ -803,10 +748,6 @@ public void TestWithComparer()
"""
using System.Collections.Generic;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -841,10 +782,6 @@ public void TestMethod()
""",
Verifier.Diagnostic(Rules.MSTestMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -877,10 +814,6 @@ public void TestMethod()
""",
Verifier.Diagnostic(Rules.MSTestMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -913,10 +846,6 @@ public void TestMethod()
""",
Verifier.Diagnostic(Rules.MSTestMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -953,10 +882,6 @@ public void TestMethod()
"""
using System;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -998,10 +923,6 @@ public async Task TestMethodAsync()
"""
using System;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1043,10 +964,6 @@ public void TestMethod()
"""
using System.IO;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1085,10 +1002,6 @@ public void TestMethod()
"""
using System.IO;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1127,10 +1040,6 @@ public void TestMethod()
"""
using System.IO;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1169,10 +1078,6 @@ public void TestMethod()
"""
using System.IO;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1188,6 +1093,248 @@ public async Task TestMethod()
);
}
+ [Test]
+ public async Task MSTest_KitchenSink_Comprehensive_Migration()
+ {
+ // This test combines MANY MSTest patterns together to ensure the code fixer
+ // can handle complex real-world scenarios in a single pass.
+ await CodeFixer.VerifyCodeFixAsync(
+ """
+ using Microsoft.VisualStudio.TestTools.UnitTesting;
+ using System;
+ using System.Collections.Generic;
+
+ {|#0:[TestClass]|}
+ public class KitchenSinkTests
+ {
+ private static List _log;
+ private int _counter;
+
+ [ClassInitialize]
+ public static void ClassSetup(TestContext context)
+ {
+ _log = new List();
+ }
+
+ [TestInitialize]
+ public void TestSetup()
+ {
+ _counter = 0;
+ }
+
+ [TestMethod]
+ public void BasicTest()
+ {
+ Assert.IsTrue(_counter == 0);
+ Assert.AreEqual(0, _counter);
+ Assert.IsNotNull(_log);
+ }
+
+ [TestMethod]
+ [DataRow(1, 2, 3)]
+ [DataRow(10, 20, 30)]
+ [DataRow(-1, 1, 0)]
+ public void ParameterizedTest(int a, int b, int expected)
+ {
+ var result = a + b;
+ Assert.AreEqual(expected, result);
+ }
+
+ [TestMethod]
+ [DynamicData(nameof(GetTestData))]
+ public void DataSourceTest(string input, int expectedLength)
+ {
+ Assert.AreEqual(expectedLength, input.Length);
+ Assert.IsNotNull(input);
+ }
+
+ public static IEnumerable GetTestData()
+ {
+ yield return new object[] { "hello", 5 };
+ yield return new object[] { "world", 5 };
+ }
+
+ [TestMethod]
+ public void CollectionAssertTest()
+ {
+ var list = new List { 1, 2, 3 };
+ CollectionAssert.Contains(list, 2);
+ CollectionAssert.AllItemsAreUnique(list);
+ }
+
+ [TestMethod]
+ public void StringAssertTest()
+ {
+ var text = "Hello World";
+ StringAssert.Contains(text, "World");
+ StringAssert.StartsWith(text, "Hello");
+ StringAssert.EndsWith(text, "World");
+ }
+
+ [TestMethod]
+ public void ExceptionTest()
+ {
+ Assert.ThrowsException(() => throw new ArgumentException("test"));
+ }
+
+ [TestMethod]
+ public void ComparisonAssertions()
+ {
+ var value = 42;
+ Assert.IsTrue(value > 0);
+ Assert.IsFalse(value < 0);
+ Assert.AreNotEqual(0, value);
+ }
+
+ [TestMethod]
+ public void NullAssertions()
+ {
+ string? nullValue = null;
+ var notNullValue = "test";
+ Assert.IsNull(nullValue);
+ Assert.IsNotNull(notNullValue);
+ }
+
+ [TestMethod]
+ public void TypeAssertions()
+ {
+ object obj = "test string";
+ Assert.IsInstanceOfType(obj, typeof(string));
+ }
+
+ [TestCleanup]
+ public void TestTeardown()
+ {
+ _counter = 0;
+ }
+
+ [ClassCleanup]
+ public static void ClassTeardown()
+ {
+ _log.Clear();
+ }
+ }
+ """,
+ Verifier.Diagnostic(Rules.MSTestMigration).WithLocation(0),
+ """
+ using System;
+ using System.Collections.Generic;
+ using System.Threading.Tasks;
+
+ public class KitchenSinkTests
+ {
+ private static List _log;
+ private int _counter;
+
+ [Before(HookType.Class)]
+ public static void ClassSetup()
+ {
+ _log = new List();
+ }
+
+ [Before(HookType.Test)]
+ public void TestSetup()
+ {
+ _counter = 0;
+ }
+
+ [Test]
+ public async Task BasicTest()
+ {
+ await Assert.That(_counter == 0).IsTrue();
+ await Assert.That(_counter).IsEqualTo(0);
+ await Assert.That(_log).IsNotNull();
+ }
+
+ [Test]
+ [Arguments(1, 2, 3)]
+ [Arguments(10, 20, 30)]
+ [Arguments(-1, 1, 0)]
+ public async Task ParameterizedTest(int a, int b, int expected)
+ {
+ var result = a + b;
+ await Assert.That(result).IsEqualTo(expected);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(GetTestData))]
+ public async Task DataSourceTest(string input, int expectedLength)
+ {
+ await Assert.That(input.Length).IsEqualTo(expectedLength);
+ await Assert.That(input).IsNotNull();
+ }
+
+ public static IEnumerable GetTestData()
+ {
+ yield return new object[] { "hello", 5 };
+ yield return new object[] { "world", 5 };
+ }
+
+ [Test]
+ public async Task CollectionAssertTest()
+ {
+ var list = new List { 1, 2, 3 };
+ await Assert.That(list).Contains(2);
+ await Assert.That(list).HasDistinctItems();
+ }
+
+ [Test]
+ public async Task StringAssertTest()
+ {
+ var text = "Hello World";
+ await Assert.That(text).Contains("World");
+ await Assert.That(text).StartsWith("Hello");
+ await Assert.That(text).EndsWith("World");
+ }
+
+ [Test]
+ public async Task ExceptionTest()
+ {
+ await Assert.ThrowsAsync(() => throw new ArgumentException("test"));
+ }
+
+ [Test]
+ public async Task ComparisonAssertions()
+ {
+ var value = 42;
+ await Assert.That(value > 0).IsTrue();
+ await Assert.That(value < 0).IsFalse();
+ await Assert.That(value).IsNotEqualTo(0);
+ }
+
+ [Test]
+ public async Task NullAssertions()
+ {
+ string? nullValue = null;
+ var notNullValue = "test";
+ await Assert.That(nullValue).IsNull();
+ await Assert.That(notNullValue).IsNotNull();
+ }
+
+ [Test]
+ public async Task TypeAssertions()
+ {
+ object obj = "test string";
+ await Assert.That(obj).IsAssignableTo(typeof(string));
+ }
+
+ [After(HookType.Test)]
+ public void TestTeardown()
+ {
+ _counter = 0;
+ }
+
+ [After(HookType.Class)]
+ public static void ClassTeardown()
+ {
+ _log.Clear();
+ }
+ }
+ """,
+ ConfigureMSTestTest
+ );
+ }
+
private static void ConfigureMSTestTest(Verifier.Test test)
{
test.TestState.AdditionalReferences.Add(typeof(TestMethodAttribute).Assembly);
@@ -1195,9 +1342,21 @@ private static void ConfigureMSTestTest(Verifier.Test test)
private static void ConfigureMSTestTest(CodeFixer.Test test)
{
+ // Add MSTest assemblies to TestState (for input code compilation)
test.TestState.AdditionalReferences.Add(typeof(TestMethodAttribute).Assembly);
- // FixedState should only have TUnit assemblies, not MSTest
+
+ // FixedState: TUnit assemblies only (NO MSTest inheritance)
+ // Use Explicit inheritance mode to prevent MSTest references from being inherited
+ // This ensures the analyzer's IsFrameworkAvailable check returns false for MSTest
+ test.FixedState.InheritanceMode = StateInheritanceMode.Explicit;
test.FixedState.AdditionalReferences.Add(typeof(TUnit.Core.TestAttribute).Assembly);
test.FixedState.AdditionalReferences.Add(typeof(TUnit.Assertions.Assert).Assembly);
+
+ // With Explicit mode, we need to copy AnalyzerConfigFiles from TestState
+ // The .editorconfig is added by CSharpCodeFixVerifier base class
+ test.FixedState.AnalyzerConfigFiles.Add(("/.editorconfig", SourceText.From("""
+ is_global = true
+ end_of_line = lf
+ """)));
}
}
diff --git a/TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs b/TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs
index 8cebdbe80c..5a842011a6 100644
--- a/TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs
+++ b/TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs
@@ -1,3 +1,4 @@
+using Microsoft.CodeAnalysis.Testing;
using Microsoft.CodeAnalysis.Text;
using NUnit.Framework.Legacy;
using CodeFixer = TUnit.Analyzers.Tests.Verifiers.CSharpCodeFixVerifier;
@@ -47,10 +48,6 @@ public void MyMethod() { }
""",
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
$$"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -78,11 +75,6 @@ public void MyMethod() { }
""",
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
-
public class MyClass
{
[Test]
@@ -92,7 +84,7 @@ public void MyMethod() { }
ConfigureNUnitTest
);
}
-
+
[Test]
public async Task NUnit_Assert_That_Converted()
{
@@ -114,10 +106,6 @@ public void MyMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -156,27 +144,24 @@ public void MyMethod()
""",
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
+ using System.Threading.Tasks;
public class MyClass
{
[Test]
- public void MyMethod()
+ public async Task MyMethod()
{
- ClassicAssert.AreEqual(5, 5);
- ClassicAssert.IsTrue(true);
- ClassicAssert.IsNull(null);
- ClassicAssert.Greater(10, 5);
+ await Assert.That(5).IsEqualTo(5);
+ await Assert.That(true).IsTrue();
+ await Assert.That(null).IsNull();
+ await Assert.That(10).IsGreaterThan(5);
}
}
""",
ConfigureNUnitTest
);
}
-
+
[Test]
public async Task NUnit_Directive_Flagged()
{
@@ -208,10 +193,6 @@ public void MyMethod() { }
""",
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -243,10 +224,6 @@ public void MyMethod() { }
""",
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -292,10 +269,6 @@ public void OuterTest()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class OuterClass
{
@@ -339,10 +312,6 @@ public void GenericTest()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class GenericTestClass
{
@@ -382,10 +351,6 @@ public void ComplexConstraints()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -473,10 +438,6 @@ public void ClassTeardown()
"""
using System;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class CompleteTestClass
{
@@ -498,7 +459,7 @@ public void Setup()
public async Task Test1()
{
await Assert.That(_counter).IsGreaterThan(0);
- ClassicAssert.IsTrue(true);
+ await Assert.That(true).IsTrue();
}
[Test]
@@ -564,10 +525,6 @@ public void TestMultipleAssertions()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -576,10 +533,10 @@ public async Task TestMultipleAssertions()
{
var value = 42;
await Assert.That(value).IsNotNull();
- ClassicAssert.IsNotNull(value);
- ClassicAssert.AreEqual(42, value);
+ await Assert.That(value).IsNotNull();
+ await Assert.That(value).IsEqualTo(42);
await Assert.That(value).IsGreaterThan(0);
- ClassicAssert.Less(0, value);
+ await Assert.That(0).IsLessThan(value);
}
}
""",
@@ -603,10 +560,6 @@ public class MyClass
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -640,10 +593,6 @@ public class MyClass
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -681,10 +630,6 @@ public int Add(int a, int b)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -718,10 +663,6 @@ public class MyClass
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -757,10 +698,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -794,10 +731,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -831,10 +764,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -868,10 +797,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -905,10 +830,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -942,10 +863,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -979,10 +896,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1016,10 +929,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1053,10 +962,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1090,10 +995,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1128,10 +1029,6 @@ public void AdditionTest(int a, int b, int expected)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1168,10 +1065,6 @@ public void AdditionTest(int a, int b, int expected)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1208,10 +1101,6 @@ public void MyTest(int value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1249,10 +1138,6 @@ public void MyTest(int value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1290,10 +1175,6 @@ public void MyTest(int value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1329,10 +1210,6 @@ public void MyTest(int value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1368,10 +1245,6 @@ public void MyTest(int value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1407,10 +1280,6 @@ public void MyTest(int value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1446,10 +1315,6 @@ public void MyTest(int value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1487,10 +1352,6 @@ public void MyTest(int value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1525,10 +1386,6 @@ public class MyClass
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1565,10 +1422,6 @@ public void MyTest(int value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1605,10 +1458,6 @@ public void MyTest(int value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1646,10 +1495,6 @@ public void MyTest(int value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1688,10 +1533,6 @@ public void MyTest(int value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1732,10 +1573,6 @@ public void TestMethod()
"""
using System;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1775,10 +1612,6 @@ public void TestMethod()
"""
using System;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1827,10 +1660,6 @@ public async System.Threading.Tasks.Task Execute(int value)
"""
using System;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1876,10 +1705,6 @@ public void TestMethod()
"""
using System;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1915,10 +1740,6 @@ public void TestMethod()
"""
using System;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -1963,10 +1784,6 @@ private async System.Threading.Tasks.Task SomeMethod()
"""
using System;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2008,10 +1825,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2047,10 +1860,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2086,10 +1895,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2125,10 +1930,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2166,10 +1967,6 @@ public void TestMethod()
"""
using System.Collections.Generic;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2207,10 +2004,6 @@ public void TestMethod()
"""
using System.Threading;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2246,10 +2039,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2284,10 +2073,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2323,10 +2108,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2361,10 +2142,6 @@ public void TestMethod()
""",
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2397,10 +2174,6 @@ public void TestMethod()
""",
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2433,10 +2206,6 @@ public void TestMethod()
""",
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2476,10 +2245,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2522,10 +2287,6 @@ public void TestMethod()
"""
using System.Collections.Generic;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2563,10 +2324,6 @@ public void TestMethod()
"""
using System.Collections.Generic;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2602,10 +2359,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2641,10 +2394,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2680,10 +2429,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2719,10 +2464,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2758,10 +2499,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2797,10 +2534,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2836,10 +2569,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2873,10 +2602,6 @@ public void TestMethod()
""",
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2909,10 +2634,6 @@ public void TestMethod()
""",
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2945,10 +2666,6 @@ public void TestMethod()
""",
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -2981,10 +2698,6 @@ public void TestMethod()
""",
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3026,10 +2739,6 @@ private static void HandleRealized(object sender, ref bool realized)
""",
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3077,10 +2786,6 @@ private static void TryGetValue(string key, out int value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3137,10 +2842,6 @@ public void Run()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public interface ITestRunner
{
@@ -3185,10 +2886,6 @@ public void TestMethod([Values(1, 2, 3)] int value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3222,10 +2919,6 @@ public void TestMethod([Range(1, 5)] int value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3259,10 +2952,6 @@ public void TestMethod([Range(0, 10, 2)] int value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3296,10 +2985,6 @@ public void TestMethod([Range(1.0, 5.0)] double value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3333,10 +3018,6 @@ public void TestMethod([Range(1L, 100L)] long value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3370,10 +3051,6 @@ public void TestMethod([Range(1.0f, 5.0f)] float value)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3408,10 +3085,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3447,10 +3120,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3486,10 +3155,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3524,10 +3189,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3562,10 +3223,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3604,10 +3261,6 @@ public void TestMethod([ValueSource(nameof(Numbers))] int value)
"""
using System.Collections.Generic;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3644,10 +3297,6 @@ public void TestMethod([Values(1, 2)] int a, [Values("x", "y")] string b)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3685,10 +3334,6 @@ public void TestMethod([Values(1, 2)] int a, [Values("x", "y")] string b)
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3723,10 +3368,6 @@ public void TestMethod()
"""
using System.IO;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3761,10 +3402,6 @@ public void TestMethod()
"""
using System.IO;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3799,10 +3436,6 @@ public void TestMethod()
"""
using System.IO;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3837,10 +3470,6 @@ public void TestMethod()
"""
using System.IO;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3875,10 +3504,6 @@ public void TestMethod()
"""
using System.IO;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3913,10 +3538,6 @@ public void TestMethod()
"""
using System.IO;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3951,10 +3572,6 @@ public void TestMethod()
"""
using System.IO;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -3991,10 +3608,6 @@ public void TestMethod()
"""
using System;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -4036,10 +3649,6 @@ public async Task TestMethod()
"""
using System;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -4080,10 +3689,6 @@ public void TestMethod()
"""
using System.Collections.Generic;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -4121,10 +3726,6 @@ public void TestMethod()
"""
using System.Collections.Generic;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -4162,10 +3763,6 @@ public void TestMethod()
"""
using System.Collections.Generic;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -4203,10 +3800,6 @@ public void TestMethod()
"""
using System.Collections.Generic;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -4244,10 +3837,6 @@ public void TestMethod()
"""
using System.Collections.Generic;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -4285,10 +3874,6 @@ public void TestMethod()
"""
using System.Collections.Generic;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -4326,10 +3911,6 @@ public void TestMethod()
"""
using System.Collections.Generic;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -4368,10 +3949,6 @@ public void TestMethod()
"""
using System.Collections.Generic;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -4410,10 +3987,6 @@ public void TestMethod()
"""
using System.Collections.Generic;
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -4448,10 +4021,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -4485,10 +4054,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -4522,10 +4087,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -4559,10 +4120,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -4596,10 +4153,6 @@ public void TestMethod()
Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
"""
using System.Threading.Tasks;
- using TUnit.Core;
- using TUnit.Assertions;
- using static TUnit.Assertions.Assert;
- using TUnit.Assertions.Extensions;
public class MyClass
{
@@ -4614,6 +4167,259 @@ public async Task TestMethod()
);
}
+ [Test]
+ public async Task NUnit_KitchenSink_Comprehensive_Migration()
+ {
+ // This test combines MANY NUnit patterns together to ensure the code fixer
+ // can handle complex real-world scenarios in a single pass.
+ // Note: Some advanced patterns (constraint chaining, Assert.Fail) have known
+ // limitations - separate tests cover those edge cases.
+ await CodeFixer.VerifyCodeFixAsync(
+ """
+ using NUnit.Framework;
+ using NUnit.Framework.Legacy;
+ using System;
+ using System.Collections.Generic;
+
+ {|#0:[TestFixture]|}
+ [NonParallelizable]
+ [Category("Integration")]
+ public class KitchenSinkTests
+ {
+ private List _log;
+ private int _counter;
+
+ [OneTimeSetUp]
+ public void ClassSetup()
+ {
+ _log = new List();
+ }
+
+ [SetUp]
+ public void TestSetup()
+ {
+ _counter = 0;
+ }
+
+ [Test]
+ public void BasicTest()
+ {
+ Assert.That(_counter, Is.EqualTo(0));
+ ClassicAssert.AreEqual(0, _counter);
+ }
+
+ [Test]
+ [Repeat(3)]
+ public void RepeatedTest()
+ {
+ _counter++;
+ Assert.That(_counter, Is.GreaterThan(0));
+ }
+
+ [TestCase(1, 2, 3)]
+ [TestCase(10, 20, 30)]
+ [TestCase(-1, 1, 0)]
+ public void ParameterizedTest(int a, int b, int expected)
+ {
+ var result = a + b;
+ Assert.That(result, Is.EqualTo(expected));
+ }
+
+ [TestCaseSource(nameof(GetTestData))]
+ public void DataSourceTest(string input, int expectedLength)
+ {
+ Assert.That(input.Length, Is.EqualTo(expectedLength));
+ Assert.That(input, Is.Not.Null);
+ }
+
+ public static IEnumerable GetTestData()
+ {
+ yield return new object[] { "hello", 5 };
+ yield return new object[] { "world", 5 };
+ }
+
+ [Test]
+ public void CollectionAssertTest()
+ {
+ var list = new List { 1, 2, 3 };
+ CollectionAssert.Contains(list, 2);
+ CollectionAssert.IsNotEmpty(list);
+ CollectionAssert.AllItemsAreUnique(list);
+ }
+
+ [Test]
+ public void StringAssertTest()
+ {
+ var text = "Hello World";
+ StringAssert.Contains("World", text);
+ StringAssert.StartsWith("Hello", text);
+ StringAssert.EndsWith("World", text);
+ }
+
+ [Test]
+ public void ExceptionTest()
+ {
+ Assert.Throws(() => throw new ArgumentException("test"));
+ }
+
+ [Test]
+ public void MultipleAssertionsTest()
+ {
+ var value = 42;
+ Assert.Multiple(() =>
+ {
+ Assert.That(value, Is.GreaterThan(0));
+ Assert.That(value, Is.LessThan(100));
+ Assert.That(value, Is.EqualTo(42));
+ });
+ }
+
+ [Test]
+ public void NullAndTypeAssertions()
+ {
+ object obj = "test";
+ Assert.That(obj, Is.Not.Null);
+ Assert.That(obj, Is.TypeOf());
+ }
+
+ [TearDown]
+ public void TestTeardown()
+ {
+ _counter = 0;
+ }
+
+ [OneTimeTearDown]
+ public void ClassTeardown()
+ {
+ _log.Clear();
+ }
+ }
+ """,
+ Verifier.Diagnostic(Rules.NUnitMigration).WithLocation(0),
+ """
+ using System;
+ using System.Collections.Generic;
+ using System.Threading.Tasks;
+
+ [NotInParallel]
+ [Category("Integration")]
+ public class KitchenSinkTests
+ {
+ private List _log;
+ private int _counter;
+
+ [Before(HookType.Class)]
+ public void ClassSetup()
+ {
+ _log = new List();
+ }
+
+ [Before(HookType.Test)]
+ public void TestSetup()
+ {
+ _counter = 0;
+ }
+
+ [Test]
+ public async Task BasicTest()
+ {
+ await Assert.That(_counter).IsEqualTo(0);
+ await Assert.That(_counter).IsEqualTo(0);
+ }
+
+ [Test]
+ [Repeat(3)]
+ public async Task RepeatedTest()
+ {
+ _counter++;
+ await Assert.That(_counter).IsGreaterThan(0);
+ }
+
+ [Test]
+ [Arguments(1, 2, 3)]
+ [Arguments(10, 20, 30)]
+ [Arguments(-1, 1, 0)]
+ public async Task ParameterizedTest(int a, int b, int expected)
+ {
+ var result = a + b;
+ await Assert.That(result).IsEqualTo(expected);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(GetTestData))]
+ public async Task DataSourceTest(string input, int expectedLength)
+ {
+ await Assert.That(input.Length).IsEqualTo(expectedLength);
+ await Assert.That(input).IsNotNull();
+ }
+
+ public static IEnumerable GetTestData()
+ {
+ yield return new object[] { "hello", 5 };
+ yield return new object[] { "world", 5 };
+ }
+
+ [Test]
+ public async Task CollectionAssertTest()
+ {
+ var list = new List { 1, 2, 3 };
+ await Assert.That(list).Contains(2);
+ await Assert.That(list).IsNotEmpty();
+ await Assert.That(list).HasDistinctItems();
+ }
+
+ [Test]
+ public async Task StringAssertTest()
+ {
+ var text = "Hello World";
+ await Assert.That(text).Contains("World");
+ await Assert.That(text).StartsWith("Hello");
+ await Assert.That(text).EndsWith("World");
+ }
+
+ [Test]
+ public async Task ExceptionTest()
+ {
+ await Assert.ThrowsAsync(() => throw new ArgumentException("test"));
+ }
+
+ [Test]
+ public async Task MultipleAssertionsTest()
+ {
+ var value = 42;
+ using (Assert.Multiple())
+ {
+ await Assert.That(value).IsGreaterThan(0);
+ await Assert.That(value).IsLessThan(100);
+ await Assert.That(value).IsEqualTo(42);
+ }
+ }
+
+ [Test]
+ public async Task NullAndTypeAssertions()
+ {
+ object obj = "test";
+ await Assert.That(obj).IsNotNull();
+ await Assert.That(obj).IsTypeOf();
+ }
+
+ [After(HookType.Test)]
+ public void TestTeardown()
+ {
+ _counter = 0;
+ }
+
+ [After(HookType.Class)]
+ public void ClassTeardown()
+ {
+ _log.Clear();
+ }
+ }
+ """,
+ ConfigureNUnitTest
+ );
+ }
+
private static void ConfigureNUnitTest(Verifier.Test test)
{
test.TestState.AdditionalReferences.Add(typeof(NUnit.Framework.TestAttribute).Assembly);
@@ -4621,10 +4427,22 @@ private static void ConfigureNUnitTest(Verifier.Test test)
private static void ConfigureNUnitTest(CodeFixer.Test test)
{
+ // Add NUnit assemblies to TestState (for input code compilation)
test.TestState.AdditionalReferences.Add(typeof(NUnit.Framework.TestAttribute).Assembly);
test.TestState.AdditionalReferences.Add(typeof(NUnit.Framework.Legacy.ClassicAssert).Assembly);
- // FixedState should only have TUnit assemblies, not NUnit
+
+ // FixedState: TUnit assemblies only (NO NUnit inheritance)
+ // Use Explicit inheritance mode to prevent NUnit references from being inherited
+ // This ensures the analyzer's IsFrameworkAvailable check returns false for NUnit
+ test.FixedState.InheritanceMode = StateInheritanceMode.Explicit;
test.FixedState.AdditionalReferences.Add(typeof(TUnit.Core.TestAttribute).Assembly);
test.FixedState.AdditionalReferences.Add(typeof(TUnit.Assertions.Assert).Assembly);
+
+ // With Explicit mode, we need to copy AnalyzerConfigFiles from TestState
+ // The .editorconfig is added by CSharpCodeFixVerifier base class
+ test.FixedState.AnalyzerConfigFiles.Add(("/.editorconfig", SourceText.From("""
+ is_global = true
+ end_of_line = lf
+ """)));
}
}
diff --git a/TUnit.Analyzers.Tests/XUnitMigrationAnalyzerTests.cs b/TUnit.Analyzers.Tests/XUnitMigrationAnalyzerTests.cs
index db9e695043..53606f8f59 100644
--- a/TUnit.Analyzers.Tests/XUnitMigrationAnalyzerTests.cs
+++ b/TUnit.Analyzers.Tests/XUnitMigrationAnalyzerTests.cs
@@ -48,7 +48,7 @@ public async Task Test_Attributes_Can_Be_Fixed(string attribute, string expected
await CodeFixer
.VerifyCodeFixAsync(
$$"""
- {|#0:using TUnit.Core;
+ {|#0:using Xunit;
public class MyClass
{
@@ -60,7 +60,6 @@ public void MyTest()
""",
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
$$"""
- using TUnit.Core;
public class MyClass
{
@@ -84,7 +83,7 @@ public async Task Skipped_Test_Attributes_Can_Be_Fixed(string attribute)
await CodeFixer
.VerifyCodeFixAsync(
$$"""
- {|#0:using TUnit.Core;
+ {|#0:using Xunit;
public class MyClass
{
@@ -96,7 +95,6 @@ public void MyTest()
""",
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
$$"""
- using TUnit.Core;
public class MyClass
{
@@ -116,7 +114,7 @@ public async Task Collection_Attributes_Can_Be_Fixed()
await CodeFixer
.VerifyCodeFixAsync(
"""
- {|#0:using TUnit.Core;
+ {|#0:using Xunit;
public class MyType;
@@ -138,7 +136,6 @@ public class MyCollection : ICollectionFixture
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
],
"""
- using TUnit.Core;
public class MyType;
@@ -166,7 +163,7 @@ public async Task Collection_Disable_Parallelism_Attributes_Can_Be_Fixed()
await CodeFixer
.VerifyCodeFixAsync(
"""
- {|#0:using TUnit.Core;
+ {|#0:using Xunit;
public class MyType;
@@ -188,7 +185,6 @@ public class MyCollection
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
],
"""
- using TUnit.Core;
public class MyType;
@@ -216,7 +212,7 @@ public async Task Combined_Collection_Fixture_And_Disable_Parallelism_Attributes
await CodeFixer
.VerifyCodeFixAsync(
"""
- {|#0:using TUnit.Core;
+ {|#0:using Xunit;
public class MyType;
@@ -238,7 +234,6 @@ public class MyCollection : ICollectionFixture
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
],
"""
- using TUnit.Core;
public class MyType;
@@ -329,7 +324,9 @@ public async Task ClassFixture_Can_Be_Fixed()
await CodeFixer
.VerifyCodeFixAsync(
"""
- {|#0:public class MyType;
+ {|#0:using Xunit;
+
+ public class MyType;
public class MyClass(MyType myType) : IClassFixture
{
@@ -341,6 +338,7 @@ public void MyTest()
""",
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
"""
+
public class MyType;
[ClassDataSource(Shared = SharedType.PerClass)]
@@ -362,12 +360,12 @@ public async Task Xunit_Directive_Flagged()
await Verifier
.VerifyAnalyzerAsync(
"""
- {|#0:using TUnit.Core;
+ {|#0:using Xunit;
using Xunit;
public class MyClass
{
- [Test]
+ [Fact]
public void MyTest()
{
}
@@ -384,12 +382,12 @@ public async Task Xunit_Directive_Can_Be_Removed()
await CodeFixer
.VerifyCodeFixAsync(
"""
- {|#0:using TUnit.Core;
+ {|#0:using Xunit;
using Xunit;
public class MyClass
{
- [Test]
+ [Fact]
public void MyTest()
{
}
@@ -397,7 +395,6 @@ public void MyTest()
""",
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
"""
- using TUnit.Core;
public class MyClass
{
@@ -417,7 +414,7 @@ public async Task Test_Initialize_Can_Be_Converted()
await CodeFixer
.VerifyCodeFixAsync(
"""
- {|#0:using TUnit.Core;
+ {|#0:using Xunit;
public class MyClass : IAsyncLifetime
{
@@ -439,7 +436,6 @@ public void MyTest()
""",
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
"""
- using TUnit.Core;
public class MyClass
{
@@ -471,7 +467,7 @@ public async Task NonTest_Initialize_Can_Be_Converted()
await CodeFixer
.VerifyCodeFixAsync(
"""
- {|#0:using TUnit.Core;
+ {|#0:using Xunit;
public class MyClass : IAsyncLifetime
{
@@ -488,7 +484,6 @@ public ValueTask DisposeAsync()
""",
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
"""
- using TUnit.Core;
public class MyClass : IAsyncInitializer, IAsyncDisposable
{
@@ -536,7 +531,7 @@ public async Task TheoryData_Can_Be_Converted()
await CodeFixer
.VerifyCodeFixAsync(
"""
- {|#0:using TUnit.Core;
+ {|#0:using Xunit;
public class MyClass
{
@@ -550,7 +545,6 @@ public class MyClass
""",
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
"""
- using TUnit.Core;
public class MyClass
{
@@ -598,7 +592,7 @@ public async Task ITestOutputHelper_Can_Be_Converted()
await CodeFixer
.VerifyCodeFixAsync(
"""
- {|#0:using TUnit.Core;
+ {|#0:using Xunit;
public class UnitTest1(ITestOutputHelper testOutputHelper)
{
@@ -615,7 +609,6 @@ public void Test1()
""",
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
"""
- using TUnit.Core;
public class UnitTest1()
{
@@ -637,7 +630,7 @@ public async Task Assert_Equal_Can_Be_Converted()
await CodeFixer
.VerifyCodeFixAsync(
"""
- {|#0:using TUnit.Core;
+ {|#0:using Xunit;
public class MyClass
{
@@ -650,7 +643,6 @@ public void MyTest()
""",
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
"""
- using TUnit.Core;
using System.Threading.Tasks;
public class MyClass
@@ -672,7 +664,7 @@ public async Task Assert_Matches_Can_Be_Converted()
await CodeFixer
.VerifyCodeFixAsync(
"""
- {|#0:using TUnit.Core;
+ {|#0:using Xunit;
public class MyClass
{
@@ -685,7 +677,6 @@ public void MyTest()
""",
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
"""
- using TUnit.Core;
using System.Threading.Tasks;
public class MyClass
@@ -707,7 +698,7 @@ public async Task Assert_DoesNotMatch_Can_Be_Converted()
await CodeFixer
.VerifyCodeFixAsync(
"""
- {|#0:using TUnit.Core;
+ {|#0:using Xunit;
public class MyClass
{
@@ -720,7 +711,6 @@ public void MyTest()
""",
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
"""
- using TUnit.Core;
using System.Threading.Tasks;
public class MyClass
@@ -743,7 +733,7 @@ await CodeFixer
.VerifyCodeFixAsync(
"""
{|#0:using System;
- using TUnit.Core;
+ using Xunit;
public class MyClass
{
@@ -761,7 +751,6 @@ public void MyTest()
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
"""
using System;
- using TUnit.Core;
using System.Threading.Tasks;
public class MyClass
@@ -787,7 +776,7 @@ await CodeFixer
"""
{|#0:using System;
using System.Collections.Generic;
- using TUnit.Core;
+ using Xunit;
public class MyClass
{
@@ -804,7 +793,6 @@ public void MyTest()
"""
using System;
using System.Collections.Generic;
- using TUnit.Core;
using System.Threading.Tasks;
public class MyClass
@@ -831,7 +819,7 @@ await CodeFixer
"""
{|#0:using System;
using System.Collections.Generic;
- using TUnit.Core;
+ using Xunit;
public class MyClass
{
@@ -848,7 +836,6 @@ public void MyTest()
"""
using System;
using System.Collections.Generic;
- using TUnit.Core;
using System.Threading.Tasks;
public class MyClass
@@ -873,7 +860,7 @@ public async Task Assert_Same_Can_Be_Converted()
await CodeFixer
.VerifyCodeFixAsync(
"""
- {|#0:using TUnit.Core;
+ {|#0:using Xunit;
public class MyClass
{
@@ -888,7 +875,6 @@ public void MyTest()
""",
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
"""
- using TUnit.Core;
using System.Threading.Tasks;
public class MyClass
@@ -912,7 +898,7 @@ public async Task Assert_NotSame_Can_Be_Converted()
await CodeFixer
.VerifyCodeFixAsync(
"""
- {|#0:using TUnit.Core;
+ {|#0:using Xunit;
public class MyClass
{
@@ -927,7 +913,6 @@ public void MyTest()
""",
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
"""
- using TUnit.Core;
using System.Threading.Tasks;
public class MyClass
@@ -952,7 +937,7 @@ await CodeFixer
.VerifyCodeFixAsync(
"""
{|#0:using System;
- using TUnit.Core;
+ using Xunit;
public class MyClass
{
@@ -967,7 +952,6 @@ public void MyTest()
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
"""
using System;
- using TUnit.Core;
using System.Threading.Tasks;
public class MyClass
@@ -991,7 +975,7 @@ await CodeFixer
.VerifyCodeFixAsync(
"""
{|#0:using System;
- using TUnit.Core;
+ using Xunit;
public class MyClass
{
@@ -1007,7 +991,6 @@ public void MyTest()
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
"""
using System;
- using TUnit.Core;
using System.Threading.Tasks;
public class MyClass
@@ -1040,7 +1023,7 @@ await CodeFixer
.VerifyCodeFixAsync(
"""
{|#0:using System;
- using TUnit.Core;
+ using Xunit;
public class MyClass
{
@@ -1057,7 +1040,6 @@ public void MyTest()
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
"""
using System;
- using TUnit.Core;
using System.Threading.Tasks;
public class MyClass
@@ -1065,7 +1047,7 @@ public class MyClass
[Test]
public async Task MyTest()
{
- var ex = await Assert.ThrowsAsync(() => ThrowException());
+ var ex = Assert.Throws(() => ThrowException());
await Assert.That(ex.ParamName).IsEqualTo("param");
}
@@ -1083,7 +1065,7 @@ await CodeFixer
.VerifyCodeFixAsync(
"""
{|#0:using System;
- using TUnit.Core;
+ using Xunit;
public class MyClass
{
@@ -1100,7 +1082,6 @@ public void MyTest()
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
"""
using System;
- using TUnit.Core;
using System.Threading.Tasks;
public class MyClass
@@ -1108,7 +1089,7 @@ public class MyClass
[Test]
public async Task MyTest()
{
- var ex = await Assert.ThrowsAsync(() => ThrowException());
+ var ex = Assert.Throws(() => ThrowException());
await Assert.That(ex.Message).Contains("error occurred");
}
@@ -1126,7 +1107,7 @@ await CodeFixer
.VerifyCodeFixAsync(
"""
{|#0:using System;
- using TUnit.Core;
+ using Xunit;
public class MyClass
{
@@ -1143,7 +1124,6 @@ private void DoSomething() { }
Verifier.Diagnostic(Rules.XunitMigration).WithLocation(0),
"""
using System;
- using TUnit.Core;
using System.Threading.Tasks;
public class MyClass
@@ -1170,6 +1150,220 @@ private void DoSomething() { }
);
}
+ [Test]
+ public async Task XUnit_KitchenSink_Comprehensive_Migration()
+ {
+ // This test combines MANY xUnit patterns together to ensure the code fixer
+ // can handle complex real-world scenarios in a single pass.
+ // Note: IClassFixture + IAsyncLifetime combined have complex interactions -
+ // this test focuses on patterns that work reliably together.
+ await CodeFixer
+ .VerifyCodeFixAsync(
+ """
+ {|#0:using Xunit;
+ using System;
+ using System.Collections.Generic;
+
+ public class KitchenSinkTests
+ {
+ [Fact]
+ public void BasicTest()
+ {
+ var value = 42;
+ Assert.NotNull(value);
+ Assert.Equal(42, value);
+ }
+
+ [Theory]
+ [InlineData(1, 2, 3)]
+ [InlineData(10, 20, 30)]
+ [InlineData(-1, 1, 0)]
+ public void ParameterizedTest(int a, int b, int expected)
+ {
+ var result = a + b;
+ Assert.Equal(expected, result);
+ }
+
+ [Theory]
+ [MemberData(nameof(GetTestData))]
+ public void DataSourceTest(string input, int expectedLength)
+ {
+ Assert.Equal(expectedLength, input.Length);
+ Assert.NotNull(input);
+ }
+
+ public static IEnumerable GetTestData()
+ {
+ yield return new object[] { "hello", 5 };
+ yield return new object[] { "world", 5 };
+ }
+
+ [Fact]
+ public void CollectionAssertTest()
+ {
+ var list = new List { 1, 2, 3 };
+ Assert.Contains(2, list);
+ Assert.NotEmpty(list);
+ }
+
+ [Fact]
+ public void StringAssertTest()
+ {
+ var text = "Hello World";
+ Assert.Contains("World", text);
+ Assert.StartsWith("Hello", text);
+ Assert.EndsWith("World", text);
+ }
+
+ [Fact]
+ public void ExceptionTest()
+ {
+ Assert.Throws(() => throw new ArgumentException("test"));
+ }
+
+ [Fact]
+ public async Task AsyncExceptionTest()
+ {
+ await Assert.ThrowsAsync(async () =>
+ {
+ await Task.CompletedTask;
+ throw new ArgumentException("test");
+ });
+ }
+
+ [Fact]
+ public void ComparisonAssertions()
+ {
+ var value = 42;
+ Assert.True(value > 0);
+ Assert.False(value < 0);
+ Assert.NotEqual(0, value);
+ Assert.InRange(value, 0, 100);
+ }
+
+ [Fact]
+ public void NullAssertions()
+ {
+ string? nullValue = null;
+ var notNullValue = "test";
+ Assert.Null(nullValue);
+ Assert.NotNull(notNullValue);
+ }
+
+ [Fact]
+ public void TypeAssertions()
+ {
+ object obj = "test string";
+ Assert.IsType(obj);
+ Assert.IsAssignableFrom