#526 Preparing unit tests for generic async method issue

Fody · May 20, 2023 · 8a1c5ac · 8a1c5ac
1 parent 4bb81b7
commit 8a1c5ac
Show file tree

Hide file tree

Showing 3 changed files with 173 additions and 131 deletions.
diff --git a/AssemblyWithoutInterceptor/ClassWithAsyncMethod.cs b/AssemblyWithoutInterceptor/ClassWithAsyncMethod.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using MethodTimer;
 #pragma warning disable 414
@@ -102,3 +103,23 @@ public async Task<bool> ComplexMethodWithAwaitAsync(int instructionsToHandle)
     public async Task MethodWithExceptionAsync() =>
         await Task.Factory.StartNew(() => throw new ArgumentOutOfRangeException());
 }
+
+public class ClassWithGenericResultAsyncMethodBase
+{
+    public virtual async Task<List<T>> DoSomethingAsync<T>()
+    {
+        await Task.Delay(50);
+
+        return new List<T>();
+    }
+}
+
+public class ClassWithGenericResultAsyncMethod : ClassWithGenericResultAsyncMethodBase
+{
+    [Time("some message")]
+    public override async Task<List<T>> DoSomethingAsync<T>()
+    {
+        var result = await base.DoSomethingAsync<T>();
+        return result;
+    }
+}
diff --git a/Tests/AssemblyTesterSets/WithoutInterceptorTests.async.cs b/Tests/AssemblyTesterSets/WithoutInterceptorTests.async.cs
@@ -0,0 +1,151 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+public partial class WithoutInterceptorTests
+{
+    [Fact]
+    public void MethodWithEmptyAsync()
+    {
+        var type = testResult.Assembly.GetType("ClassWithAsyncMethod");
+        var instance = (dynamic)Activator.CreateInstance(type);
+        var message = TraceRunner.Capture(() =>
+        {
+            var task = (Task)instance.MethodWithEmptyAsync();
+            task.Wait();
+        });
+
+        Assert.Single(message);
+        Assert.StartsWith("ClassWithAsyncMethod.MethodWithEmptyAsync ", message.First());
+    }
+
+    [Fact]
+    public void ClassWithAsyncMethod()
+    {
+        var type = testResult.Assembly.GetType("ClassWithAsyncMethod");
+        var instance = (dynamic)Activator.CreateInstance(type);
+        var message = TraceRunner.Capture(() =>
+        {
+            var task = (Task)instance.MethodWithAwaitAsync();
+            task.Wait();
+        });
+
+        Assert.Single(message);
+        Assert.StartsWith("ClassWithAsyncMethod.MethodWithAwaitAsync ", message.First());
+    }
+
+    [Fact]
+    public void ClassWithAsyncMethodThatThrowsException()
+    {
+        var type = testResult.Assembly.GetType("ClassWithAsyncMethod");
+        var instance = (dynamic)Activator.CreateInstance(type);
+        var message = TraceRunner.Capture(() =>
+        {
+            try
+            {
+                var task = (Task)instance.MethodWithAwaitAndExceptionAsync();
+                task.Wait();
+            }
+            catch (Exception)
+            {
+                // Expected
+            }
+        });
+
+        Assert.Single(message);
+        Assert.StartsWith("ClassWithAsyncMethod.MethodWithAwaitAndExceptionAsync ", message.First());
+    }
+
+    [Fact]
+    public void ClassWithInheritedGenericTaskAsyncMethod()
+    {
+        var type = testResult.Assembly.GetType("ClassWithGenericResultAsyncMethod");
+        var instance = (dynamic)Activator.CreateInstance(type);
+        var message = TraceRunner.Capture(() =>
+        {
+            var task = (Task)instance.DoSomethingAsync<int>();
+            task.Wait();
+        });
+
+        Assert.Single(message);
+        Assert.StartsWith("ClassWithGenericResultAsyncMethod.DoSomethingAsync", message.First());
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void ClassWithAsyncMethodWithFastPath(bool recurse)
+    {
+        var type = testResult.Assembly.GetType("ClassWithAsyncMethod");
+        var instance = (dynamic)Activator.CreateInstance(type);
+        var message = TraceRunner.Capture(() =>
+        {
+            var task = (Task)instance.MethodWithFastPathAsync(recurse);
+            task.Wait();
+        });
+
+        Assert.Equal(recurse ? 2 : 1, message.Count);
+        Assert.StartsWith("ClassWithAsyncMethod.MethodWithFastPathAsync ", message.First());
+    }
+
+    [Fact]
+    public void ClassWithExceptionAsyncMethod()
+    {
+        var type = testResult.Assembly.GetType("ClassWithAsyncMethod");
+        var instance = (dynamic)Activator.CreateInstance(type);
+        var message = TraceRunner.Capture(() =>
+        {
+            var task = (Task)instance.ComplexMethodWithAwaitAsync(-1);
+            task.Wait();
+        });
+
+        Assert.Single(message);
+        Assert.StartsWith("ClassWithAsyncMethod.ComplexMethodWithAwaitAsync ", message.First());
+    }
+
+    [Fact]
+    public void ClassWithFastComplexAsyncMethod()
+    {
+        var type = testResult.Assembly.GetType("ClassWithAsyncMethod");
+        var instance = (dynamic)Activator.CreateInstance(type);
+        var message = TraceRunner.Capture(() =>
+        {
+            var task = (Task)instance.ComplexMethodWithAwaitAsync(0);
+            task.Wait();
+        });
+
+        Assert.Single(message);
+        Assert.StartsWith("ClassWithAsyncMethod.ComplexMethodWithAwaitAsync ", message.First());
+    }
+
+    [Fact]
+    public void ClassWithMediumComplexAsyncMethod()
+    {
+        var type = testResult.Assembly.GetType("ClassWithAsyncMethod");
+        var instance = (dynamic)Activator.CreateInstance(type);
+        var message = TraceRunner.Capture(() =>
+        {
+            var task = (Task)instance.ComplexMethodWithAwaitAsync(2);
+            task.Wait();
+        });
+
+        Assert.Single(message);
+        Assert.StartsWith("ClassWithAsyncMethod.ComplexMethodWithAwaitAsync ", message.First());
+    }
+
+    [Fact]
+    public void ClassWithSlowComplexAsyncMethod()
+    {
+        var type = testResult.Assembly.GetType("ClassWithAsyncMethod");
+        var instance = (dynamic)Activator.CreateInstance(type);
+        var message = TraceRunner.Capture(() =>
+        {
+            var task = (Task)instance.ComplexMethodWithAwaitAsync(100);
+            task.Wait();
+        });
+
+        Assert.Single(message);
+        Assert.StartsWith("ClassWithAsyncMethod.ComplexMethodWithAwaitAsync ", message.First());
+    }
+}
diff --git a/Tests/AssemblyTesterSets/WithoutInterceptorTests.cs b/Tests/AssemblyTesterSets/WithoutInterceptorTests.cs
@@ -1,11 +1,10 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Threading.Tasks;
 using Fody;
 using Xunit;
 
-public class WithoutInterceptorTests
+public partial class WithoutInterceptorTests
 {
     static TestResult testResult;
 
@@ -53,135 +52,6 @@ public void ClassWithYieldMethod()
         //Assert.True(message.First().StartsWith("ClassWithYieldMethod.YieldMethod "));
     }
 
-    [Fact]
-    public void MethodWithEmptyAsync()
-    {
-        var type = testResult.Assembly.GetType("ClassWithAsyncMethod");
-        var instance = (dynamic)Activator.CreateInstance(type);
-        var message = TraceRunner.Capture(() =>
-        {
-            var task = (Task)instance.MethodWithEmptyAsync();
-            task.Wait();
-        });
-
-        Assert.Single(message);
-        Assert.StartsWith("ClassWithAsyncMethod.MethodWithEmptyAsync ", message.First());
-    }
-
-    [Fact]
-    public void ClassWithAsyncMethod()
-    {
-        var type = testResult.Assembly.GetType("ClassWithAsyncMethod");
-        var instance = (dynamic)Activator.CreateInstance(type);
-        var message = TraceRunner.Capture(() =>
-        {
-            var task = (Task)instance.MethodWithAwaitAsync();
-            task.Wait();
-        });
-
-        Assert.Single(message);
-        Assert.StartsWith("ClassWithAsyncMethod.MethodWithAwaitAsync ", message.First());
-    }
-
-    [Fact]
-    public void ClassWithAsyncMethodThatThrowsException()
-    {
-        var type = testResult.Assembly.GetType("ClassWithAsyncMethod");
-        var instance = (dynamic)Activator.CreateInstance(type);
-        var message = TraceRunner.Capture(() =>
-        {
-            try
-            {
-                var task = (Task)instance.MethodWithAwaitAndExceptionAsync();
-                task.Wait();
-            }
-            catch (Exception)
-            {
-                // Expected
-            }
-        });
-
-        Assert.Single(message);
-        Assert.StartsWith("ClassWithAsyncMethod.MethodWithAwaitAndExceptionAsync ", message.First());
-    }
-
-    [Theory]
-    [InlineData(true)]
-    [InlineData(false)]
-    public void ClassWithAsyncMethodWithFastPath(bool recurse)
-    {
-        var type = testResult.Assembly.GetType("ClassWithAsyncMethod");
-        var instance = (dynamic)Activator.CreateInstance(type);
-        var message = TraceRunner.Capture(() =>
-        {
-            var task = (Task)instance.MethodWithFastPathAsync(recurse);
-            task.Wait();
-        });
-
-        Assert.Equal(recurse ? 2 : 1, message.Count);
-        Assert.StartsWith("ClassWithAsyncMethod.MethodWithFastPathAsync ", message.First());
-    }
-
-    [Fact]
-    public void ClassWithExceptionAsyncMethod()
-    {
-        var type = testResult.Assembly.GetType("ClassWithAsyncMethod");
-        var instance = (dynamic)Activator.CreateInstance(type);
-        var message = TraceRunner.Capture(() =>
-        {
-            var task = (Task)instance.ComplexMethodWithAwaitAsync(-1);
-            task.Wait();
-        });
-
-        Assert.Single(message);
-        Assert.StartsWith("ClassWithAsyncMethod.ComplexMethodWithAwaitAsync ", message.First());
-    }
-
-    [Fact]
-    public void ClassWithFastComplexAsyncMethod()
-    {
-        var type = testResult.Assembly.GetType("ClassWithAsyncMethod");
-        var instance = (dynamic)Activator.CreateInstance(type);
-        var message = TraceRunner.Capture(() =>
-        {
-            var task = (Task)instance.ComplexMethodWithAwaitAsync(0);
-            task.Wait();
-        });
-
-        Assert.Single(message);
-        Assert.StartsWith("ClassWithAsyncMethod.ComplexMethodWithAwaitAsync ", message.First());
-    }
-
-    [Fact]
-    public void ClassWithMediumComplexAsyncMethod()
-    {
-        var type = testResult.Assembly.GetType("ClassWithAsyncMethod");
-        var instance = (dynamic)Activator.CreateInstance(type);
-        var message = TraceRunner.Capture(() =>
-        {
-            var task = (Task)instance.ComplexMethodWithAwaitAsync(2);
-            task.Wait();
-        });
-
-        Assert.Single(message);
-        Assert.StartsWith("ClassWithAsyncMethod.ComplexMethodWithAwaitAsync ", message.First());
-    }
-
-    [Fact]
-    public void ClassWithSlowComplexAsyncMethod()
-    {
-        var type = testResult.Assembly.GetType("ClassWithAsyncMethod");
-        var instance = (dynamic)Activator.CreateInstance(type);
-        var message = TraceRunner.Capture(() =>
-        {
-            var task = (Task)instance.ComplexMethodWithAwaitAsync(100);
-            task.Wait();
-        });
-
-        Assert.Single(message);
-        Assert.StartsWith("ClassWithAsyncMethod.ComplexMethodWithAwaitAsync ", message.First());
-    }
-
     [Fact]
     public void ClassWithConstructor()
     {