Merge pull request #2545 from ermshiperete/Xamarin-24974

[mono.git] / mcs / class / corlib / Test / System.Runtime.CompilerServices / TaskAwaiterTest.cs

diff --git a/mcs/class/corlib/Test/System.Runtime.CompilerServices/TaskAwaiterTest.cs b/mcs/class/corlib/Test/System.Runtime.CompilerServices/TaskAwaiterTest.cs
index 74d5c548852556979c82a339d9ada3173ab4f9d9..57b1d2c27642c1dafc45d854a7ccf92f086f1cee 100644 (file)
--- a/mcs/class/corlib/Test/System.Runtime.CompilerServices/TaskAwaiterTest.cs
+++ b/mcs/class/corlib/Test/System.Runtime.CompilerServices/TaskAwaiterTest.cs
@@ -35,6 +35,7 @@ using NUnit.Framework;
 using System.Runtime.CompilerServices;
 using System.Collections.Generic;
 using System.Collections;
+using System.Collections.Concurrent;
 
 namespace MonoTests.System.Runtime.CompilerServices
 {
@@ -72,6 +73,11 @@ namespace MonoTests.System.Runtime.CompilerServices
                                Interlocked.Increment (ref ic);
                                return false;
                        }
+
+                       public override string ToString ()
+                       {
+                               return "Scheduler-" + name;
+                       }
                }
 
                class SingleThreadSynchronizationContext : SynchronizationContext
@@ -101,6 +107,43 @@ namespace MonoTests.System.Runtime.CompilerServices
                        }
                }
 
+               class NestedSynchronizationContext : SynchronizationContext
+               {
+                       Thread thread;
+                       readonly ConcurrentQueue<Tuple<SendOrPostCallback, object, ExecutionContext>> workQueue = new ConcurrentQueue<Tuple<SendOrPostCallback, object, ExecutionContext>> ();
+                       readonly AutoResetEvent workReady = new AutoResetEvent (false);
+
+                       public NestedSynchronizationContext ()
+                       {
+                               thread = new Thread (WorkerThreadProc) { IsBackground = true };
+                               thread.Start ();
+                       }
+
+                       public override void Post (SendOrPostCallback d, object state)
+                       {
+                               var context = ExecutionContext.Capture ();
+                               workQueue.Enqueue (Tuple.Create (d, state, context));
+                               workReady.Set ();
+                       }
+
+                       void WorkerThreadProc ()
+                       {
+                               if (!workReady.WaitOne (10000))
+                                       return;
+
+                               Tuple<SendOrPostCallback, object, ExecutionContext> work;
+
+                               while (workQueue.TryDequeue (out work)) {
+                                       ExecutionContext.Run (work.Item3, _ => {
+                                               var oldSyncContext = SynchronizationContext.Current;
+                                               SynchronizationContext.SetSynchronizationContext (this);
+                                               work.Item1 (_);
+                                               SynchronizationContext.SetSynchronizationContext (oldSyncContext);
+                                       }, work.Item2); 
+                               }
+                       }
+               }
+
                string progress;
                SynchronizationContext sc;
                ManualResetEvent mre;
@@ -178,7 +221,7 @@ namespace MonoTests.System.Runtime.CompilerServices
                        Assert.IsTrue (t.Wait (3000), "#0");
                        Assert.AreEqual (0, t.Result, "#1");
                        Assert.AreEqual (0, b.InlineCalls, "#2b");
-                       Assert.AreEqual (2, a.QueueCalls, "#3a");
+                       Assert.IsTrue (a.QueueCalls == 1 || a.QueueCalls == 2, "#3a");
                        Assert.AreEqual (1, b.QueueCalls, "#3b");
                }
 
@@ -205,6 +248,7 @@ namespace MonoTests.System.Runtime.CompilerServices
                        return res.Result;
                }
 
+#if !MOBILE_STATIC
                [Test]
                public void FinishedTaskOnCompleted ()
                {
@@ -229,6 +273,8 @@ namespace MonoTests.System.Runtime.CompilerServices
                        Assert.AreEqual (Thread.CurrentThread.IsBackground, mres2.WaitOne (2000), "#2");;
                }
 
+#endif
+
                [Test]
                public void CompletionOnSameCustomSynchronizationContext ()
                {
@@ -278,7 +324,9 @@ namespace MonoTests.System.Runtime.CompilerServices
                        SynchronizationContext.SetSynchronizationContext (syncContext);
 
                        syncContext.Post (delegate {
-                               Go2 (syncContext);
+                               Task t = new Task (delegate() { });
+                               Go2 (syncContext, t);
+                               t.Start ();
                        }, null);
 
                        // Custom message loop
@@ -289,30 +337,62 @@ namespace MonoTests.System.Runtime.CompilerServices
                                Thread.Sleep (0);
                        }
 
-                       Assert.AreEqual ("132", progress);
+                       Assert.AreEqual ("13xa2", progress);
                }
 
-               async void Go2 (SynchronizationContext ctx)
+               async void Go2 (SynchronizationContext ctx, Task t)
                {
-                       await Wait2 (ctx);
+                       await Wait2 (ctx, t);
+
+                       progress += "a";
 
                        if (mre.WaitOne (5000))
                                progress += "2";
+                       else
+                               progress += "b";
                }
 
-               async Task Wait2 (SynchronizationContext ctx)
+               async Task Wait2 (SynchronizationContext ctx, Task t)
                {
-                       await Task.Delay (10); // Force block suspend/return
+                       await t; // Force block suspend/return
 
                        ctx.Post (l => {
                                progress += "3";
                                mre.Set ();
+                               progress += "x";
                        }, null);
 
                        progress += "1";
 
                        SynchronizationContext.SetSynchronizationContext (null);
                }
+
+               [Test]
+               public void NestedLeakingSynchronizationContext ()
+               {
+                       var sc = SynchronizationContext.Current;
+                       if (sc == null)
+                               Assert.IsTrue (NestedLeakingSynchronizationContext_MainAsync (sc).Wait (5000), "#1");
+                       else
+                               Assert.Ignore ("NestedSynchronizationContext may never complete on custom context");
+               }
+
+               static async Task NestedLeakingSynchronizationContext_MainAsync (SynchronizationContext sc)
+               {
+                       Assert.AreSame (sc, SynchronizationContext.Current, "#1");
+                       await NestedLeakingSynchronizationContext_DoWorkAsync ();
+                       Assert.AreSame (sc, SynchronizationContext.Current, "#2");
+               }
+
+               static async Task NestedLeakingSynchronizationContext_DoWorkAsync ()
+               {
+                       var sc = new NestedSynchronizationContext ();
+                       SynchronizationContext.SetSynchronizationContext (sc);
+
+                       Assert.AreSame (sc, SynchronizationContext.Current);
+                       await Task.Yield ();
+                       Assert.AreSame (sc, SynchronizationContext.Current);
+               }
        }
 }