diff --git a/.gitignore b/.gitignore
index 149ec04978..c7af869a73 100644
--- a/.gitignore
+++ b/.gitignore
@@ -426,4 +426,13 @@ nul
# Claude Code settings
.claude/settings.local.json
-.claude/agents
\ No newline at end of file
+.claude/agents
+
+# Documentation plans
+doc/plans/
+
+# Speedscope profiling files
+*speedscope*.json
+
+# Dotnet trace files
+*.nettrace
\ No newline at end of file
diff --git a/TUnit.Analyzers.CodeFixers/NUnitExpectedResultRewriter.cs b/TUnit.Analyzers.CodeFixers/NUnitExpectedResultRewriter.cs
new file mode 100644
index 0000000000..aa0797a9e1
--- /dev/null
+++ b/TUnit.Analyzers.CodeFixers/NUnitExpectedResultRewriter.cs
@@ -0,0 +1,487 @@
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace TUnit.Analyzers.CodeFixers;
+
+///
+/// Transforms NUnit [TestCase(..., ExpectedResult = X)] patterns to TUnit assertions.
+///
+public class NUnitExpectedResultRewriter : CSharpSyntaxRewriter
+{
+ // Kept for consistency with other rewriters and potential future semantic analysis needs
+ private readonly SemanticModel _semanticModel;
+
+ public NUnitExpectedResultRewriter(SemanticModel semanticModel)
+ {
+ _semanticModel = semanticModel;
+ }
+
+ public override SyntaxNode? VisitMethodDeclaration(MethodDeclarationSyntax node)
+ {
+ // Check if method has any TestCase attributes with ExpectedResult
+ var testCaseAttributes = GetTestCaseAttributesWithExpectedResult(node);
+
+ if (testCaseAttributes.Count == 0)
+ {
+ return base.VisitMethodDeclaration(node);
+ }
+
+ // Get the return type (will become the expected parameter type)
+ var returnType = node.ReturnType;
+ if (returnType is PredefinedTypeSyntax predefined && predefined.Keyword.IsKind(SyntaxKind.VoidKeyword))
+ {
+ // void methods can't have ExpectedResult
+ return base.VisitMethodDeclaration(node);
+ }
+
+ // Transform the method
+ return TransformMethod(node, testCaseAttributes, returnType);
+ }
+
+ private List GetTestCaseAttributesWithExpectedResult(MethodDeclarationSyntax method)
+ {
+ var result = new List();
+
+ foreach (var attributeList in method.AttributeLists)
+ {
+ foreach (var attribute in attributeList.Attributes)
+ {
+ var name = attribute.Name.ToString();
+ if (name is "TestCase" or "NUnit.Framework.TestCase" or "TestCaseAttribute" or "NUnit.Framework.TestCaseAttribute")
+ {
+ if (HasExpectedResultArgument(attribute))
+ {
+ result.Add(attribute);
+ }
+ }
+ }
+ }
+
+ return result;
+ }
+
+ private bool HasExpectedResultArgument(AttributeSyntax attribute)
+ {
+ if (attribute.ArgumentList == null)
+ {
+ return false;
+ }
+
+ foreach (var arg in attribute.ArgumentList.Arguments)
+ {
+ if (arg.NameEquals?.Name.Identifier.Text == "ExpectedResult")
+ {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private MethodDeclarationSyntax TransformMethod(
+ MethodDeclarationSyntax method,
+ List testCaseAttributes,
+ TypeSyntax originalReturnType)
+ {
+ // 1. Add 'expected' parameter
+ var expectedParam = SyntaxFactory.Parameter(SyntaxFactory.Identifier("expected"))
+ .WithType(originalReturnType.WithoutTrivia().WithTrailingTrivia(SyntaxFactory.Space));
+
+ var newParameters = method.ParameterList.AddParameters(expectedParam);
+
+ // 2. Transform the body
+ var newBody = TransformBody(method, originalReturnType);
+
+ // 3. Build the new method with async Task return type
+ var asyncTaskType = SyntaxFactory.ParseTypeName("Task").WithTrailingTrivia(SyntaxFactory.Space);
+
+ var newMethod = method
+ .WithReturnType(asyncTaskType)
+ .WithParameterList(newParameters)
+ .WithBody(newBody)
+ .WithExpressionBody(null)
+ .WithSemicolonToken(default);
+
+ // 4. Add async modifier if not present
+ bool hasAsyncModifier = false;
+ foreach (var modifier in method.Modifiers)
+ {
+ if (modifier.IsKind(SyntaxKind.AsyncKeyword))
+ {
+ hasAsyncModifier = true;
+ break;
+ }
+ }
+
+ if (!hasAsyncModifier)
+ {
+ var modifiers = method.Modifiers;
+ var insertIndex = 0;
+
+ // Find the right position for async (after public/private/etc, before static)
+ for (int i = 0; i < modifiers.Count; i++)
+ {
+ if (modifiers[i].IsKind(SyntaxKind.PublicKeyword) ||
+ modifiers[i].IsKind(SyntaxKind.PrivateKeyword) ||
+ modifiers[i].IsKind(SyntaxKind.ProtectedKeyword) ||
+ modifiers[i].IsKind(SyntaxKind.InternalKeyword))
+ {
+ insertIndex = i + 1;
+ }
+ }
+
+ var asyncModifier = SyntaxFactory.Token(SyntaxKind.AsyncKeyword).WithTrailingTrivia(SyntaxFactory.Space);
+ modifiers = modifiers.Insert(insertIndex, asyncModifier);
+ newMethod = newMethod.WithModifiers(modifiers);
+ }
+
+ // 5. Update attribute lists (remove ExpectedResult from TestCase, add [Test])
+ var newAttributeLists = TransformAttributeLists(method.AttributeLists, testCaseAttributes);
+ newMethod = newMethod.WithAttributeLists(newAttributeLists);
+
+ return newMethod;
+ }
+
+ private BlockSyntax TransformBody(MethodDeclarationSyntax method, TypeSyntax returnType)
+ {
+ ExpressionSyntax returnExpression;
+
+ if (method.ExpressionBody != null)
+ {
+ // Expression-bodied: => a + b
+ returnExpression = method.ExpressionBody.Expression;
+ }
+ else if (method.Body != null)
+ {
+ // Block body - find ALL return statements recursively
+ var returnStatements = FindAllReturnStatements(method.Body);
+
+ if (returnStatements.Count == 1 && returnStatements[0].Expression != null)
+ {
+ // Single return - check if it's a simple direct return or nested
+ bool isDirectReturn = method.Body.Statements.Contains(returnStatements[0]);
+
+ if (isDirectReturn)
+ {
+ // Direct return - use the expression directly
+ returnExpression = returnStatements[0].Expression;
+
+ // Build new body with all statements except the return, plus assertion
+ var statementsWithoutReturn = new List();
+ foreach (var s in method.Body.Statements)
+ {
+ if (s != returnStatements[0])
+ {
+ statementsWithoutReturn.Add(s);
+ }
+ }
+
+ var assertStatement = CreateAssertStatement(returnExpression);
+ statementsWithoutReturn.Add(assertStatement);
+
+ return SyntaxFactory.Block(statementsWithoutReturn);
+ }
+ else
+ {
+ // Nested return - treat as multiple returns
+ return TransformMultipleReturns(method.Body, returnType);
+ }
+ }
+ else if (returnStatements.Count > 1)
+ {
+ // Multiple returns - use local variable pattern
+ return TransformMultipleReturns(method.Body, returnType);
+ }
+ else
+ {
+ // No return found - shouldn't happen for ExpectedResult
+ return method.Body;
+ }
+ }
+ else
+ {
+ // No body - shouldn't happen
+ return SyntaxFactory.Block();
+ }
+
+ // For expression-bodied, create block with assertion
+ var assertion = CreateAssertStatement(returnExpression);
+ return SyntaxFactory.Block(assertion);
+ }
+
+ private List FindAllReturnStatements(SyntaxNode node)
+ {
+ var returnStatements = new List();
+
+ foreach (var descendant in node.DescendantNodes())
+ {
+ if (descendant is ReturnStatementSyntax returnStmt)
+ {
+ returnStatements.Add(returnStmt);
+ }
+ }
+
+ return returnStatements;
+ }
+
+ private BlockSyntax TransformMultipleReturns(BlockSyntax body, TypeSyntax returnType)
+ {
+ // Declare: {returnType} result;
+ var resultDeclaration = SyntaxFactory.LocalDeclarationStatement(
+ SyntaxFactory.VariableDeclaration(returnType.WithoutTrivia().WithTrailingTrivia(SyntaxFactory.Space))
+ .WithVariables(SyntaxFactory.SingletonSeparatedList(
+ SyntaxFactory.VariableDeclarator("result"))));
+
+ // Transform the statements to use if-else chains
+ var transformedStatements = TransformStatementsWithElseChain(body.Statements);
+
+ // Add result declaration at start
+ var statements = new List { resultDeclaration };
+ statements.AddRange(transformedStatements);
+
+ // Add assertion at end
+ var assertStatement = CreateAssertStatement(
+ SyntaxFactory.IdentifierName("result"));
+ statements.Add(assertStatement);
+
+ return SyntaxFactory.Block(statements);
+ }
+
+ private List TransformStatementsWithElseChain(SyntaxList originalStatements)
+ {
+ var result = new List();
+ var ifChainParts = new List<(ExpressionSyntax condition, StatementSyntax statement)>();
+ StatementSyntax? elseStatement = null;
+
+ // First pass: collect all if statements with returns and the final return
+ for (int i = 0; i < originalStatements.Count; i++)
+ {
+ var stmt = originalStatements[i];
+
+ if (stmt is IfStatementSyntax ifStmt && ContainsReturn(ifStmt))
+ {
+ // Extract the condition and the assignment
+ var transformedIf = TransformIfStatement(ifStmt);
+
+ // If the statement is a block with a single statement, unwrap it
+ var statement = transformedIf.Statement;
+ if (statement is BlockSyntax block && block.Statements.Count == 1)
+ {
+ statement = block.Statements[0];
+ }
+
+ ifChainParts.Add((transformedIf.Condition, statement));
+ }
+ else if (stmt is ReturnStatementSyntax returnStmt && returnStmt.Expression != null)
+ {
+ // Final return statement - will become the else clause
+ elseStatement = SyntaxFactory.ExpressionStatement(
+ SyntaxFactory.AssignmentExpression(
+ SyntaxKind.SimpleAssignmentExpression,
+ SyntaxFactory.IdentifierName("result"),
+ returnStmt.Expression));
+ }
+ else
+ {
+ // Non-return statement - add any accumulated if chain first
+ if (ifChainParts.Count > 0 || elseStatement != null)
+ {
+ result.Add(BuildIfElseChain(ifChainParts, elseStatement));
+ ifChainParts.Clear();
+ elseStatement = null;
+ }
+ result.Add(stmt);
+ }
+ }
+
+ // Add any remaining if chain
+ if (ifChainParts.Count > 0 || elseStatement != null)
+ {
+ result.Add(BuildIfElseChain(ifChainParts, elseStatement));
+ }
+
+ return result;
+ }
+
+ private IfStatementSyntax BuildIfElseChain(
+ List<(ExpressionSyntax condition, StatementSyntax statement)> ifChainParts,
+ StatementSyntax? elseStatement)
+ {
+ // Build the chain from the end backwards
+ ElseClauseSyntax? elseClause = elseStatement != null
+ ? SyntaxFactory.ElseClause(elseStatement.WithoutTrivia())
+ : null;
+
+ // Build the if-else chain backwards
+ for (int i = ifChainParts.Count - 1; i >= 0; i--)
+ {
+ var (condition, statement) = ifChainParts[i];
+
+ var ifStmt = SyntaxFactory.IfStatement(
+ condition.WithoutTrivia(),
+ statement.WithoutTrivia());
+
+ if (elseClause != null)
+ {
+ ifStmt = ifStmt.WithElse(elseClause);
+ }
+
+ // This becomes the else clause for the next level up
+ if (i > 0)
+ {
+ elseClause = SyntaxFactory.ElseClause(ifStmt);
+ }
+ else
+ {
+ // This is the root
+ return ifStmt;
+ }
+ }
+
+ // Shouldn't get here if ifChainParts is not empty
+ return SyntaxFactory.IfStatement(
+ SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression),
+ SyntaxFactory.Block());
+ }
+
+ private bool ContainsReturn(SyntaxNode node)
+ {
+ return node.DescendantNodes().OfType().Any();
+ }
+
+ private IfStatementSyntax TransformIfStatement(IfStatementSyntax ifStmt)
+ {
+ // Transform the statement inside the if from 'return X;' to 'result = X;'
+ var rewriter = new ReturnToAssignmentRewriter();
+ return (IfStatementSyntax)rewriter.Visit(ifStmt);
+ }
+
+ private ExpressionStatementSyntax CreateAssertStatement(ExpressionSyntax actualExpression)
+ {
+ // await Assert.That(actualExpression).IsEqualTo(expected);
+ var assertThat = SyntaxFactory.InvocationExpression(
+ SyntaxFactory.MemberAccessExpression(
+ SyntaxKind.SimpleMemberAccessExpression,
+ SyntaxFactory.IdentifierName("Assert"),
+ SyntaxFactory.IdentifierName("That")),
+ SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(
+ SyntaxFactory.Argument(actualExpression))));
+
+ var isEqualTo = SyntaxFactory.InvocationExpression(
+ SyntaxFactory.MemberAccessExpression(
+ SyntaxKind.SimpleMemberAccessExpression,
+ assertThat,
+ SyntaxFactory.IdentifierName("IsEqualTo")),
+ SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(
+ SyntaxFactory.Argument(SyntaxFactory.IdentifierName("expected")))));
+
+ var awaitExpr = SyntaxFactory.AwaitExpression(isEqualTo);
+
+ return SyntaxFactory.ExpressionStatement(awaitExpr);
+ }
+
+ private SyntaxList TransformAttributeLists(
+ SyntaxList attributeLists,
+ List testCaseAttributes)
+ {
+ var result = new List();
+ bool hasTestAttribute = false;
+
+ foreach (var attrList in attributeLists)
+ {
+ var newAttributes = new List();
+
+ foreach (var attr in attrList.Attributes)
+ {
+ var name = attr.Name.ToString();
+
+ if (name is "Test" or "NUnit.Framework.Test")
+ {
+ hasTestAttribute = true;
+ newAttributes.Add(attr);
+ }
+ else if (testCaseAttributes.Contains(attr))
+ {
+ // Transform TestCase with ExpectedResult
+ var transformed = TransformTestCaseAttribute(attr);
+ newAttributes.Add(transformed);
+ }
+ else
+ {
+ newAttributes.Add(attr);
+ }
+ }
+
+ if (newAttributes.Count > 0)
+ {
+ result.Add(attrList.WithAttributes(SyntaxFactory.SeparatedList(newAttributes)));
+ }
+ }
+
+ // Add [Test] attribute if not present
+ if (!hasTestAttribute && result.Count > 0)
+ {
+ var testAttr = SyntaxFactory.Attribute(SyntaxFactory.IdentifierName("Test"));
+ var testAttrList = SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList(testAttr))
+ .WithLeadingTrivia(result[0].GetLeadingTrivia())
+ .WithTrailingTrivia(SyntaxFactory.EndOfLine("\n"));
+ result.Insert(0, testAttrList);
+ }
+
+ return SyntaxFactory.List(result);
+ }
+
+ private AttributeSyntax TransformTestCaseAttribute(AttributeSyntax attribute)
+ {
+ if (attribute.ArgumentList == null)
+ {
+ return attribute;
+ }
+
+ var newArgs = new List();
+ ExpressionSyntax? expectedValue = null;
+
+ foreach (var arg in attribute.ArgumentList.Arguments)
+ {
+ if (arg.NameEquals?.Name.Identifier.Text == "ExpectedResult")
+ {
+ expectedValue = arg.Expression;
+ }
+ else if (arg.NameColon == null && arg.NameEquals == null)
+ {
+ // Positional argument - keep it
+ newArgs.Add(arg);
+ }
+ // Skip other named arguments for now
+ }
+
+ // Add expected value as last positional argument
+ if (expectedValue != null)
+ {
+ newArgs.Add(SyntaxFactory.AttributeArgument(expectedValue));
+ }
+
+ // The attribute will be renamed to "Arguments" by the existing attribute rewriter
+ return attribute.WithArgumentList(
+ SyntaxFactory.AttributeArgumentList(SyntaxFactory.SeparatedList(newArgs)));
+ }
+
+ private class ReturnToAssignmentRewriter : CSharpSyntaxRewriter
+ {
+ public override SyntaxNode? VisitReturnStatement(ReturnStatementSyntax node)
+ {
+ if (node.Expression == null)
+ {
+ return node;
+ }
+
+ // return X; -> result = X;
+ return SyntaxFactory.ExpressionStatement(
+ SyntaxFactory.AssignmentExpression(
+ SyntaxKind.SimpleAssignmentExpression,
+ SyntaxFactory.IdentifierName("result"),
+ node.Expression));
+ }
+ }
+}
diff --git a/TUnit.Analyzers.CodeFixers/NUnitMigrationCodeFixProvider.cs b/TUnit.Analyzers.CodeFixers/NUnitMigrationCodeFixProvider.cs
index 15a494205e..9324db3cbb 100644
--- a/TUnit.Analyzers.CodeFixers/NUnitMigrationCodeFixProvider.cs
+++ b/TUnit.Analyzers.CodeFixers/NUnitMigrationCodeFixProvider.cs
@@ -37,7 +37,10 @@ protected override CSharpSyntaxRewriter CreateLifecycleRewriter(Compilation comp
protected override CompilationUnitSyntax ApplyFrameworkSpecificConversions(CompilationUnitSyntax compilationUnit, SemanticModel semanticModel, Compilation compilation)
{
- // NUnit-specific conversions if needed
+ // Transform ExpectedResult patterns before attribute conversion
+ var expectedResultRewriter = new NUnitExpectedResultRewriter(semanticModel);
+ compilationUnit = (CompilationUnitSyntax)expectedResultRewriter.Visit(compilationUnit);
+
return compilationUnit;
}
}
diff --git a/TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs b/TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs
index ef9ea4e83b..9a28a47fc4 100644
--- a/TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs
+++ b/TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs
@@ -581,6 +581,153 @@ public void TestMultipleAssertions()
);
}
+ [Test]
+ public async Task NUnit_ExpectedResult_Converted()
+ {
+ await CodeFixer.VerifyCodeFixAsync(
+ """
+ using NUnit.Framework;
+
+ public class MyClass
+ {
+ {|#0:[TestCase(2, 3, ExpectedResult = 5)]|}
+ public int Add(int a, int b) => a + b;
+ }
+ """,
+ 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]
+ [Arguments(2, 3, 5)]
+ public async Task Add(int a, int b, int expected)
+ {
+ await Assert.That(a + b).IsEqualTo(expected);
+ }
+ }
+ """,
+ ConfigureNUnitTest
+ );
+ }
+
+ [Test]
+ public async Task NUnit_Multiple_ExpectedResult_Converted()
+ {
+ await CodeFixer.VerifyCodeFixAsync(
+ """
+ using NUnit.Framework;
+
+ public class MyClass
+ {
+ {|#0:[TestCase(2, 3, ExpectedResult = 5)]|}
+ [TestCase(10, 5, ExpectedResult = 15)]
+ [TestCase(0, 0, ExpectedResult = 0)]
+ public int Add(int a, int b) => a + b;
+ }
+ """,
+ 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]
+ [Arguments(2, 3, 5)]
+ [Arguments(10, 5, 15)]
+ [Arguments(0, 0, 0)]
+ public async Task Add(int a, int b, int expected)
+ {
+ await Assert.That(a + b).IsEqualTo(expected);
+ }
+ }
+ """,
+ ConfigureNUnitTest
+ );
+ }
+
+ [Test]
+ public async Task NUnit_ExpectedResult_BlockBody_SingleReturn_Converted()
+ {
+ await CodeFixer.VerifyCodeFixAsync(
+ """
+ using NUnit.Framework;
+
+ public class MyClass
+ {
+ {|#0:[TestCase(2, 3, ExpectedResult = 5)]|}
+ public int Add(int a, int b)
+ {
+ var sum = a + b;
+ return sum;
+ }
+ }
+ """,
+ 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]
+ [Arguments(2, 3, 5)]
+ public async Task Add(int a, int b, int expected)
+ {
+ var sum = a + b;
+ await Assert.That(sum).IsEqualTo(expected);
+ }
+ }
+ """,
+ ConfigureNUnitTest
+ );
+ }
+
+ [Test]
+ public async Task NUnit_ExpectedResult_String_Converted()
+ {
+ await CodeFixer.VerifyCodeFixAsync(
+ """
+ using NUnit.Framework;
+
+ public class MyClass
+ {
+ {|#0:[TestCase("hello", ExpectedResult = "HELLO")]|}
+ [TestCase("World", ExpectedResult = "WORLD")]
+ public string ToUpper(string input) => input.ToUpper();
+ }
+ """,
+ 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]
+ [Arguments("hello", "HELLO")]
+ [Arguments("World", "WORLD")]
+ public async Task ToUpper(string input, string expected)
+ {
+ await Assert.That(input.ToUpper()).IsEqualTo(expected);
+ }
+ }
+ """,
+ ConfigureNUnitTest
+ );
+ }
+
private static void ConfigureNUnitTest(Verifier.Test test)
{
test.TestState.AdditionalReferences.Add(typeof(NUnit.Framework.TestAttribute).Assembly);
diff --git a/TUnit.PerformanceBenchmarks/.gitignore b/TUnit.PerformanceBenchmarks/.gitignore
new file mode 100644
index 0000000000..afd0852c1c
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/.gitignore
@@ -0,0 +1,7 @@
+# Profile results (large binary files)
+Results/*.nettrace
+Results/*.speedscope.json
+Results/*.etl
+
+# Keep the results directory but ignore generated baselines
+# (Users can commit specific baselines they want to track)
diff --git a/TUnit.PerformanceBenchmarks/Profiles/profile-cpu.ps1 b/TUnit.PerformanceBenchmarks/Profiles/profile-cpu.ps1
new file mode 100644
index 0000000000..8a5ccc9db5
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Profiles/profile-cpu.ps1
@@ -0,0 +1,50 @@
+# Profile TUnit.PerformanceBenchmarks with dotnet-trace (CPU)
+# Usage: .\profile-cpu.ps1 [-Scale 1000]
+
+param(
+ [int]$Scale = 1000,
+ [string]$OutputDir = ".\Results"
+)
+
+$ErrorActionPreference = "Stop"
+$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$projectDir = Split-Path -Parent $scriptDir
+
+Push-Location $projectDir
+try {
+ # Ensure output directory exists
+ New-Item -ItemType Directory -Path $OutputDir -Force | Out-Null
+
+ # Regenerate tests for the specified scale
+ Write-Host "Generating tests for scale: $Scale" -ForegroundColor Cyan
+ & pwsh -ExecutionPolicy Bypass -File "$projectDir\generate-tests.ps1" -Scale $Scale
+
+ # Build the project
+ Write-Host "Building project..." -ForegroundColor Cyan
+ dotnet build -c Release --no-restore
+
+ # Generate timestamp for output files
+ $timestamp = Get-Date -Format "yyyy-MM-dd_HHmmss"
+ $traceFile = "$OutputDir\cpu-trace-$Scale-$timestamp.nettrace"
+
+ Write-Host "Starting CPU profile capture..." -ForegroundColor Cyan
+ Write-Host "Trace will be saved to: $traceFile" -ForegroundColor Yellow
+
+ # Run with dotnet-trace
+ dotnet-trace collect `
+ --output $traceFile `
+ -- dotnet run -c Release --no-build
+
+ Write-Host "Profile captured: $traceFile" -ForegroundColor Green
+
+ # Convert to SpeedScope format
+ $speedscopeFile = $traceFile -replace "\.nettrace$", ".speedscope.json"
+ Write-Host "Converting to SpeedScope format..." -ForegroundColor Cyan
+ dotnet-trace convert $traceFile --format speedscope
+
+ Write-Host "SpeedScope file: $speedscopeFile" -ForegroundColor Green
+ Write-Host "Open https://speedscope.app and drag the .speedscope.json file to view" -ForegroundColor Yellow
+}
+finally {
+ Pop-Location
+}
diff --git a/TUnit.PerformanceBenchmarks/Profiles/profile-gc.ps1 b/TUnit.PerformanceBenchmarks/Profiles/profile-gc.ps1
new file mode 100644
index 0000000000..3eb04203e0
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Profiles/profile-gc.ps1
@@ -0,0 +1,51 @@
+# Profile TUnit.PerformanceBenchmarks with dotnet-trace (GC/Allocations)
+# Usage: .\profile-gc.ps1 [-Scale 1000]
+
+param(
+ [int]$Scale = 1000,
+ [string]$OutputDir = ".\Results"
+)
+
+$ErrorActionPreference = "Stop"
+$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$projectDir = Split-Path -Parent $scriptDir
+
+Push-Location $projectDir
+try {
+ # Ensure output directory exists
+ New-Item -ItemType Directory -Path $OutputDir -Force | Out-Null
+
+ # Regenerate tests for the specified scale
+ Write-Host "Generating tests for scale: $Scale" -ForegroundColor Cyan
+ & pwsh -ExecutionPolicy Bypass -File "$projectDir\generate-tests.ps1" -Scale $Scale
+
+ # Build the project
+ Write-Host "Building project..." -ForegroundColor Cyan
+ dotnet build -c Release --no-restore
+
+ # Generate timestamp for output files
+ $timestamp = Get-Date -Format "yyyy-MM-dd_HHmmss"
+ $traceFile = "$OutputDir\gc-trace-$Scale-$timestamp.nettrace"
+
+ Write-Host "Starting GC/allocation profile capture..." -ForegroundColor Cyan
+ Write-Host "Trace will be saved to: $traceFile" -ForegroundColor Yellow
+
+ # Run with dotnet-trace using gc-verbose profile
+ dotnet-trace collect `
+ --profile gc-verbose `
+ --output $traceFile `
+ -- dotnet run -c Release --no-build
+
+ Write-Host "Profile captured: $traceFile" -ForegroundColor Green
+
+ # Convert to SpeedScope format
+ $speedscopeFile = $traceFile -replace "\.nettrace$", ".speedscope.json"
+ Write-Host "Converting to SpeedScope format..." -ForegroundColor Cyan
+ dotnet-trace convert $traceFile --format speedscope
+
+ Write-Host "SpeedScope file: $speedscopeFile" -ForegroundColor Green
+ Write-Host "Open https://speedscope.app and drag the .speedscope.json file to view" -ForegroundColor Yellow
+}
+finally {
+ Pop-Location
+}
diff --git a/TUnit.PerformanceBenchmarks/Profiles/run-baseline.ps1 b/TUnit.PerformanceBenchmarks/Profiles/run-baseline.ps1
new file mode 100644
index 0000000000..aeb92f7c7a
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Profiles/run-baseline.ps1
@@ -0,0 +1,100 @@
+# Run baseline benchmarks at all scale tiers
+# Usage: .\run-baseline.ps1
+
+param(
+ [string]$OutputDir = ".\Results"
+)
+
+$ErrorActionPreference = "Stop"
+$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$projectDir = Split-Path -Parent $scriptDir
+
+$scales = @(100, 500, 1000, 5000, 10000)
+$timestamp = Get-Date -Format "yyyy-MM-dd_HHmmss"
+$resultsFile = "$OutputDir\baseline-$timestamp.md"
+
+Push-Location $projectDir
+try {
+ # Ensure output directory exists
+ New-Item -ItemType Directory -Path $OutputDir -Force | Out-Null
+
+ # Initialize results file
+ @"
+# TUnit Performance Baseline
+Generated: $(Get-Date -Format "yyyy-MM-dd HH:mm:ss")
+
+## Environment
+- OS: $([System.Environment]::OSVersion.VersionString)
+- CPU: $((Get-CimInstance Win32_Processor).Name)
+- .NET: $(dotnet --version)
+- TUnit: $(git describe --tags --always 2>$null || 'unknown')
+
+## Results
+
+| Scale | Tests | Discovery (ms) | Execution (ms) | Total (ms) | GC Gen0 | GC Gen1 | GC Gen2 |
+|-------|-------|----------------|----------------|------------|---------|---------|---------|
+"@ | Out-File -FilePath $resultsFile -Encoding utf8
+
+ foreach ($scale in $scales) {
+ Write-Host "`n========================================" -ForegroundColor Cyan
+ Write-Host "Running benchmark at scale: $scale" -ForegroundColor Cyan
+ Write-Host "========================================`n" -ForegroundColor Cyan
+
+ # Regenerate tests for the specified scale
+ & pwsh -ExecutionPolicy Bypass -File "$projectDir\generate-tests.ps1" -Scale $scale
+
+ # Build the project
+ Write-Host "Building project..." -ForegroundColor Yellow
+ dotnet build -c Release --no-restore 2>&1 | Out-Null
+
+ # Run and capture timing
+ Write-Host "Running tests..." -ForegroundColor Yellow
+ $sw = [System.Diagnostics.Stopwatch]::StartNew()
+
+ # Capture GC stats before
+ $gcBefore = @(
+ [GC]::CollectionCount(0),
+ [GC]::CollectionCount(1),
+ [GC]::CollectionCount(2)
+ )
+
+ $output = dotnet run -c Release --no-build 2>&1
+
+ $sw.Stop()
+
+ # Capture GC stats after
+ $gcAfter = @(
+ [GC]::CollectionCount(0),
+ [GC]::CollectionCount(1),
+ [GC]::CollectionCount(2)
+ )
+
+ $gcDelta = @(
+ $gcAfter[0] - $gcBefore[0],
+ $gcAfter[1] - $gcBefore[1],
+ $gcAfter[2] - $gcBefore[2]
+ )
+
+ $totalMs = $sw.ElapsedMilliseconds
+
+ # Parse test count from output
+ $testCount = if ($output -match "(\d+) test[s]? passed") { $matches[1] } else { "?" }
+
+ Write-Host "Completed in ${totalMs}ms" -ForegroundColor Green
+
+ # Append to results file
+ "| $scale | $testCount | - | - | $totalMs | $($gcDelta[0]) | $($gcDelta[1]) | $($gcDelta[2]) |" |
+ Out-File -FilePath $resultsFile -Encoding utf8 -Append
+ }
+
+ Write-Host "`n========================================" -ForegroundColor Green
+ Write-Host "Baseline complete! Results saved to:" -ForegroundColor Green
+ Write-Host $resultsFile -ForegroundColor Yellow
+ Write-Host "========================================`n" -ForegroundColor Green
+
+ # Display results
+ Get-Content $resultsFile
+}
+finally {
+ Pop-Location
+}
diff --git a/TUnit.PerformanceBenchmarks/Results/.gitkeep b/TUnit.PerformanceBenchmarks/Results/.gitkeep
new file mode 100644
index 0000000000..2905e7f521
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Results/.gitkeep
@@ -0,0 +1,2 @@
+# This directory stores profiling results
+# .nettrace and .speedscope.json files are gitignored
diff --git a/TUnit.PerformanceBenchmarks/TUnit.PerformanceBenchmarks.csproj b/TUnit.PerformanceBenchmarks/TUnit.PerformanceBenchmarks.csproj
new file mode 100644
index 0000000000..e1cfab4ef0
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/TUnit.PerformanceBenchmarks.csproj
@@ -0,0 +1,28 @@
+
+
+
+
+
+
+
+ net9.0
+ enable
+ enable
+
+
+ 1000
+
+
+
+
+
+
+
+
+
+ $(DefineConstants);SCALE_$(BenchmarkScale)
+
+
+
+
+
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_01.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_01.cs
new file mode 100644
index 0000000000..e82acf264d
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_01.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_01
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_02.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_02.cs
new file mode 100644
index 0000000000..e930ca0728
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_02.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_02
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_03.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_03.cs
new file mode 100644
index 0000000000..5a0fb0def6
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_03.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_03
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_04.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_04.cs
new file mode 100644
index 0000000000..fae9f2d9e9
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_04.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_04
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_05.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_05.cs
new file mode 100644
index 0000000000..ec4e892527
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_05.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_05
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_06.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_06.cs
new file mode 100644
index 0000000000..b49feee81c
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_06.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_06
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_07.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_07.cs
new file mode 100644
index 0000000000..629fd03e2e
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_07.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_07
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_08.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_08.cs
new file mode 100644
index 0000000000..b13dbf48e9
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_08.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_08
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_09.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_09.cs
new file mode 100644
index 0000000000..76a876bb0c
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_09.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_09
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_10.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_10.cs
new file mode 100644
index 0000000000..031d609d2f
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_10.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_10
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_100.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_100.cs
new file mode 100644
index 0000000000..0945b1b088
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_100.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_100
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_11.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_11.cs
new file mode 100644
index 0000000000..854cbe4557
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_11.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_11
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_12.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_12.cs
new file mode 100644
index 0000000000..4b8964f188
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_12.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_12
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_13.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_13.cs
new file mode 100644
index 0000000000..d1bdcc05af
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_13.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_13
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_14.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_14.cs
new file mode 100644
index 0000000000..85753eba28
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_14.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_14
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_15.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_15.cs
new file mode 100644
index 0000000000..c01c48ea2d
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_15.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_15
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_16.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_16.cs
new file mode 100644
index 0000000000..8ba1e4f8ea
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_16.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_16
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_17.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_17.cs
new file mode 100644
index 0000000000..888365c87b
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_17.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_17
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_18.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_18.cs
new file mode 100644
index 0000000000..3aad541970
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_18.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_18
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_19.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_19.cs
new file mode 100644
index 0000000000..ad6c3bcfb9
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_19.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_19
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_20.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_20.cs
new file mode 100644
index 0000000000..efa9f6d33a
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_20.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_20
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_21.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_21.cs
new file mode 100644
index 0000000000..895b6e4a9f
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_21.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_21
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_22.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_22.cs
new file mode 100644
index 0000000000..50e95b2d77
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_22.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_22
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_23.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_23.cs
new file mode 100644
index 0000000000..02928b1e89
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_23.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_23
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_24.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_24.cs
new file mode 100644
index 0000000000..004b906453
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_24.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_24
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_25.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_25.cs
new file mode 100644
index 0000000000..e92b2884b5
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_25.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_25
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_26.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_26.cs
new file mode 100644
index 0000000000..fca1e19d4f
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_26.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_26
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_27.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_27.cs
new file mode 100644
index 0000000000..d907d9a1b8
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_27.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_27
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_28.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_28.cs
new file mode 100644
index 0000000000..5cf2ee4fee
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_28.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_28
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_29.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_29.cs
new file mode 100644
index 0000000000..f1c46bab93
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_29.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_29
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_30.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_30.cs
new file mode 100644
index 0000000000..fb1d050ad7
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_30.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_30
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_31.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_31.cs
new file mode 100644
index 0000000000..3ae082621a
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_31.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_31
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_32.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_32.cs
new file mode 100644
index 0000000000..02861d0041
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_32.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_32
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_33.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_33.cs
new file mode 100644
index 0000000000..db6ae49202
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_33.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_33
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_34.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_34.cs
new file mode 100644
index 0000000000..6eb7a9936f
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_34.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_34
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_35.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_35.cs
new file mode 100644
index 0000000000..94dbd66710
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_35.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_35
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_36.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_36.cs
new file mode 100644
index 0000000000..4d2f88c133
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_36.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_36
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_37.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_37.cs
new file mode 100644
index 0000000000..7a2ad904e1
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_37.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_37
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_38.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_38.cs
new file mode 100644
index 0000000000..93875bbf12
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_38.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_38
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_39.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_39.cs
new file mode 100644
index 0000000000..814604fe6d
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_39.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_39
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_40.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_40.cs
new file mode 100644
index 0000000000..cc2770f7dc
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_40.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_40
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_41.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_41.cs
new file mode 100644
index 0000000000..fe22bfd9a3
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_41.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_41
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_42.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_42.cs
new file mode 100644
index 0000000000..b5db613731
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_42.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_42
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_43.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_43.cs
new file mode 100644
index 0000000000..8600f2a524
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_43.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_43
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_44.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_44.cs
new file mode 100644
index 0000000000..4a43ce105d
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_44.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_44
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_45.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_45.cs
new file mode 100644
index 0000000000..5bae9381c5
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_45.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_45
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_46.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_46.cs
new file mode 100644
index 0000000000..cb1c8df1a2
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_46.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_46
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_47.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_47.cs
new file mode 100644
index 0000000000..b382ce814c
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_47.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_47
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_48.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_48.cs
new file mode 100644
index 0000000000..ddecaa76e0
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_48.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_48
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_49.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_49.cs
new file mode 100644
index 0000000000..493889c15b
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_49.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_49
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_50.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_50.cs
new file mode 100644
index 0000000000..3bc0a91342
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_50.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_50
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_51.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_51.cs
new file mode 100644
index 0000000000..523734e237
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_51.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_51
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_52.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_52.cs
new file mode 100644
index 0000000000..7aff7870f6
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_52.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_52
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_53.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_53.cs
new file mode 100644
index 0000000000..a8d40a4474
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_53.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_53
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_54.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_54.cs
new file mode 100644
index 0000000000..b3cfed3d29
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_54.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_54
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_55.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_55.cs
new file mode 100644
index 0000000000..e2dcca2611
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_55.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_55
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_56.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_56.cs
new file mode 100644
index 0000000000..8c3e296bb5
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_56.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_56
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_57.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_57.cs
new file mode 100644
index 0000000000..20ceeb8cbd
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_57.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_57
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_58.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_58.cs
new file mode 100644
index 0000000000..71cafcf06e
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_58.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_58
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_59.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_59.cs
new file mode 100644
index 0000000000..e2ad06d156
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_59.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_59
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_60.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_60.cs
new file mode 100644
index 0000000000..8fa31c1e74
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_60.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_60
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_61.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_61.cs
new file mode 100644
index 0000000000..8750adaff8
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_61.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_61
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_62.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_62.cs
new file mode 100644
index 0000000000..8b1e131241
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_62.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_62
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_63.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_63.cs
new file mode 100644
index 0000000000..d1200ee8b4
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_63.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_63
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_64.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_64.cs
new file mode 100644
index 0000000000..8bde987419
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_64.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_64
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_65.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_65.cs
new file mode 100644
index 0000000000..0d27ea4603
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_65.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_65
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_66.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_66.cs
new file mode 100644
index 0000000000..19e11bd015
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_66.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_66
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_67.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_67.cs
new file mode 100644
index 0000000000..9ef93fb6ee
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_67.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_67
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_68.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_68.cs
new file mode 100644
index 0000000000..a3fadf0b3c
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_68.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_68
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_69.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_69.cs
new file mode 100644
index 0000000000..c27da7a16a
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_69.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_69
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_70.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_70.cs
new file mode 100644
index 0000000000..f9389eb22f
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_70.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_70
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_71.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_71.cs
new file mode 100644
index 0000000000..bb96ff40db
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_71.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_71
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_72.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_72.cs
new file mode 100644
index 0000000000..0955e87a65
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_72.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_72
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_73.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_73.cs
new file mode 100644
index 0000000000..fbf14a1c12
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_73.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_73
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_74.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_74.cs
new file mode 100644
index 0000000000..b0737cf422
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_74.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_74
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_75.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_75.cs
new file mode 100644
index 0000000000..f4714bfe3e
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_75.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_75
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_76.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_76.cs
new file mode 100644
index 0000000000..6ddc426332
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_76.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_76
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_77.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_77.cs
new file mode 100644
index 0000000000..7edfe230c6
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_77.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_77
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_78.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_78.cs
new file mode 100644
index 0000000000..ec5defa035
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_78.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_78
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_79.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_79.cs
new file mode 100644
index 0000000000..bebc27ddc2
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_79.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_79
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_80.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_80.cs
new file mode 100644
index 0000000000..743b2dc940
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_80.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_80
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_81.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_81.cs
new file mode 100644
index 0000000000..0113682de2
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_81.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_81
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_82.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_82.cs
new file mode 100644
index 0000000000..2a9d6e4545
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_82.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_82
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_83.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_83.cs
new file mode 100644
index 0000000000..8eff28cac1
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_83.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_83
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_84.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_84.cs
new file mode 100644
index 0000000000..01c932e094
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_84.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_84
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_85.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_85.cs
new file mode 100644
index 0000000000..9eaaef31ec
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_85.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_85
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_86.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_86.cs
new file mode 100644
index 0000000000..6219ddf351
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_86.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_86
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_87.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_87.cs
new file mode 100644
index 0000000000..aca35c6db7
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_87.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_87
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_88.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_88.cs
new file mode 100644
index 0000000000..05dda1b612
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_88.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_88
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_89.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_89.cs
new file mode 100644
index 0000000000..63396c299c
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_89.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_89
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_90.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_90.cs
new file mode 100644
index 0000000000..07ee2f0419
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_90.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_90
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_91.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_91.cs
new file mode 100644
index 0000000000..56f340e34f
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_91.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_91
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_92.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_92.cs
new file mode 100644
index 0000000000..6529edd209
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_92.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_92
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_93.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_93.cs
new file mode 100644
index 0000000000..b9c25ec171
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_93.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_93
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_94.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_94.cs
new file mode 100644
index 0000000000..071b1fc5d1
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_94.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_94
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_95.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_95.cs
new file mode 100644
index 0000000000..0070ce45fd
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_95.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_95
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_96.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_96.cs
new file mode 100644
index 0000000000..b2c54ad3c4
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_96.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_96
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_97.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_97.cs
new file mode 100644
index 0000000000..09407e1594
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_97.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_97
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_98.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_98.cs
new file mode 100644
index 0000000000..c1c30a4d1d
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_98.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_98
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_99.cs b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_99.cs
new file mode 100644
index 0000000000..d7f5c49cac
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/DataDriven/DataDrivenTests_99.cs
@@ -0,0 +1,22 @@
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class DataDrivenTests_99
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_01.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_01.cs
new file mode 100644
index 0000000000..e81944fb40
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_01.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_01 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_02.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_02.cs
new file mode 100644
index 0000000000..61e69c4eaa
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_02.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_02 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_03.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_03.cs
new file mode 100644
index 0000000000..8981d53d6a
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_03.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_03 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_04.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_04.cs
new file mode 100644
index 0000000000..051bd59fb5
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_04.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_04 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_05.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_05.cs
new file mode 100644
index 0000000000..f512560322
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_05.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_05 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_06.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_06.cs
new file mode 100644
index 0000000000..9742e5b8dd
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_06.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_06 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_07.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_07.cs
new file mode 100644
index 0000000000..26577e7d36
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_07.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_07 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_08.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_08.cs
new file mode 100644
index 0000000000..00b271f06d
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_08.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_08 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_09.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_09.cs
new file mode 100644
index 0000000000..4b1c051d2f
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_09.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_09 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_10.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_10.cs
new file mode 100644
index 0000000000..af7cafaff2
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_10.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_10 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_100.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_100.cs
new file mode 100644
index 0000000000..0111b33b01
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_100.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_100 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_11.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_11.cs
new file mode 100644
index 0000000000..b306a6dc17
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_11.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_11 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_12.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_12.cs
new file mode 100644
index 0000000000..a46047258c
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_12.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_12 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_13.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_13.cs
new file mode 100644
index 0000000000..8560e8957f
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_13.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_13 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_14.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_14.cs
new file mode 100644
index 0000000000..3328d63651
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_14.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_14 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_15.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_15.cs
new file mode 100644
index 0000000000..52c7797360
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_15.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_15 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_16.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_16.cs
new file mode 100644
index 0000000000..a26c50c8ae
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_16.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_16 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_17.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_17.cs
new file mode 100644
index 0000000000..8a0a811196
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_17.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_17 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_18.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_18.cs
new file mode 100644
index 0000000000..c2a5215310
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_18.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_18 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_19.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_19.cs
new file mode 100644
index 0000000000..6adffd381e
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_19.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_19 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_20.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_20.cs
new file mode 100644
index 0000000000..0ca55e5b9a
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_20.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_20 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_21.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_21.cs
new file mode 100644
index 0000000000..7a1d138a52
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_21.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_21 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_22.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_22.cs
new file mode 100644
index 0000000000..1093487c78
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_22.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_22 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_23.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_23.cs
new file mode 100644
index 0000000000..a932c6be8d
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_23.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_23 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_24.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_24.cs
new file mode 100644
index 0000000000..e9950bd3da
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_24.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_24 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_25.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_25.cs
new file mode 100644
index 0000000000..9795c055c8
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_25.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_25 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_26.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_26.cs
new file mode 100644
index 0000000000..a6cc9f4b60
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_26.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_26 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_27.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_27.cs
new file mode 100644
index 0000000000..3e8edc42a3
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_27.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_27 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_28.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_28.cs
new file mode 100644
index 0000000000..e080dd2fba
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_28.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_28 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_29.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_29.cs
new file mode 100644
index 0000000000..466c8cfed6
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_29.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_29 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_30.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_30.cs
new file mode 100644
index 0000000000..7d45f1e342
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_30.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_30 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_31.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_31.cs
new file mode 100644
index 0000000000..b67e7a1874
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_31.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_31 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_32.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_32.cs
new file mode 100644
index 0000000000..4b64a88237
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_32.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_32 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_33.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_33.cs
new file mode 100644
index 0000000000..c248c373bb
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_33.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_33 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_34.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_34.cs
new file mode 100644
index 0000000000..5e7a1ee40c
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_34.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_34 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_35.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_35.cs
new file mode 100644
index 0000000000..4434e7c5c0
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_35.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_35 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_36.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_36.cs
new file mode 100644
index 0000000000..387cd5453c
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_36.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_36 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_37.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_37.cs
new file mode 100644
index 0000000000..9ae87dd4ab
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_37.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_37 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_38.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_38.cs
new file mode 100644
index 0000000000..9adb04b2ff
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_38.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_38 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_39.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_39.cs
new file mode 100644
index 0000000000..ef18649149
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_39.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_39 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_40.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_40.cs
new file mode 100644
index 0000000000..dd198c01eb
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_40.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_40 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_41.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_41.cs
new file mode 100644
index 0000000000..8def65d1e2
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_41.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_41 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_42.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_42.cs
new file mode 100644
index 0000000000..3225660b25
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_42.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_42 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_43.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_43.cs
new file mode 100644
index 0000000000..89938bc0ce
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_43.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_43 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_44.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_44.cs
new file mode 100644
index 0000000000..fdb4aac33e
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_44.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_44 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_45.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_45.cs
new file mode 100644
index 0000000000..8190d6f534
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_45.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_45 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_46.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_46.cs
new file mode 100644
index 0000000000..0dc13ea650
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_46.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_46 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_47.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_47.cs
new file mode 100644
index 0000000000..394df81943
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_47.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_47 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_48.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_48.cs
new file mode 100644
index 0000000000..976699bb65
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_48.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_48 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_49.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_49.cs
new file mode 100644
index 0000000000..ca7a04dec5
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_49.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_49 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_50.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_50.cs
new file mode 100644
index 0000000000..a8dc3063c1
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_50.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_50 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_51.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_51.cs
new file mode 100644
index 0000000000..da8168019c
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_51.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_51 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_52.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_52.cs
new file mode 100644
index 0000000000..5a8efc572b
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_52.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_52 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_53.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_53.cs
new file mode 100644
index 0000000000..2bad479f25
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_53.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_53 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_54.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_54.cs
new file mode 100644
index 0000000000..f1af204a5a
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_54.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_54 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_55.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_55.cs
new file mode 100644
index 0000000000..430cd88e5d
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_55.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_55 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_56.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_56.cs
new file mode 100644
index 0000000000..858654676b
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_56.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_56 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_57.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_57.cs
new file mode 100644
index 0000000000..1b53ff39ff
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_57.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_57 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_58.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_58.cs
new file mode 100644
index 0000000000..52c1c06540
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_58.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_58 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_59.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_59.cs
new file mode 100644
index 0000000000..9a89dbb30f
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_59.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_59 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_60.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_60.cs
new file mode 100644
index 0000000000..45c7b6816a
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_60.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_60 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_61.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_61.cs
new file mode 100644
index 0000000000..36e74e5e30
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_61.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_61 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_62.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_62.cs
new file mode 100644
index 0000000000..fdd0464b14
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_62.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_62 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_63.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_63.cs
new file mode 100644
index 0000000000..681fd8a4d4
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_63.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_63 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_64.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_64.cs
new file mode 100644
index 0000000000..adb36b361e
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_64.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_64 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_65.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_65.cs
new file mode 100644
index 0000000000..ea3414e77c
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_65.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_65 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_66.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_66.cs
new file mode 100644
index 0000000000..a49c0d2b3e
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_66.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_66 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_67.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_67.cs
new file mode 100644
index 0000000000..dcdc581c79
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_67.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_67 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_68.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_68.cs
new file mode 100644
index 0000000000..0ad737c3d8
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_68.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_68 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_69.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_69.cs
new file mode 100644
index 0000000000..7bdba55180
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_69.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_69 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_70.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_70.cs
new file mode 100644
index 0000000000..9fa4c42ab0
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_70.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_70 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_71.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_71.cs
new file mode 100644
index 0000000000..4c7f9a8319
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_71.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_71 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_72.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_72.cs
new file mode 100644
index 0000000000..f1164b96a2
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_72.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_72 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_73.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_73.cs
new file mode 100644
index 0000000000..3f33c2f472
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_73.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_73 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_74.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_74.cs
new file mode 100644
index 0000000000..28856df61f
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_74.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_74 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_75.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_75.cs
new file mode 100644
index 0000000000..c3c809195f
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_75.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_75 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_76.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_76.cs
new file mode 100644
index 0000000000..fe74f8e111
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_76.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_76 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_77.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_77.cs
new file mode 100644
index 0000000000..21b0918df4
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_77.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_77 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_78.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_78.cs
new file mode 100644
index 0000000000..cc749562f5
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_78.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_78 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_79.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_79.cs
new file mode 100644
index 0000000000..2ac95606de
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_79.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_79 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_80.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_80.cs
new file mode 100644
index 0000000000..9a6ffe5c16
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_80.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_80 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_81.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_81.cs
new file mode 100644
index 0000000000..de72f16bed
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_81.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_81 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_82.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_82.cs
new file mode 100644
index 0000000000..906279dcfc
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_82.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_82 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_83.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_83.cs
new file mode 100644
index 0000000000..6b5fd9ecf5
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_83.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_83 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_84.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_84.cs
new file mode 100644
index 0000000000..9d2e99f2fe
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_84.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_84 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_85.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_85.cs
new file mode 100644
index 0000000000..a462086847
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_85.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_85 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_86.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_86.cs
new file mode 100644
index 0000000000..59dc5a1d87
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_86.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_86 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_87.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_87.cs
new file mode 100644
index 0000000000..f89ed3b09f
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_87.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_87 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_88.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_88.cs
new file mode 100644
index 0000000000..15759d6580
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_88.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_88 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_89.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_89.cs
new file mode 100644
index 0000000000..b4e9d3d4bd
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_89.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_89 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_90.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_90.cs
new file mode 100644
index 0000000000..d71ae4af4f
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_90.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_90 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_91.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_91.cs
new file mode 100644
index 0000000000..eb109e9867
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_91.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_91 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_92.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_92.cs
new file mode 100644
index 0000000000..a08b84eccc
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_92.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_92 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_93.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_93.cs
new file mode 100644
index 0000000000..08e10076e1
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_93.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_93 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_94.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_94.cs
new file mode 100644
index 0000000000..23d0d5b8bf
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_94.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_94 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_95.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_95.cs
new file mode 100644
index 0000000000..12b6f6a5f4
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_95.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_95 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_96.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_96.cs
new file mode 100644
index 0000000000..ecfb256b48
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_96.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_96 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_97.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_97.cs
new file mode 100644
index 0000000000..e4dd158da5
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_97.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_97 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_98.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_98.cs
new file mode 100644
index 0000000000..fd5e42683d
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_98.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_98 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_99.cs b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_99.cs
new file mode 100644
index 0000000000..7d41e4d78e
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Lifecycle/LifecycleTests_99.cs
@@ -0,0 +1,34 @@
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class LifecycleTests_99 : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_01.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_01.cs
new file mode 100644
index 0000000000..7ba7c4b4ff
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_01.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_01
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_02.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_02.cs
new file mode 100644
index 0000000000..909c47a423
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_02.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_02
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_03.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_03.cs
new file mode 100644
index 0000000000..0f967ee988
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_03.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_03
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_04.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_04.cs
new file mode 100644
index 0000000000..8d5b0ff457
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_04.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_04
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_05.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_05.cs
new file mode 100644
index 0000000000..096ff13b33
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_05.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_05
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_06.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_06.cs
new file mode 100644
index 0000000000..ae5b38d7e1
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_06.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_06
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_07.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_07.cs
new file mode 100644
index 0000000000..742b2c2d9e
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_07.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_07
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_08.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_08.cs
new file mode 100644
index 0000000000..f61e42c4f0
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_08.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_08
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_09.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_09.cs
new file mode 100644
index 0000000000..527af68869
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_09.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_09
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_10.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_10.cs
new file mode 100644
index 0000000000..d9cae4e69f
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_10.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_10
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_100.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_100.cs
new file mode 100644
index 0000000000..44c9d19993
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_100.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_100
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_11.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_11.cs
new file mode 100644
index 0000000000..e18141a991
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_11.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_11
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_12.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_12.cs
new file mode 100644
index 0000000000..05bca1ab43
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_12.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_12
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_13.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_13.cs
new file mode 100644
index 0000000000..7dc41d12be
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_13.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_13
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_14.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_14.cs
new file mode 100644
index 0000000000..2d7b1e8404
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_14.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_14
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_15.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_15.cs
new file mode 100644
index 0000000000..35468f9983
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_15.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_15
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_16.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_16.cs
new file mode 100644
index 0000000000..a8f7bf2548
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_16.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_16
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_17.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_17.cs
new file mode 100644
index 0000000000..f7c331e755
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_17.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_17
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_18.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_18.cs
new file mode 100644
index 0000000000..b71ad81135
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_18.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_18
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_19.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_19.cs
new file mode 100644
index 0000000000..b21fad8bc4
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_19.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_19
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_20.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_20.cs
new file mode 100644
index 0000000000..d34970d290
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_20.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_20
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_21.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_21.cs
new file mode 100644
index 0000000000..4fc20ea6b5
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_21.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_21
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_22.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_22.cs
new file mode 100644
index 0000000000..d0ee5818ee
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_22.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_22
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_23.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_23.cs
new file mode 100644
index 0000000000..837e371f9e
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_23.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_23
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_24.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_24.cs
new file mode 100644
index 0000000000..bf16049016
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_24.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_24
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_25.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_25.cs
new file mode 100644
index 0000000000..7543757fb4
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_25.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_25
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_26.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_26.cs
new file mode 100644
index 0000000000..9392c7a765
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_26.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_26
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_27.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_27.cs
new file mode 100644
index 0000000000..61bb2957f7
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_27.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_27
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_28.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_28.cs
new file mode 100644
index 0000000000..0783445ddc
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_28.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_28
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_29.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_29.cs
new file mode 100644
index 0000000000..d6f0b9832b
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_29.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_29
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_30.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_30.cs
new file mode 100644
index 0000000000..d6f2fa03ae
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_30.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_30
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_31.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_31.cs
new file mode 100644
index 0000000000..ca7c18d0c5
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_31.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_31
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_32.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_32.cs
new file mode 100644
index 0000000000..6026417cbc
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_32.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_32
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_33.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_33.cs
new file mode 100644
index 0000000000..7d583eec68
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_33.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_33
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_34.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_34.cs
new file mode 100644
index 0000000000..9019995eca
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_34.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_34
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_35.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_35.cs
new file mode 100644
index 0000000000..0be50dcc35
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_35.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_35
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_36.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_36.cs
new file mode 100644
index 0000000000..0a1df95ce0
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_36.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_36
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_37.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_37.cs
new file mode 100644
index 0000000000..65cd63d049
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_37.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_37
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_38.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_38.cs
new file mode 100644
index 0000000000..4ed6c7497f
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_38.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_38
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_39.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_39.cs
new file mode 100644
index 0000000000..94762d4dc2
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_39.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_39
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_40.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_40.cs
new file mode 100644
index 0000000000..a885350836
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_40.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_40
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_41.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_41.cs
new file mode 100644
index 0000000000..5393595c3c
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_41.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_41
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_42.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_42.cs
new file mode 100644
index 0000000000..260c329ead
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_42.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_42
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_43.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_43.cs
new file mode 100644
index 0000000000..31eb82077a
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_43.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_43
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_44.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_44.cs
new file mode 100644
index 0000000000..7caa1672ed
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_44.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_44
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_45.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_45.cs
new file mode 100644
index 0000000000..1dd7a5c3a4
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_45.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_45
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_46.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_46.cs
new file mode 100644
index 0000000000..56574731d3
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_46.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_46
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_47.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_47.cs
new file mode 100644
index 0000000000..1f20361d34
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_47.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_47
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_48.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_48.cs
new file mode 100644
index 0000000000..8b1b596517
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_48.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_48
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_49.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_49.cs
new file mode 100644
index 0000000000..516b1dff60
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_49.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_49
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_50.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_50.cs
new file mode 100644
index 0000000000..7e66b9fcb3
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_50.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_50
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_51.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_51.cs
new file mode 100644
index 0000000000..1076c4b83b
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_51.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_51
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_52.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_52.cs
new file mode 100644
index 0000000000..b3b0315b1f
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_52.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_52
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_53.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_53.cs
new file mode 100644
index 0000000000..5837f9d245
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_53.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_53
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_54.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_54.cs
new file mode 100644
index 0000000000..39b9a5b565
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_54.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_54
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_55.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_55.cs
new file mode 100644
index 0000000000..efa85cb188
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_55.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_55
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_56.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_56.cs
new file mode 100644
index 0000000000..c1348cd60e
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_56.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_56
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_57.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_57.cs
new file mode 100644
index 0000000000..2a9773b758
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_57.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_57
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_58.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_58.cs
new file mode 100644
index 0000000000..8828f25e20
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_58.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_58
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_59.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_59.cs
new file mode 100644
index 0000000000..90f44d36ba
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_59.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_59
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_60.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_60.cs
new file mode 100644
index 0000000000..af52487e18
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_60.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_60
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_61.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_61.cs
new file mode 100644
index 0000000000..54debbf0ea
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_61.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_61
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_62.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_62.cs
new file mode 100644
index 0000000000..949392646e
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_62.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_62
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_63.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_63.cs
new file mode 100644
index 0000000000..1bc9e010fc
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_63.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_63
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_64.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_64.cs
new file mode 100644
index 0000000000..9b08f87450
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_64.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_64
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_65.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_65.cs
new file mode 100644
index 0000000000..02c28296ef
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_65.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_65
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_66.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_66.cs
new file mode 100644
index 0000000000..8f02a30952
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_66.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_66
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_67.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_67.cs
new file mode 100644
index 0000000000..0f7e20090a
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_67.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_67
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_68.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_68.cs
new file mode 100644
index 0000000000..8d44b52919
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_68.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_68
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_69.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_69.cs
new file mode 100644
index 0000000000..d8a0eb71b1
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_69.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_69
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_70.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_70.cs
new file mode 100644
index 0000000000..f99092abb9
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_70.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_70
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_71.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_71.cs
new file mode 100644
index 0000000000..4b7cac5924
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_71.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_71
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_72.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_72.cs
new file mode 100644
index 0000000000..913783723d
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_72.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_72
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_73.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_73.cs
new file mode 100644
index 0000000000..445ed7704a
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_73.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_73
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_74.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_74.cs
new file mode 100644
index 0000000000..98a9984475
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_74.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_74
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_75.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_75.cs
new file mode 100644
index 0000000000..e05701c1bb
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_75.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_75
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_76.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_76.cs
new file mode 100644
index 0000000000..95c8ee317f
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_76.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_76
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_77.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_77.cs
new file mode 100644
index 0000000000..3ca01e8f2d
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_77.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_77
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_78.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_78.cs
new file mode 100644
index 0000000000..305fa27463
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_78.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_78
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_79.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_79.cs
new file mode 100644
index 0000000000..0bda1676b7
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_79.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_79
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_80.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_80.cs
new file mode 100644
index 0000000000..85f1b3c15c
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_80.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_80
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_81.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_81.cs
new file mode 100644
index 0000000000..7d65281c44
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_81.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_81
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_82.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_82.cs
new file mode 100644
index 0000000000..5e77b8c13e
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_82.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_82
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_83.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_83.cs
new file mode 100644
index 0000000000..1f25ada0b5
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_83.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_83
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_84.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_84.cs
new file mode 100644
index 0000000000..049c7ca1dd
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_84.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_84
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_85.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_85.cs
new file mode 100644
index 0000000000..2416dfab72
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_85.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_85
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_86.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_86.cs
new file mode 100644
index 0000000000..86aa276022
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_86.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_86
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_87.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_87.cs
new file mode 100644
index 0000000000..9489652116
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_87.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_87
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_88.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_88.cs
new file mode 100644
index 0000000000..d2be56970b
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_88.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_88
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_89.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_89.cs
new file mode 100644
index 0000000000..cb2d2444b0
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_89.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_89
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_90.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_90.cs
new file mode 100644
index 0000000000..a2363d73b0
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_90.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_90
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_91.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_91.cs
new file mode 100644
index 0000000000..a5d2d26967
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_91.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_91
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_92.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_92.cs
new file mode 100644
index 0000000000..b4376b171c
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_92.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_92
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_93.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_93.cs
new file mode 100644
index 0000000000..5071ec211d
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_93.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_93
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_94.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_94.cs
new file mode 100644
index 0000000000..6f31d8f3e1
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_94.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_94
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_95.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_95.cs
new file mode 100644
index 0000000000..66f3179a30
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_95.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_95
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_96.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_96.cs
new file mode 100644
index 0000000000..cd6f022984
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_96.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_96
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_97.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_97.cs
new file mode 100644
index 0000000000..b4b2c18393
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_97.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_97
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_98.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_98.cs
new file mode 100644
index 0000000000..3f1d718776
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_98.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_98
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_99.cs b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_99.cs
new file mode 100644
index 0000000000..a24873abcc
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/Tests/Simple/SimpleTests_99.cs
@@ -0,0 +1,34 @@
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class SimpleTests_99
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
diff --git a/TUnit.PerformanceBenchmarks/generate-tests.ps1 b/TUnit.PerformanceBenchmarks/generate-tests.ps1
new file mode 100644
index 0000000000..6d58a387ea
--- /dev/null
+++ b/TUnit.PerformanceBenchmarks/generate-tests.ps1
@@ -0,0 +1,140 @@
+# Generate test classes for TUnit.PerformanceBenchmarks
+# Usage: .\generate-tests.ps1 -Scale 1000
+
+param(
+ [int]$Scale = 1000
+)
+
+# Calculate test distribution (60% simple, 30% data-driven, 10% lifecycle)
+$simpleTests = [math]::Floor($Scale * 0.6)
+$dataDrivenTests = [math]::Floor($Scale * 0.3)
+$lifecycleTests = [math]::Floor($Scale * 0.1)
+
+Write-Host "Generating $Scale tests: $simpleTests simple, $dataDrivenTests data-driven, $lifecycleTests lifecycle"
+
+$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+
+# Clean existing generated files
+Get-ChildItem -Path "$scriptDir\Tests\Simple" -Filter "SimpleTests_*.cs" | Remove-Item -Force
+Get-ChildItem -Path "$scriptDir\Tests\DataDriven" -Filter "DataDrivenTests_*.cs" | Remove-Item -Force
+Get-ChildItem -Path "$scriptDir\Tests\Lifecycle" -Filter "LifecycleTests_*.cs" | Remove-Item -Force
+
+# Generate simple tests (10 tests per class, 6 methods with 10 arguments each = 60 tests per class)
+$simpleClassCount = [math]::Ceiling($simpleTests / 60)
+for ($i = 1; $i -le $simpleClassCount; $i++) {
+ $className = "SimpleTests_{0:D2}" -f $i
+ $content = @"
+namespace TUnit.PerformanceBenchmarks.Tests.Simple;
+
+public class $className
+{
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_01(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_02(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_03(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_04(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_05(int v) { }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ [Arguments(6), Arguments(7), Arguments(8), Arguments(9), Arguments(10)]
+ public void Test_06(int v) { }
+}
+"@
+ $content | Out-File -FilePath "$scriptDir\Tests\Simple\$className.cs" -Encoding utf8
+}
+
+# Generate data-driven tests (10 tests per class using MethodDataSource)
+$dataDrivenClassCount = [math]::Ceiling($dataDrivenTests / 30)
+for ($i = 1; $i -le $dataDrivenClassCount; $i++) {
+ $className = "DataDrivenTests_{0:D2}" -f $i
+ $content = @"
+namespace TUnit.PerformanceBenchmarks.Tests.DataDriven;
+
+public class $className
+{
+ public static IEnumerable<(int, string)> TestData()
+ {
+ for (int i = 0; i < 10; i++)
+ yield return (i, "Value" + i);
+ }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_01((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_02((int num, string str) data) { _ = data.num + data.str.Length; }
+
+ [Test]
+ [MethodDataSource(nameof(TestData))]
+ public void DataTest_03((int num, string str) data) { _ = data.num + data.str.Length; }
+}
+"@
+ $content | Out-File -FilePath "$scriptDir\Tests\DataDriven\$className.cs" -Encoding utf8
+}
+
+# Generate lifecycle tests (with hooks)
+$lifecycleClassCount = [math]::Ceiling($lifecycleTests / 10)
+for ($i = 1; $i -le $lifecycleClassCount; $i++) {
+ $className = "LifecycleTests_{0:D2}" -f $i
+ $content = @"
+using TUnit.Core.Interfaces;
+
+namespace TUnit.PerformanceBenchmarks.Tests.Lifecycle;
+
+public class $className : IAsyncInitializer, IAsyncDisposable
+{
+ private int _initialized;
+
+ public Task InitializeAsync()
+ {
+ _initialized = 1;
+ return Task.CompletedTask;
+ }
+
+ public ValueTask DisposeAsync()
+ {
+ _initialized = 0;
+ return ValueTask.CompletedTask;
+ }
+
+ [Before(Test)]
+ public void BeforeEach() { _ = _initialized; }
+
+ [After(Test)]
+ public void AfterEach() { _ = _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_01(int v) { _ = v + _initialized; }
+
+ [Test]
+ [Arguments(1), Arguments(2), Arguments(3), Arguments(4), Arguments(5)]
+ public void LifecycleTest_02(int v) { _ = v + _initialized; }
+}
+"@
+ $content | Out-File -FilePath "$scriptDir\Tests\Lifecycle\$className.cs" -Encoding utf8
+}
+
+Write-Host "Generated $simpleClassCount simple classes, $dataDrivenClassCount data-driven classes, $lifecycleClassCount lifecycle classes"
+Write-Host "Total approximate test count: $($simpleClassCount * 60 + $dataDrivenClassCount * 30 + $lifecycleClassCount * 10)"
diff --git a/docs/plans/2025-12-25-nunit-expectedresult-implementation.md b/docs/plans/2025-12-25-nunit-expectedresult-implementation.md
new file mode 100644
index 0000000000..c27e59817e
--- /dev/null
+++ b/docs/plans/2025-12-25-nunit-expectedresult-implementation.md
@@ -0,0 +1,800 @@
+# NUnit ExpectedResult Migration Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** Add code fixer support for migrating NUnit's `ExpectedResult` pattern to TUnit's assertion-based approach.
+
+**Architecture:** Extend the existing `NUnitMigrationCodeFixProvider` with a new `NUnitExpectedResultRewriter` that transforms `[TestCase(..., ExpectedResult = X)]` into `[Arguments(..., X)]` with an assertion in the method body. The rewriter runs in the `ApplyFrameworkSpecificConversions` hook before attribute conversion.
+
+**Tech Stack:** Roslyn CodeAnalysis, C# Syntax Rewriters, existing TUnit.Analyzers infrastructure.
+
+---
+
+## Task 1: Add Failing Test for Simple ExpectedResult
+
+**Files:**
+- Modify: `TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs`
+
+**Step 1: Write the failing test**
+
+Add this test method at the end of the test class (before the `ConfigureNUnitTest` methods):
+
+```csharp
+[Test]
+public async Task NUnit_ExpectedResult_Converted()
+{
+ await CodeFixer.VerifyCodeFixAsync(
+ """
+ using NUnit.Framework;
+
+ {|#0:public class MyClass|}
+ {
+ [TestCase(2, 3, ExpectedResult = 5)]
+ public int Add(int a, int b) => a + b;
+ }
+ """,
+ 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]
+ [Arguments(2, 3, 5)]
+ public async Task Add(int a, int b, int expected)
+ {
+ await Assert.That(a + b).IsEqualTo(expected);
+ }
+ }
+ """,
+ ConfigureNUnitTest
+ );
+}
+```
+
+**Step 2: Run test to verify it fails**
+
+Run: `dotnet test TUnit.Analyzers.Tests --filter "NUnit_ExpectedResult_Converted"`
+
+Expected: FAIL (code fixer doesn't handle ExpectedResult yet)
+
+**Step 3: Commit**
+
+```bash
+git add TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs
+git commit -m "test: add failing test for NUnit ExpectedResult migration"
+```
+
+---
+
+## Task 2: Create NUnitExpectedResultRewriter Class
+
+**Files:**
+- Create: `TUnit.Analyzers.CodeFixers/NUnitExpectedResultRewriter.cs`
+
+**Step 1: Create the rewriter skeleton**
+
+```csharp
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace TUnit.Analyzers.CodeFixers;
+
+///
+/// Transforms NUnit [TestCase(..., ExpectedResult = X)] patterns to TUnit assertions.
+///
+public class NUnitExpectedResultRewriter : CSharpSyntaxRewriter
+{
+ private readonly SemanticModel _semanticModel;
+
+ public NUnitExpectedResultRewriter(SemanticModel semanticModel)
+ {
+ _semanticModel = semanticModel;
+ }
+
+ public override SyntaxNode? VisitMethodDeclaration(MethodDeclarationSyntax node)
+ {
+ // Check if method has any TestCase attributes with ExpectedResult
+ var testCaseAttributes = GetTestCaseAttributesWithExpectedResult(node);
+
+ if (testCaseAttributes.Count == 0)
+ {
+ return base.VisitMethodDeclaration(node);
+ }
+
+ // Get the return type (will become the expected parameter type)
+ var returnType = node.ReturnType;
+ if (returnType is PredefinedTypeSyntax predefined && predefined.Keyword.IsKind(SyntaxKind.VoidKeyword))
+ {
+ // void methods can't have ExpectedResult
+ return base.VisitMethodDeclaration(node);
+ }
+
+ // Transform the method
+ return TransformMethod(node, testCaseAttributes, returnType);
+ }
+
+ private List GetTestCaseAttributesWithExpectedResult(MethodDeclarationSyntax method)
+ {
+ var result = new List();
+
+ foreach (var attributeList in method.AttributeLists)
+ {
+ foreach (var attribute in attributeList.Attributes)
+ {
+ var name = attribute.Name.ToString();
+ if (name is "TestCase" or "NUnit.Framework.TestCase" or "TestCaseAttribute" or "NUnit.Framework.TestCaseAttribute")
+ {
+ if (HasExpectedResultArgument(attribute))
+ {
+ result.Add(attribute);
+ }
+ }
+ }
+ }
+
+ return result;
+ }
+
+ private bool HasExpectedResultArgument(AttributeSyntax attribute)
+ {
+ if (attribute.ArgumentList == null)
+ {
+ return false;
+ }
+
+ return attribute.ArgumentList.Arguments
+ .Any(arg => arg.NameEquals?.Name.Identifier.Text == "ExpectedResult");
+ }
+
+ private MethodDeclarationSyntax TransformMethod(
+ MethodDeclarationSyntax method,
+ List testCaseAttributes,
+ TypeSyntax originalReturnType)
+ {
+ // 1. Add 'expected' parameter
+ var expectedParam = SyntaxFactory.Parameter(SyntaxFactory.Identifier("expected"))
+ .WithType(originalReturnType.WithTrailingTrivia(SyntaxFactory.Space));
+
+ var newParameters = method.ParameterList.AddParameters(expectedParam);
+
+ // 2. Change return type to async Task
+ var asyncTaskType = SyntaxFactory.ParseTypeName("async Task ")
+ .WithTrailingTrivia(SyntaxFactory.Space);
+
+ // 3. Transform the body
+ var newBody = TransformBody(method, originalReturnType);
+
+ // 4. Build the new method
+ var newMethod = method
+ .WithReturnType(SyntaxFactory.ParseTypeName("Task").WithTrailingTrivia(SyntaxFactory.Space))
+ .WithParameterList(newParameters)
+ .WithBody(newBody)
+ .WithExpressionBody(null)
+ .WithSemicolonToken(default);
+
+ // 5. Add async modifier if not present
+ if (!method.Modifiers.Any(SyntaxKind.AsyncKeyword))
+ {
+ var asyncModifier = SyntaxFactory.Token(SyntaxKind.AsyncKeyword).WithTrailingTrivia(SyntaxFactory.Space);
+ newMethod = newMethod.AddModifiers(asyncModifier);
+ }
+
+ // 6. Update attribute lists (remove ExpectedResult from TestCase, add [Test])
+ var newAttributeLists = TransformAttributeLists(method.AttributeLists, testCaseAttributes);
+ newMethod = newMethod.WithAttributeLists(newAttributeLists);
+
+ return newMethod;
+ }
+
+ private BlockSyntax TransformBody(MethodDeclarationSyntax method, TypeSyntax returnType)
+ {
+ ExpressionSyntax returnExpression;
+
+ if (method.ExpressionBody != null)
+ {
+ // Expression-bodied: => a + b
+ returnExpression = method.ExpressionBody.Expression;
+ }
+ else if (method.Body != null)
+ {
+ // Block body - find return statements
+ var returnStatements = method.Body.Statements
+ .OfType()
+ .ToList();
+
+ if (returnStatements.Count == 1 && returnStatements[0].Expression != null)
+ {
+ // Single return - use the expression directly
+ returnExpression = returnStatements[0].Expression;
+
+ // Build new body with all statements except the return, plus assertion
+ var statementsWithoutReturn = method.Body.Statements
+ .Where(s => s != returnStatements[0])
+ .ToList();
+
+ var assertStatement = CreateAssertStatement(returnExpression);
+ statementsWithoutReturn.Add(assertStatement);
+
+ return SyntaxFactory.Block(statementsWithoutReturn);
+ }
+ else if (returnStatements.Count > 1)
+ {
+ // Multiple returns - use local variable pattern
+ return TransformMultipleReturns(method.Body, returnType);
+ }
+ else
+ {
+ // No return found - shouldn't happen for ExpectedResult
+ return method.Body;
+ }
+ }
+ else
+ {
+ // No body - shouldn't happen
+ return SyntaxFactory.Block();
+ }
+
+ // For expression-bodied, create block with assertion
+ var assertion = CreateAssertStatement(returnExpression);
+ return SyntaxFactory.Block(assertion);
+ }
+
+ private BlockSyntax TransformMultipleReturns(BlockSyntax body, TypeSyntax returnType)
+ {
+ // Declare: {returnType} result;
+ var resultDeclaration = SyntaxFactory.LocalDeclarationStatement(
+ SyntaxFactory.VariableDeclaration(returnType.WithTrailingTrivia(SyntaxFactory.Space))
+ .WithVariables(SyntaxFactory.SingletonSeparatedList(
+ SyntaxFactory.VariableDeclarator("result"))));
+
+ // Replace each 'return X;' with 'result = X;'
+ var rewriter = new ReturnToAssignmentRewriter();
+ var transformedBody = (BlockSyntax)rewriter.Visit(body);
+
+ // Add result declaration at start
+ var statements = new List { resultDeclaration };
+ statements.AddRange(transformedBody.Statements);
+
+ // Add assertion at end
+ var assertStatement = CreateAssertStatement(
+ SyntaxFactory.IdentifierName("result"));
+ statements.Add(assertStatement);
+
+ return SyntaxFactory.Block(statements);
+ }
+
+ private ExpressionStatementSyntax CreateAssertStatement(ExpressionSyntax actualExpression)
+ {
+ // await Assert.That(actualExpression).IsEqualTo(expected);
+ var assertThat = SyntaxFactory.InvocationExpression(
+ SyntaxFactory.MemberAccessExpression(
+ SyntaxKind.SimpleMemberAccessExpression,
+ SyntaxFactory.IdentifierName("Assert"),
+ SyntaxFactory.IdentifierName("That")),
+ SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(
+ SyntaxFactory.Argument(actualExpression))));
+
+ var isEqualTo = SyntaxFactory.InvocationExpression(
+ SyntaxFactory.MemberAccessExpression(
+ SyntaxKind.SimpleMemberAccessExpression,
+ assertThat,
+ SyntaxFactory.IdentifierName("IsEqualTo")),
+ SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(
+ SyntaxFactory.Argument(SyntaxFactory.IdentifierName("expected")))));
+
+ var awaitExpr = SyntaxFactory.AwaitExpression(isEqualTo);
+
+ return SyntaxFactory.ExpressionStatement(awaitExpr);
+ }
+
+ private SyntaxList TransformAttributeLists(
+ SyntaxList attributeLists,
+ List testCaseAttributes)
+ {
+ var result = new List();
+ bool hasTestAttribute = false;
+
+ foreach (var attrList in attributeLists)
+ {
+ var newAttributes = new List();
+
+ foreach (var attr in attrList.Attributes)
+ {
+ var name = attr.Name.ToString();
+
+ if (name is "Test" or "NUnit.Framework.Test")
+ {
+ hasTestAttribute = true;
+ newAttributes.Add(attr);
+ }
+ else if (testCaseAttributes.Contains(attr))
+ {
+ // Transform TestCase with ExpectedResult to Arguments
+ var transformed = TransformTestCaseAttribute(attr);
+ newAttributes.Add(transformed);
+ }
+ else
+ {
+ newAttributes.Add(attr);
+ }
+ }
+
+ if (newAttributes.Count > 0)
+ {
+ result.Add(attrList.WithAttributes(SyntaxFactory.SeparatedList(newAttributes)));
+ }
+ }
+
+ // Add [Test] attribute if not present
+ if (!hasTestAttribute)
+ {
+ var testAttr = SyntaxFactory.Attribute(SyntaxFactory.IdentifierName("Test"));
+ var testAttrList = SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList(testAttr))
+ .WithLeadingTrivia(attributeLists.First().GetLeadingTrivia());
+ result.Insert(0, testAttrList);
+ }
+
+ return SyntaxFactory.List(result);
+ }
+
+ private AttributeSyntax TransformTestCaseAttribute(AttributeSyntax attribute)
+ {
+ if (attribute.ArgumentList == null)
+ {
+ return attribute;
+ }
+
+ var newArgs = new List();
+ ExpressionSyntax? expectedValue = null;
+
+ foreach (var arg in attribute.ArgumentList.Arguments)
+ {
+ if (arg.NameEquals?.Name.Identifier.Text == "ExpectedResult")
+ {
+ expectedValue = arg.Expression;
+ }
+ else if (arg.NameColon == null && arg.NameEquals == null)
+ {
+ // Positional argument - keep it
+ newArgs.Add(arg);
+ }
+ // Skip other named arguments for now
+ }
+
+ // Add expected value as last positional argument
+ if (expectedValue != null)
+ {
+ newArgs.Add(SyntaxFactory.AttributeArgument(expectedValue));
+ }
+
+ // The attribute will be renamed to "Arguments" by the existing attribute rewriter
+ return attribute.WithArgumentList(
+ SyntaxFactory.AttributeArgumentList(SyntaxFactory.SeparatedList(newArgs)));
+ }
+
+ private class ReturnToAssignmentRewriter : CSharpSyntaxRewriter
+ {
+ public override SyntaxNode? VisitReturnStatement(ReturnStatementSyntax node)
+ {
+ if (node.Expression == null)
+ {
+ return node;
+ }
+
+ // return X; -> result = X;
+ return SyntaxFactory.ExpressionStatement(
+ SyntaxFactory.AssignmentExpression(
+ SyntaxKind.SimpleAssignmentExpression,
+ SyntaxFactory.IdentifierName("result"),
+ node.Expression));
+ }
+ }
+}
+```
+
+**Step 2: Build to verify no syntax errors**
+
+Run: `dotnet build TUnit.Analyzers.CodeFixers`
+
+Expected: Build succeeded
+
+**Step 3: Commit**
+
+```bash
+git add TUnit.Analyzers.CodeFixers/NUnitExpectedResultRewriter.cs
+git commit -m "feat: add NUnitExpectedResultRewriter skeleton"
+```
+
+---
+
+## Task 3: Integrate Rewriter into Code Fix Provider
+
+**Files:**
+- Modify: `TUnit.Analyzers.CodeFixers/NUnitMigrationCodeFixProvider.cs`
+
+**Step 1: Update ApplyFrameworkSpecificConversions**
+
+Replace the `ApplyFrameworkSpecificConversions` method:
+
+```csharp
+protected override CompilationUnitSyntax ApplyFrameworkSpecificConversions(CompilationUnitSyntax compilationUnit, SemanticModel semanticModel, Compilation compilation)
+{
+ // Transform ExpectedResult patterns before attribute conversion
+ var expectedResultRewriter = new NUnitExpectedResultRewriter(semanticModel);
+ compilationUnit = (CompilationUnitSyntax)expectedResultRewriter.Visit(compilationUnit);
+
+ return compilationUnit;
+}
+```
+
+**Step 2: Run the test**
+
+Run: `dotnet test TUnit.Analyzers.Tests --filter "NUnit_ExpectedResult_Converted"`
+
+Expected: May pass or fail depending on edge cases - we'll iterate
+
+**Step 3: Commit**
+
+```bash
+git add TUnit.Analyzers.CodeFixers/NUnitMigrationCodeFixProvider.cs
+git commit -m "feat: integrate ExpectedResult rewriter into NUnit migration"
+```
+
+---
+
+## Task 4: Fix Formatting Issues
+
+**Files:**
+- Modify: `TUnit.Analyzers.CodeFixers/NUnitExpectedResultRewriter.cs`
+
+**Step 1: Run test and check output**
+
+Run: `dotnet test TUnit.Analyzers.Tests --filter "NUnit_ExpectedResult_Converted" -v n`
+
+Examine the actual output vs expected - likely issues with:
+- Trivia (whitespace, newlines)
+- Attribute ordering
+- Method modifier ordering
+
+**Step 2: Fix identified issues**
+
+Common fixes needed:
+- Add proper leading/trailing trivia to statements
+- Ensure async modifier is in correct position
+- Fix attribute list formatting
+
+**Step 3: Run test again**
+
+Run: `dotnet test TUnit.Analyzers.Tests --filter "NUnit_ExpectedResult_Converted"`
+
+Expected: PASS
+
+**Step 4: Commit**
+
+```bash
+git add TUnit.Analyzers.CodeFixers/NUnitExpectedResultRewriter.cs
+git commit -m "fix: correct formatting in ExpectedResult transformation"
+```
+
+---
+
+## Task 5: Add Test for Multiple TestCase Attributes
+
+**Files:**
+- Modify: `TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs`
+
+**Step 1: Write the test**
+
+```csharp
+[Test]
+public async Task NUnit_Multiple_ExpectedResult_Converted()
+{
+ await CodeFixer.VerifyCodeFixAsync(
+ """
+ using NUnit.Framework;
+
+ {|#0:public class MyClass|}
+ {
+ [TestCase(2, 3, ExpectedResult = 5)]
+ [TestCase(10, 5, ExpectedResult = 15)]
+ [TestCase(0, 0, ExpectedResult = 0)]
+ public int Add(int a, int b) => a + b;
+ }
+ """,
+ 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]
+ [Arguments(2, 3, 5)]
+ [Arguments(10, 5, 15)]
+ [Arguments(0, 0, 0)]
+ public async Task Add(int a, int b, int expected)
+ {
+ await Assert.That(a + b).IsEqualTo(expected);
+ }
+ }
+ """,
+ ConfigureNUnitTest
+ );
+}
+```
+
+**Step 2: Run test**
+
+Run: `dotnet test TUnit.Analyzers.Tests --filter "NUnit_Multiple_ExpectedResult_Converted"`
+
+Expected: PASS
+
+**Step 3: Commit**
+
+```bash
+git add TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs
+git commit -m "test: add test for multiple TestCase with ExpectedResult"
+```
+
+---
+
+## Task 6: Add Test for Block-Bodied Method with Single Return
+
+**Files:**
+- Modify: `TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs`
+
+**Step 1: Write the test**
+
+```csharp
+[Test]
+public async Task NUnit_ExpectedResult_BlockBody_SingleReturn_Converted()
+{
+ await CodeFixer.VerifyCodeFixAsync(
+ """
+ using NUnit.Framework;
+
+ {|#0:public class MyClass|}
+ {
+ [TestCase(2, 3, ExpectedResult = 5)]
+ public int Add(int a, int b)
+ {
+ var sum = a + b;
+ return sum;
+ }
+ }
+ """,
+ 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]
+ [Arguments(2, 3, 5)]
+ public async Task Add(int a, int b, int expected)
+ {
+ var sum = a + b;
+ await Assert.That(sum).IsEqualTo(expected);
+ }
+ }
+ """,
+ ConfigureNUnitTest
+ );
+}
+```
+
+**Step 2: Run test**
+
+Run: `dotnet test TUnit.Analyzers.Tests --filter "NUnit_ExpectedResult_BlockBody_SingleReturn_Converted"`
+
+Expected: PASS (or fix if needed)
+
+**Step 3: Commit**
+
+```bash
+git add TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs
+git commit -m "test: add test for block-bodied ExpectedResult with single return"
+```
+
+---
+
+## Task 7: Add Test for Multiple Return Statements
+
+**Files:**
+- Modify: `TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs`
+
+**Step 1: Write the test**
+
+```csharp
+[Test]
+public async Task NUnit_ExpectedResult_MultipleReturns_Converted()
+{
+ await CodeFixer.VerifyCodeFixAsync(
+ """
+ using NUnit.Framework;
+
+ {|#0:public class MyClass|}
+ {
+ [TestCase(-1, ExpectedResult = 0)]
+ [TestCase(0, ExpectedResult = 1)]
+ [TestCase(5, ExpectedResult = 120)]
+ public int Factorial(int n)
+ {
+ if (n < 0) return 0;
+ if (n <= 1) return 1;
+ return n * Factorial(n - 1);
+ }
+ }
+ """,
+ 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]
+ [Arguments(-1, 0)]
+ [Arguments(0, 1)]
+ [Arguments(5, 120)]
+ public async Task Factorial(int n, int expected)
+ {
+ int result;
+ if (n < 0) result = 0;
+ else if (n <= 1) result = 1;
+ else result = n * Factorial(n - 1);
+ await Assert.That(result).IsEqualTo(expected);
+ }
+ }
+ """,
+ ConfigureNUnitTest
+ );
+}
+```
+
+**Step 2: Run test**
+
+Run: `dotnet test TUnit.Analyzers.Tests --filter "NUnit_ExpectedResult_MultipleReturns_Converted"`
+
+Expected: May fail initially - multiple returns require more complex transformation
+
+**Step 3: Fix if needed and commit**
+
+```bash
+git add TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs
+git commit -m "test: add test for ExpectedResult with multiple returns"
+```
+
+---
+
+## Task 8: Add Test for String ExpectedResult
+
+**Files:**
+- Modify: `TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs`
+
+**Step 1: Write the test**
+
+```csharp
+[Test]
+public async Task NUnit_ExpectedResult_String_Converted()
+{
+ await CodeFixer.VerifyCodeFixAsync(
+ """
+ using NUnit.Framework;
+
+ {|#0:public class MyClass|}
+ {
+ [TestCase("hello", ExpectedResult = "HELLO")]
+ [TestCase("World", ExpectedResult = "WORLD")]
+ public string ToUpper(string input) => input.ToUpper();
+ }
+ """,
+ 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]
+ [Arguments("hello", "HELLO")]
+ [Arguments("World", "WORLD")]
+ public async Task ToUpper(string input, string expected)
+ {
+ await Assert.That(input.ToUpper()).IsEqualTo(expected);
+ }
+ }
+ """,
+ ConfigureNUnitTest
+ );
+}
+```
+
+**Step 2: Run test**
+
+Run: `dotnet test TUnit.Analyzers.Tests --filter "NUnit_ExpectedResult_String_Converted"`
+
+Expected: PASS
+
+**Step 3: Commit**
+
+```bash
+git add TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs
+git commit -m "test: add test for string ExpectedResult migration"
+```
+
+---
+
+## Task 9: Run Full Test Suite
+
+**Files:** None (verification only)
+
+**Step 1: Run all NUnit migration tests**
+
+Run: `dotnet test TUnit.Analyzers.Tests --filter "NUnitMigration"`
+
+Expected: All tests PASS
+
+**Step 2: Run full analyzer test suite**
+
+Run: `dotnet test TUnit.Analyzers.Tests`
+
+Expected: All tests PASS
+
+**Step 3: Commit any remaining fixes**
+
+```bash
+git add -A
+git commit -m "fix: address any remaining test failures"
+```
+
+---
+
+## Task 10: Update Design Document Status
+
+**Files:**
+- Modify: `docs/plans/2025-12-25-nunit-expectedresult-migration-design.md`
+
+**Step 1: Update status**
+
+Change the Status line from:
+```
+**Status**: Design Complete
+```
+
+To:
+```
+**Status**: Implemented
+```
+
+**Step 2: Commit**
+
+```bash
+git add docs/plans/2025-12-25-nunit-expectedresult-migration-design.md
+git commit -m "docs: mark ExpectedResult migration as implemented"
+```
+
+---
+
+## Verification Checklist
+
+After all tasks complete:
+
+- [ ] `dotnet test TUnit.Analyzers.Tests` passes
+- [ ] `dotnet build TUnit.Analyzers.CodeFixers` succeeds
+- [ ] New tests cover: simple ExpectedResult, multiple TestCase, block body, multiple returns, string types
+- [ ] Code follows existing patterns in NUnitMigrationCodeFixProvider
diff --git a/docs/plans/2025-12-25-nunit-expectedresult-migration-design.md b/docs/plans/2025-12-25-nunit-expectedresult-migration-design.md
new file mode 100644
index 0000000000..6fc8da8aeb
--- /dev/null
+++ b/docs/plans/2025-12-25-nunit-expectedresult-migration-design.md
@@ -0,0 +1,215 @@
+# NUnit ExpectedResult Migration Code Fixer
+
+**Issue**: #4167
+**Date**: 2025-12-25
+**Status**: Implemented
+
+## Overview
+
+A Roslyn analyzer + code fixer that extends TUnit's existing NUnit migration infrastructure to handle `ExpectedResult` patterns. Converts NUnit's return-value-based test assertions to TUnit's explicit assertion approach.
+
+## Scope
+
+### Patterns Handled
+
+1. `[TestCase(..., ExpectedResult = X)]` - Inline expected result property
+2. `TestCaseData.Returns(X)` - Fluent expected result in data sources
+
+### Patterns Flagged for Manual Review
+
+- Mixed attributes (some with ExpectedResult, some without)
+- `TestCaseData` with `.SetName()`, `.SetCategory()`, or other chained methods
+- Dynamic/computed `TestCaseData` (loops, conditionals)
+- `TestCaseData` constructed outside simple array/collection initializers
+
+## Transformation Examples
+
+### TestCase with ExpectedResult
+
+```csharp
+// BEFORE (NUnit)
+[TestCase(2, 3, ExpectedResult = 5)]
+[TestCase(10, 5, ExpectedResult = 15)]
+public int Add(int a, int b) => a + b;
+
+// AFTER (TUnit)
+[Test]
+[Arguments(2, 3, 5)]
+[Arguments(10, 5, 15)]
+public async Task Add(int a, int b, int expected)
+{
+ await Assert.That(a + b).IsEqualTo(expected);
+}
+```
+
+### TestCaseData.Returns()
+
+```csharp
+// BEFORE (NUnit)
+public static IEnumerable AddCases => new[]
+{
+ new TestCaseData(2, 3).Returns(5),
+ new TestCaseData(10, 5).Returns(15)
+};
+
+[TestCaseSource(nameof(AddCases))]
+public int Add(int a, int b) => a + b;
+
+// AFTER (TUnit)
+public static IEnumerable<(int, int, int)> AddCases => new[]
+{
+ (2, 3, 5),
+ (10, 5, 15)
+};
+
+[Test]
+[MethodDataSource(nameof(AddCases))]
+public async Task Add(int a, int b, int expected)
+{
+ await Assert.That(a + b).IsEqualTo(expected);
+}
+```
+
+## Design Decisions
+
+| Decision | Choice | Rationale |
+|----------|--------|-----------|
+| Multiple ExpectedResults | Add as method parameter | Preserves parameterized structure, single method |
+| Expression-bodied members | Convert to block body | Semantic change warrants explicit block |
+| Multiple return statements | Extract to local variable | Cleaner code, single assertion point |
+| Null expected values | Use `IsEqualTo(expected)` | Parameter value unknown at compile-time |
+| Parameter naming | `expected` | Concise, idiomatic in testing |
+
+## Method Body Transformation
+
+### Case A: Expression-Bodied
+
+```csharp
+// BEFORE
+public int Add(int a, int b) => a + b;
+
+// AFTER
+public async Task Add(int a, int b, int expected)
+{
+ await Assert.That(a + b).IsEqualTo(expected);
+}
+```
+
+### Case B: Single Return
+
+```csharp
+// BEFORE
+public int Add(int a, int b)
+{
+ var sum = a + b;
+ return sum;
+}
+
+// AFTER
+public async Task Add(int a, int b, int expected)
+{
+ var sum = a + b;
+ await Assert.That(sum).IsEqualTo(expected);
+}
+```
+
+### Case C: Multiple Returns
+
+```csharp
+// BEFORE
+public int Factorial(int n)
+{
+ if (n < 0) return 0;
+ if (n <= 1) return 1;
+ return n * Factorial(n - 1);
+}
+
+// AFTER
+public async Task Factorial(int n, int expected)
+{
+ int result;
+ if (n < 0) result = 0;
+ else if (n <= 1) result = 1;
+ else result = n * Factorial(n - 1);
+ await Assert.That(result).IsEqualTo(expected);
+}
+```
+
+**Algorithm for multiple returns**:
+1. Declare `{returnType} result;` at method start
+2. Replace each `return X;` with `result = X;`
+3. Convert `if (...) return` chains to `if/else if/else`
+4. Append `await Assert.That(result).IsEqualTo(expected);` at end
+
+## Implementation
+
+### Analyzer
+
+Extend `NUnitMigrationAnalyzer` to detect:
+- `ExpectedResult` named argument in `[TestCase]` attributes
+- `.Returns()` method calls on `TestCaseData`
+
+**Diagnostic**: `TUnit0050` (Info severity)
+**Message**: "NUnit ExpectedResult can be converted to TUnit assertion"
+
+### Code Fixer
+
+#### New Files
+
+```
+TUnit.Analyzers.CodeFixers/
+├── NUnitExpectedResultRewriter.cs # TestCase ExpectedResult transform
+└── NUnitTestCaseDataRewriter.cs # TestCaseData.Returns() transform
+```
+
+#### Integration
+
+Add to `NUnitMigrationCodeFixProvider.cs` transformation pipeline:
+
+```csharp
+// Before attribute conversion:
+root = new NUnitExpectedResultRewriter(semanticModel).Visit(root);
+root = new NUnitTestCaseDataRewriter(semanticModel).Visit(root);
+```
+
+### TestCase Transformation Steps
+
+1. Extract `ExpectedResult` values from each `[TestCase]`
+2. Convert `[TestCase(args, ExpectedResult = X)]` → `[Arguments(args, X)]`
+3. Add `expected` parameter with original return type
+4. Change return type to `async Task`
+5. Transform method body per cases above
+6. Add `[Test]` attribute if not present
+
+### TestCaseData Transformation Steps
+
+1. Locate data source method/property
+2. For each `TestCaseData`: extract args + `.Returns()` value → tuple
+3. Update return type: `IEnumerable` → `IEnumerable<(T1, T2, ..., TExpected)>`
+4. Transform test method same as TestCase
+
+## Testing
+
+Add to `TUnit.Analyzers.Tests/NUnitMigrationAnalyzerTests.cs`:
+
+- Simple ExpectedResult (single TestCase)
+- Multiple TestCase attributes with different expected values
+- Expression-bodied methods
+- Block-bodied with single return
+- Block-bodied with multiple returns
+- Null expected values
+- Reference type expected values
+- TestCaseData.Returns() simple case
+- TestCaseData.Returns() with multiple entries
+- Mixed scenarios (flagged for manual review)
+
+## Edge Cases
+
+| Scenario | Handling |
+|----------|----------|
+| Null ExpectedResult | `IsEqualTo(expected)` handles null at runtime |
+| Constant references (`int.MaxValue`) | Passed through as parameter value |
+| Generic return types | Parameter type matches original return type |
+| Nullable return types | Parameter type includes nullability |
+| Recursive methods | Works - method signature change is compatible |
+| Mixed TestCase (with/without ExpectedResult) | Flag for manual review |