添加测试用例（#110）

Author: inversionhourglass

test/Rougamo.Fody.Tests/IssueTest.cs

@@ -1,6 +1,7 @@
 using Issues;
 using Issues.Attributes;
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
@@ -269,11 +270,69 @@ public void Issue107Test()
             var instance = Assembly.GetInstance(nameof(Issue107));
             instance.Test();
         }
+
         [Fact]
         public void Issue108Test()
         {
             var instance = Assembly.GetInstance("Issue108`1", false, t => t.MakeGenericType(typeof(string)));
             instance.CatchAndGetStackTrace(108, "mono-stacktrace");
         }
+
+        [Fact]
+        public async Task Issue110Test()
+        {
+            var instance = Assembly.GetInstance(nameof(Issue110));
+            var logs = new List<string>();
+
+            var enumerator = (IEnumerator)instance.Enumerator(logs);
+            while (enumerator.MoveNext()) ;
+            Assert.Equal(["Enumerator OnEntry", "Enumerator OnSuccess", "Enumerator OnExit"], logs);
+            logs.Clear();
+
+            var genericEnumerator = (IEnumerator<int>)instance.GenericEnumerator(logs);
+            while (genericEnumerator.MoveNext()) ;
+            Assert.Equal(["GenericEnumerator OnEntry", "GenericEnumerator OnSuccess", "GenericEnumerator OnExit"], logs);
+            logs.Clear();
+
+            var genericEnumerator1 = (IEnumerator<Guid>)instance.GenericEnumerator<Guid>(logs);
+            while (genericEnumerator1.MoveNext()) ;
+            Assert.Equal(["GenericEnumerator`1 OnEntry", "GenericEnumerator`1 OnSuccess", "GenericEnumerator`1 OnExit"], logs);
+            logs.Clear();
+
+            var enumerable = (IEnumerable)instance.Enumerable(logs);
+            foreach (var item in enumerable) ;
+            Assert.Equal(["Enumerable OnEntry", "Enumerable OnSuccess", "Enumerable OnExit"], logs);
+            logs.Clear();
+
+            var genericEnumerable = (IEnumerable<int>)instance.GenericEnumerable(logs);
+            foreach (var item in genericEnumerable) ;
+            Assert.Equal(["GenericEnumerable OnEntry", "GenericEnumerable OnSuccess", "GenericEnumerable OnExit"], logs);
+            logs.Clear();
+
+            var genericEnumerable1 = (IEnumerable<string>)instance.GenericEnumerable<string>(logs);
+            foreach (var item in genericEnumerable1) ;
+            Assert.Equal(["GenericEnumerable`1 OnEntry", "GenericEnumerable`1 OnSuccess", "GenericEnumerable`1 OnExit"], logs);
+            logs.Clear();
+
+            var asyncEnumerator = (IAsyncEnumerator<int>)instance.EnumeratorAsync(logs);
+            while (await asyncEnumerator.MoveNextAsync()) ;
+            Assert.Equal(["EnumeratorAsync OnEntry", "EnumeratorAsync OnSuccess", "EnumeratorAsync OnExit"], logs);
+            logs.Clear();
+
+            var asyncEnumerator1 = (IAsyncEnumerator<decimal>)instance.EnumeratorAsync<decimal>(logs);
+            while (await asyncEnumerator1.MoveNextAsync()) ;
+            Assert.Equal(["EnumeratorAsync`1 OnEntry", "EnumeratorAsync`1 OnSuccess", "EnumeratorAsync`1 OnExit"], logs);
+            logs.Clear();
+
+            var asyncEnumerable = (IAsyncEnumerable<int>)instance.EnumerableAsync(logs);
+            await foreach (var item in asyncEnumerable) ;
+            Assert.Equal(["EnumerableAsync OnEntry", "EnumerableAsync OnSuccess", "EnumerableAsync OnExit"], logs);
+            logs.Clear();
+
+            var asyncEnumerable1 = (IAsyncEnumerable<DateTime>)instance.EnumerableAsync<DateTime>(logs);
+            await foreach (var item in asyncEnumerable1) ;
+            Assert.Equal(["EnumerableAsync`1 OnEntry", "EnumerableAsync`1 OnSuccess", "EnumerableAsync`1 OnExit"], logs);
+            logs.Clear();
+        }
     }
 }

test/TestAssemblies/Issues/Attributes/_110_Attribute.cs

@@ -0,0 +1,37 @@
+using Rougamo;
+using Rougamo.Context;
+using System.Collections.Generic;
+
+namespace Issues.Attributes;
+
+public class _110_Attribute : MoAttribute
+{
+    public override void OnEntry(MethodContext context)
+    {
+        ((List<string>)context.Arguments[0]).Add($"{GetMethodName(context)} OnEntry");
+    }
+
+    public override void OnSuccess(MethodContext context)
+    {
+        ((List<string>)context.Arguments[0]).Add($"{GetMethodName(context)} OnSuccess");
+    }
+
+    public override void OnException(MethodContext context)
+    {
+        ((List<string>)context.Arguments[0]).Add($"{GetMethodName(context)} OnException");
+    }
+
+    public override void OnExit(MethodContext context)
+    {
+        ((List<string>)context.Arguments[0]).Add($"{GetMethodName(context)} OnExit");
+    }
+
+    public static string GetMethodName(MethodContext context)
+    {
+        if (!context.Method.IsGenericMethodDefinition) return context.Method.Name;
+
+        var count = context.Method.GetGenericArguments().Length;
+
+        return $"{context.Method.Name}`{count}";
+    }
+}

test/TestAssemblies/Issues/Issue110.cs

@@ -0,0 +1,91 @@
+using Issues.Attributes;
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace Issues;
+
+public class Issue110
+{
+    public int X { get; set; } = 1;
+
+    public int Y { get; set; } = 2;
+
+    public int Z { get; set; } = 3;
+
+    [_110_]
+    public IEnumerator Enumerator(List<string> logs)
+    {
+        yield return X;
+        yield return Y;
+        yield return Z;
+    }
+
+    [_110_]
+    public IEnumerator<int> GenericEnumerator(List<string> logs)
+    {
+        yield return X;
+        yield return Y;
+        yield return Z;
+    }
+
+    [_110_]
+    public IEnumerator<T> GenericEnumerator<T>(List<string> logs)
+    {
+        yield return default;
+    }
+
+    [_110_]
+    public IEnumerable Enumerable(List<string> logs)
+    {
+        yield return X;
+        yield return Y;
+        yield return Z;
+    }
+
+    [_110_]
+    public IEnumerable<int> GenericEnumerable(List<string> logs)
+    {
+        yield return X;
+        yield return Y;
+        yield return Z;
+    }
+
+    [_110_]
+    public IEnumerable<T> GenericEnumerable<T>(List<string> logs)
+    {
+        yield return default;
+    }
+
+    [_110_]
+    public async IAsyncEnumerator<int> EnumeratorAsync(List<string> logs)
+    {
+        await Task.Yield();
+        yield return X;
+        yield return Y;
+        yield return Z;
+    }
+
+    [_110_]
+    public async IAsyncEnumerator<T> EnumeratorAsync<T>(List<string> logs)
+    {
+        await Task.Yield();
+        yield return default;
+    }
+
+    [_110_]
+    public async IAsyncEnumerable<int> EnumerableAsync(List<string> logs)
+    {
+        await Task.Yield();
+        yield return X;
+        yield return Y;
+        yield return Z;
+    }
+
+    [_110_]
+    public async IAsyncEnumerable<T> EnumerableAsync<T>(List<string> logs)
+    {
+        await Task.Yield();
+        yield return default;
+    }
+}