Bump NuGet.BuildTasks to get new updates and switch to `dev` branch (#5566)

[mono.git] / mcs / tests / test-async-35.cs

diff --git a/mcs/tests/test-async-35.cs b/mcs/tests/test-async-35.cs
index 5b0532e1706edfbee8fb293a7ae4382c61f0bd31..e04a810ebceed00ddd87d14c43e48053a821fe4a 100644 (file)
--- a/mcs/tests/test-async-35.cs
+++ b/mcs/tests/test-async-35.cs
@@ -4,32 +4,66 @@ using System.Threading.Tasks;
 using System.Runtime.CompilerServices;
 using System.Linq;
 
-class C
+namespace N.M
 {
-       public static async Task<int> AsyncMethod ()
+       class C
        {
-               await Task.Delay (1);
-               return 0;
-       }
+               public static async Task<int> AsyncMethod ()
+               {
+                       await Task.Delay (1);
+                       return 0;
+               }
 
-       static int Main ()
-       {
-               var m = typeof (C).GetMethod ("AsyncMethod");
-               var attr = m.GetCustomAttribute<AsyncStateMachineAttribute> ();
-               if (attr == null)
-                       return 1;
+               public static async Task NestedAsyncAnonymousMethod ()
+               {
+                       Action a = async delegate {
+                               await Task.Yield();
+                       };
+
+                       await Task.Yield();
+               }
+
+               public static int Main ()
+               {
+                       var m = typeof (C).GetMethod ("AsyncMethod");
+                       var attr = m.GetCustomAttribute<AsyncStateMachineAttribute> ();
+                       if (attr == null)
+                               return 1;
+
+                       if (attr.StateMachineType == null)
+                               return 2;
+
+                       Func<Task<int>> a = async () => await AsyncMethod ();
+
+                       var c = typeof (C).GetMethods (BindingFlags.NonPublic | BindingFlags.Static).Where (l =>
+                               l.IsDefined (typeof (AsyncStateMachineAttribute))).Count ();
+
+                       if (c != 1)
+                               return 3;
+
+
+                       m = typeof (C).GetMethod ("NestedAsyncAnonymousMethod");
+                       attr = m.GetCustomAttribute<AsyncStateMachineAttribute> ();
+                       if (attr == null)
+                               return 10;
+
+                       if (attr.StateMachineType == null)
+                               return 11;
 
-               if (attr.StateMachineType == null)
-                       return 2;
+                       var n = typeof (C).GetNestedTypes (BindingFlags.NonPublic).Single (l => l.Name.Contains ("NestedAsyncAnonymousMethod"));
+                       if (n == null)
+                               return 12;
 
-               Func<Task<int>> a = async () => await AsyncMethod ();
+                       m = n.GetMethods (BindingFlags.NonPublic | BindingFlags.Static).Single (l => l.Name.Contains ("m__"));
 
-               var c = typeof (C).GetMethods (BindingFlags.NonPublic | BindingFlags.Static).Where (l =>
-                       l.IsDefined (typeof (AsyncStateMachineAttribute))).Count ();
+                       attr = m.GetCustomAttribute<AsyncStateMachineAttribute> ();
+                       if (attr == null)
+                               return 13;
 
-               if (c != 1)
-                       return 3;
+                       if (attr.StateMachineType == null)
+                               return 14;
 
-               return 0;
+                       return 0;
+               }
        }
 }