From 410b69b3e13faadfe2107ea8481a05f0bab105f9 Mon Sep 17 00:00:00 2001 From: Zion Sati <283163728+zion-sati@users.noreply.github.com> Date: Tue, 29 Sep 2026 23:15:00 +1000 Subject: [PATCH] Fix generated invokers for ValueTask tests --- .../Generators/TestMetadataGenerator.cs | 17 +- ...skResultTests.Test.DotNet10_0.verified.txt | 150 ++++++++++++++++++ ...askResultTests.Test.DotNet8_0.verified.txt | 150 ++++++++++++++++++ ...askResultTests.Test.DotNet9_0.verified.txt | 150 ++++++++++++++++++ ...ueTaskResultTests.Test.Net4_7.verified.txt | 150 ++++++++++++++++++ .../ValueTaskResultTests.cs | 23 +++ .../TUnit.TestProject/ValueTaskResultTests.cs | 11 ++ 7 files changed, 649 insertions(+), 2 deletions(-) create mode 100644 tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.Test.DotNet10_0.verified.txt create mode 100644 tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.Test.DotNet8_0.verified.txt create mode 100644 tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.Test.DotNet9_0.verified.txt create mode 100644 tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.Test.Net4_7.verified.txt create mode 100644 tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.cs create mode 100644 tests/TUnit.TestProject/ValueTaskResultTests.cs diff --git a/src/TUnit.Core.SourceGenerator/Generators/TestMetadataGenerator.cs b/src/TUnit.Core.SourceGenerator/Generators/TestMetadataGenerator.cs index 23306d2c17..a80604cb16 100644 --- a/src/TUnit.Core.SourceGenerator/Generators/TestMetadataGenerator.cs +++ b/src/TUnit.Core.SourceGenerator/Generators/TestMetadataGenerator.cs @@ -1100,6 +1100,9 @@ private static void EmitConcreteInvokeBody(CodeWriter writer, TestMethodMetadata case TestReturnPattern.ValueTask: writer.AppendLine($"return {methodCall};"); break; + case TestReturnPattern.ValueTaskOfT: + writer.AppendLine($"return new global::System.Threading.Tasks.ValueTask({methodCall}.AsTask());"); + break; case TestReturnPattern.Task: writer.AppendLine($"return new global::System.Threading.Tasks.ValueTask({methodCall});"); break; @@ -3847,7 +3850,8 @@ private static void WriteTestEntryFactoryCall(CodeWriter writer, ClassTestGroup private enum TestReturnPattern { Void, // void methods - ValueTask, // ValueTask or ValueTask + ValueTask, // ValueTask + ValueTaskOfT, // ValueTask Task, // Task or Task Unknown // F# Async, custom awaitables, etc. } @@ -3861,11 +3865,16 @@ private static TestReturnPattern GetReturnPattern(IMethodSymbol method) var returnTypeName = method.ReturnType.ToDisplayString(); - if (returnTypeName.StartsWith("System.Threading.Tasks.ValueTask")) + if (returnTypeName == "System.Threading.Tasks.ValueTask") { return TestReturnPattern.ValueTask; } + if (returnTypeName.StartsWith("System.Threading.Tasks.ValueTask<")) + { + return TestReturnPattern.ValueTaskOfT; + } + if (returnTypeName.StartsWith("System.Threading.Tasks.Task") || returnTypeName.StartsWith("Task<")) { @@ -3891,6 +3900,10 @@ private static void GenerateReturnHandling( writer.AppendLine($"return {methodCall};"); break; + case TestReturnPattern.ValueTaskOfT: + writer.AppendLine($"return new global::System.Threading.Tasks.ValueTask({methodCall}.AsTask());"); + break; + case TestReturnPattern.Task: writer.AppendLine($"return new global::System.Threading.Tasks.ValueTask({methodCall});"); break; diff --git a/tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.Test.DotNet10_0.verified.txt b/tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.Test.DotNet10_0.verified.txt new file mode 100644 index 0000000000..7097e7e85a --- /dev/null +++ b/tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.Test.DotNet10_0.verified.txt @@ -0,0 +1,150 @@ +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_ValueTaskResultTests_GenericMethodValueTaskResult_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.ValueTaskResultTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.ValueTaskResultTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.ValueTaskResultTests)), + Name = "ValueTaskResultTests", + Namespace = "TUnit.TestProject", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.ValueTaskResultTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("GenericMethodValueTaskResult", __classType, typeof(global::System.Threading.Tasks.ValueTask), __classMetadata, genericTypeCount: 1); + private static global::TUnit.TestProject.ValueTaskResultTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.ValueTaskResultTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.ValueTaskResultTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + return new global::System.Threading.Tasks.ValueTask(instance.GenericMethodValueTaskResult().AsTask()); + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(int)) + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "GenericMethodValueTaskResult", + fullyQualifiedName: "TUnit.TestProject.ValueTaskResultTests.GenericMethodValueTaskResult", + filePath: "", + lineNumber: 8, + methodMetadata: __mm_0, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_ValueTaskResultTests_GenericMethodValueTaskResult_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_ValueTaskResultTests_GenericMethodValueTaskResult_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_ValueTaskResultTests__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.ValueTaskResultTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.ValueTaskResultTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.ValueTaskResultTests)), + Name = "ValueTaskResultTests", + Namespace = "TUnit.TestProject", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.ValueTaskResultTests); + private static global::TUnit.TestProject.ValueTaskResultTests __CreateInstance(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.ValueTaskResultTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke(global::TUnit.TestProject.ValueTaskResultTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + switch (methodIndex) + { + case 0: + { + return new global::System.Threading.Tasks.ValueTask(instance.GenericValueTaskResult().AsTask()); + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex)); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes(int groupIndex) + { + switch (groupIndex) + { + case 0: + { + return + [ + new global::TUnit.Core.TestAttribute() + ]; + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex)); + } + } + private static readonly global::System.Func __createInstance = __CreateInstance; + private static readonly global::System.Func __invoke = __Invoke; + private static readonly global::System.Func __attributes = __Attributes; + public static readonly global::TUnit.Core.TestEntry[] Entries = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.CreateWithClassMetadata( + methodName: "GenericValueTaskResult", + fullyQualifiedName: "TUnit.TestProject.ValueTaskResultTests.GenericValueTaskResult", + filePath: "", + lineNumber: 5, + returnType: typeof(global::System.Threading.Tasks.ValueTask), + classMetadata: __classMetadata, + createInstance: __createInstance, + invokeBody: __invoke, + methodIndex: 0, + createAttributes: __attributes, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_ValueTaskResultTests__TestSource = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_ValueTaskResultTests__TestSource.Entries); +} diff --git a/tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.Test.DotNet8_0.verified.txt b/tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.Test.DotNet8_0.verified.txt new file mode 100644 index 0000000000..7097e7e85a --- /dev/null +++ b/tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.Test.DotNet8_0.verified.txt @@ -0,0 +1,150 @@ +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_ValueTaskResultTests_GenericMethodValueTaskResult_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.ValueTaskResultTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.ValueTaskResultTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.ValueTaskResultTests)), + Name = "ValueTaskResultTests", + Namespace = "TUnit.TestProject", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.ValueTaskResultTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("GenericMethodValueTaskResult", __classType, typeof(global::System.Threading.Tasks.ValueTask), __classMetadata, genericTypeCount: 1); + private static global::TUnit.TestProject.ValueTaskResultTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.ValueTaskResultTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.ValueTaskResultTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + return new global::System.Threading.Tasks.ValueTask(instance.GenericMethodValueTaskResult().AsTask()); + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(int)) + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "GenericMethodValueTaskResult", + fullyQualifiedName: "TUnit.TestProject.ValueTaskResultTests.GenericMethodValueTaskResult", + filePath: "", + lineNumber: 8, + methodMetadata: __mm_0, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_ValueTaskResultTests_GenericMethodValueTaskResult_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_ValueTaskResultTests_GenericMethodValueTaskResult_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_ValueTaskResultTests__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.ValueTaskResultTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.ValueTaskResultTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.ValueTaskResultTests)), + Name = "ValueTaskResultTests", + Namespace = "TUnit.TestProject", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.ValueTaskResultTests); + private static global::TUnit.TestProject.ValueTaskResultTests __CreateInstance(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.ValueTaskResultTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke(global::TUnit.TestProject.ValueTaskResultTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + switch (methodIndex) + { + case 0: + { + return new global::System.Threading.Tasks.ValueTask(instance.GenericValueTaskResult().AsTask()); + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex)); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes(int groupIndex) + { + switch (groupIndex) + { + case 0: + { + return + [ + new global::TUnit.Core.TestAttribute() + ]; + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex)); + } + } + private static readonly global::System.Func __createInstance = __CreateInstance; + private static readonly global::System.Func __invoke = __Invoke; + private static readonly global::System.Func __attributes = __Attributes; + public static readonly global::TUnit.Core.TestEntry[] Entries = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.CreateWithClassMetadata( + methodName: "GenericValueTaskResult", + fullyQualifiedName: "TUnit.TestProject.ValueTaskResultTests.GenericValueTaskResult", + filePath: "", + lineNumber: 5, + returnType: typeof(global::System.Threading.Tasks.ValueTask), + classMetadata: __classMetadata, + createInstance: __createInstance, + invokeBody: __invoke, + methodIndex: 0, + createAttributes: __attributes, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_ValueTaskResultTests__TestSource = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_ValueTaskResultTests__TestSource.Entries); +} diff --git a/tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.Test.DotNet9_0.verified.txt b/tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.Test.DotNet9_0.verified.txt new file mode 100644 index 0000000000..7097e7e85a --- /dev/null +++ b/tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.Test.DotNet9_0.verified.txt @@ -0,0 +1,150 @@ +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_ValueTaskResultTests_GenericMethodValueTaskResult_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.ValueTaskResultTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.ValueTaskResultTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.ValueTaskResultTests)), + Name = "ValueTaskResultTests", + Namespace = "TUnit.TestProject", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.ValueTaskResultTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("GenericMethodValueTaskResult", __classType, typeof(global::System.Threading.Tasks.ValueTask), __classMetadata, genericTypeCount: 1); + private static global::TUnit.TestProject.ValueTaskResultTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.ValueTaskResultTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.ValueTaskResultTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + return new global::System.Threading.Tasks.ValueTask(instance.GenericMethodValueTaskResult().AsTask()); + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(int)) + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "GenericMethodValueTaskResult", + fullyQualifiedName: "TUnit.TestProject.ValueTaskResultTests.GenericMethodValueTaskResult", + filePath: "", + lineNumber: 8, + methodMetadata: __mm_0, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_ValueTaskResultTests_GenericMethodValueTaskResult_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_ValueTaskResultTests_GenericMethodValueTaskResult_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_ValueTaskResultTests__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.ValueTaskResultTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.ValueTaskResultTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.ValueTaskResultTests)), + Name = "ValueTaskResultTests", + Namespace = "TUnit.TestProject", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.ValueTaskResultTests); + private static global::TUnit.TestProject.ValueTaskResultTests __CreateInstance(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.ValueTaskResultTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke(global::TUnit.TestProject.ValueTaskResultTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + switch (methodIndex) + { + case 0: + { + return new global::System.Threading.Tasks.ValueTask(instance.GenericValueTaskResult().AsTask()); + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex)); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes(int groupIndex) + { + switch (groupIndex) + { + case 0: + { + return + [ + new global::TUnit.Core.TestAttribute() + ]; + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex)); + } + } + private static readonly global::System.Func __createInstance = __CreateInstance; + private static readonly global::System.Func __invoke = __Invoke; + private static readonly global::System.Func __attributes = __Attributes; + public static readonly global::TUnit.Core.TestEntry[] Entries = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.CreateWithClassMetadata( + methodName: "GenericValueTaskResult", + fullyQualifiedName: "TUnit.TestProject.ValueTaskResultTests.GenericValueTaskResult", + filePath: "", + lineNumber: 5, + returnType: typeof(global::System.Threading.Tasks.ValueTask), + classMetadata: __classMetadata, + createInstance: __createInstance, + invokeBody: __invoke, + methodIndex: 0, + createAttributes: __attributes, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_ValueTaskResultTests__TestSource = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_ValueTaskResultTests__TestSource.Entries); +} diff --git a/tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.Test.Net4_7.verified.txt b/tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.Test.Net4_7.verified.txt new file mode 100644 index 0000000000..cb8e3a9c60 --- /dev/null +++ b/tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.Test.Net4_7.verified.txt @@ -0,0 +1,150 @@ +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_ValueTaskResultTests_GenericMethodValueTaskResult_TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.ValueTaskResultTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.ValueTaskResultTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.ValueTaskResultTests)), + Name = "ValueTaskResultTests", + Namespace = "TUnit.TestProject", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.ValueTaskResultTests); + private static readonly global::TUnit.Core.MethodMetadata __mm_0 = global::TUnit.Core.MethodMetadataFactory.Create("GenericMethodValueTaskResult", __classType, typeof(global::System.Threading.Tasks.ValueTask), __classMetadata, genericTypeCount: 1); + private static global::TUnit.TestProject.ValueTaskResultTests __CreateInstance_0(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.ValueTaskResultTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke_0(global::TUnit.TestProject.ValueTaskResultTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + return new global::System.Threading.Tasks.ValueTask(instance.GenericMethodValueTaskResult().AsTask()); + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes_0(int groupIndex) + { + return new global::System.Attribute[] + { + new global::TUnit.Core.TestAttribute(), + new global::TUnit.Core.GenerateGenericTestAttribute(typeof(int)) + }; + } + public static readonly global::TUnit.Core.TestEntry[] Entries_0 = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.Create( + methodName: "GenericMethodValueTaskResult", + fullyQualifiedName: "TUnit.TestProject.ValueTaskResultTests.GenericMethodValueTaskResult", + filePath: "", + lineNumber: 8, + methodMetadata: __mm_0, + createInstance: __CreateInstance_0, + invokeBody: __Invoke_0, + methodIndex: 0, + createAttributes: __Attributes_0, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_ValueTaskResultTests_GenericMethodValueTaskResult_TestSource_0 = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_ValueTaskResultTests_GenericMethodValueTaskResult_TestSource.Entries_0); +} + + +// ===== FILE SEPARATOR ===== + +// +#pragma warning disable + +#nullable enable +namespace TUnit.Generated; +[global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute] +[global::System.CodeDom.Compiler.GeneratedCode("TUnit", "VERSION_SCRUBBED")] +internal static class TUnit_TestProject_ValueTaskResultTests__TestSource +{ + private static readonly global::TUnit.Core.ClassMetadata __classMetadata = global::TUnit.Core.ClassMetadata.GetOrAdd("TestsBase`1:global::TUnit.TestProject.ValueTaskResultTests", new global::TUnit.Core.ClassMetadata + { + Type = typeof(global::TUnit.TestProject.ValueTaskResultTests), + TypeInfo = new global::TUnit.Core.ConcreteType(typeof(global::TUnit.TestProject.ValueTaskResultTests)), + Name = "ValueTaskResultTests", + Namespace = "TUnit.TestProject", + Assembly = global::TUnit.Core.AssemblyMetadata.GetOrAdd("TestsBase`1", "TestsBase`1"), + Parameters = global::System.Array.Empty(), + Properties = global::System.Array.Empty(), + Parent = null + }); + private static readonly global::System.Type __classType = typeof(global::TUnit.TestProject.ValueTaskResultTests); + private static global::TUnit.TestProject.ValueTaskResultTests __CreateInstance(global::System.Type[] typeArgs, object?[] args) + { + return new global::TUnit.TestProject.ValueTaskResultTests(); + } + private static global::System.Threading.Tasks.ValueTask __Invoke(global::TUnit.TestProject.ValueTaskResultTests instance, int methodIndex, object?[] args, global::System.Threading.CancellationToken cancellationToken) + { + try + { + switch (methodIndex) + { + case 0: + { + return new global::System.Threading.Tasks.ValueTask(instance.GenericValueTaskResult().AsTask()); + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(methodIndex)); + } + } + catch (global::System.Exception ex) + { + return new global::System.Threading.Tasks.ValueTask(global::System.Threading.Tasks.Task.FromException(ex)); + } + } + private static global::System.Attribute[] __Attributes(int groupIndex) + { + switch (groupIndex) + { + case 0: + { + return + [ + new global::TUnit.Core.TestAttribute() + ]; + } + default: + throw new global::System.ArgumentOutOfRangeException(nameof(groupIndex)); + } + } + private static readonly global::System.Func __createInstance = __CreateInstance; + private static readonly global::System.Func __invoke = __Invoke; + private static readonly global::System.Func __attributes = __Attributes; + public static readonly global::TUnit.Core.TestEntry[] Entries = new global::TUnit.Core.TestEntry[] + { + global::TUnit.Core.TestEntryFactory.CreateWithClassMetadata( + methodName: "GenericValueTaskResult", + fullyQualifiedName: "TUnit.TestProject.ValueTaskResultTests.GenericValueTaskResult", + filePath: "", + lineNumber: 5, + returnType: typeof(global::System.Threading.Tasks.ValueTask), + classMetadata: __classMetadata, + createInstance: __createInstance, + invokeBody: __invoke, + methodIndex: 0, + createAttributes: __attributes, + attributeGroupIndex: 0), + }; +} +internal static partial class TUnit_TestRegistration +{ + static readonly int _r_TUnit_TestProject_ValueTaskResultTests__TestSource = global::TUnit.Core.SourceRegistrar.RegisterEntries(static () => TUnit_TestProject_ValueTaskResultTests__TestSource.Entries); +} diff --git a/tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.cs b/tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.cs new file mode 100644 index 0000000000..e2dbc541c7 --- /dev/null +++ b/tests/TUnit.Core.SourceGenerator.Tests/ValueTaskResultTests.cs @@ -0,0 +1,23 @@ +using TUnit.Core.SourceGenerator.Tests.Options; + +namespace TUnit.Core.SourceGenerator.Tests; + +internal class ValueTaskResultTests : TestsBase +{ + [Test] + public Task Test() => RunTest( + Path.Combine(Git.TestsDirectory.FullName, "TUnit.TestProject", "ValueTaskResultTests.cs"), + new RunTestOptions + { + VerifyConfigurator = verify => verify.UniqueForTargetFrameworkAndVersion() + }, + async generatedFiles => + { + var generatedCode = string.Join(Environment.NewLine, generatedFiles); + + await Assert.That(generatedCode) + .Contains("new global::System.Threading.Tasks.ValueTask(instance.GenericValueTaskResult().AsTask())"); + await Assert.That(generatedCode) + .Contains("new global::System.Threading.Tasks.ValueTask(instance.GenericMethodValueTaskResult().AsTask())"); + }); +} diff --git a/tests/TUnit.TestProject/ValueTaskResultTests.cs b/tests/TUnit.TestProject/ValueTaskResultTests.cs new file mode 100644 index 0000000000..18ca44cc61 --- /dev/null +++ b/tests/TUnit.TestProject/ValueTaskResultTests.cs @@ -0,0 +1,11 @@ +namespace TUnit.TestProject; + +public class ValueTaskResultTests +{ + [Test] + public ValueTask GenericValueTaskResult() => ValueTask.FromResult(42); + + [Test] + [GenerateGenericTest(typeof(int))] + public ValueTask GenericMethodValueTaskResult() => ValueTask.FromResult(43); +}