Merge pull request #943 from ermshiperete/bug-novell-325669

[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 590e9073692a065fb7abc699bbc5a09408f56658..a403d5287e2d6af53add6c41d825a641bea42ae6 100644 (file)
--- a/mcs/class/corlib/Test/System.Runtime.CompilerServices/TaskAwaiterTest.cs
+++ b/mcs/class/corlib/Test/System.Runtime.CompilerServices/TaskAwaiterTest.cs
@@ -34,6 +34,7 @@ using System.Threading.Tasks;
 using NUnit.Framework;
 using System.Runtime.CompilerServices;
 using System.Collections.Generic;
+using System.Collections;
 
 namespace MonoTests.System.Runtime.CompilerServices
 {
@@ -72,6 +73,48 @@ namespace MonoTests.System.Runtime.CompilerServices
                        }
                }
 
+               class SingleThreadSynchronizationContext : SynchronizationContext
+               {
+                       readonly Queue _queue = new Queue ();
+
+                       public void RunOnCurrentThread ()
+                       {
+                               while (_queue.Count != 0) {
+                                       var workItem = (KeyValuePair<SendOrPostCallback, object>) _queue.Dequeue ();
+                                       workItem.Key (workItem.Value);
+                               }
+                       }
+                               
+                       public override void Post (SendOrPostCallback d, object state)
+                       {
+                               if (d == null) {
+                                       throw new ArgumentNullException ("d");
+                               }
+
+                               _queue.Enqueue (new KeyValuePair<SendOrPostCallback, object> (d, state));
+                       }
+
+                       public override void Send (SendOrPostCallback d, object state)
+                       {
+                               throw new NotSupportedException ("Synchronously sending is not supported.");
+                       }
+               }
+
+               string progress;
+               SynchronizationContext sc;
+
+               [SetUp]
+               public void Setup ()
+               {
+                       sc = SynchronizationContext.Current;
+               }
+
+               [TearDown]
+               public void TearDown ()
+               {
+                       SynchronizationContext.SetSynchronizationContext (sc);
+               }
+
                [Test]
                public void GetResultFaulted ()
                {
@@ -124,7 +167,7 @@ namespace MonoTests.System.Runtime.CompilerServices
                {
                        // some test runners (e.g. Touch.Unit) will execute this on the main thread and that would lock them
                        if (!Thread.CurrentThread.IsBackground)
-                               return;
+                               Assert.Ignore ("Current thread is not running in the background.");
 
                        var a = new Scheduler ("a");
                        var b = new Scheduler ("b");
@@ -132,7 +175,6 @@ namespace MonoTests.System.Runtime.CompilerServices
                        var t = TestCS (a, b);
                        Assert.IsTrue (t.Wait (3000), "#0");
                        Assert.AreEqual (0, t.Result, "#1");
-                       Assert.AreEqual (1, a.InlineCalls, "#2a");
                        Assert.AreEqual (0, b.InlineCalls, "#2b");
                        Assert.AreEqual (2, a.QueueCalls, "#3a");
                        Assert.AreEqual (1, b.QueueCalls, "#3b");
@@ -160,7 +202,111 @@ namespace MonoTests.System.Runtime.CompilerServices
 
                        return res.Result;
                }
+
+               [Test]
+               public void FinishedTaskOnCompleted ()
+               {
+                       var mres = new ManualResetEvent (false);
+                       var mres2 = new ManualResetEvent (false);
+
+                       var tcs = new TaskCompletionSource<object> ();
+                       tcs.SetResult (null);
+                       var task = tcs.Task;
+
+                       var awaiter = task.GetAwaiter ();
+                       Assert.IsTrue (awaiter.IsCompleted, "#1");
+
+                       awaiter.OnCompleted(() => { 
+                               if (mres.WaitOne (1000))
+                                       mres2.Set ();
+                       });
+
+                       mres.Set ();
+                       // this will only terminate correctly if the test was not executed from the main thread
+                       // e.g. Touch.Unit defaults to run tests on the main thread and this will return false
+                       Assert.AreEqual (Thread.CurrentThread.IsBackground, mres2.WaitOne (2000), "#2");;
+               }
+
+               [Test]
+               public void CompletionOnSameCustomSynchronizationContext ()
+               {
+                       progress = "";
+                       var syncContext = new SingleThreadSynchronizationContext ();
+                       SynchronizationContext.SetSynchronizationContext (syncContext);
+
+                       syncContext.Post (delegate {
+                               Go (syncContext);
+                       }, null);
+
+                       // Custom message loop
+                       var cts = new CancellationTokenSource ();
+                       cts.CancelAfter (5000);
+                       while (progress.Length != 3 && !cts.IsCancellationRequested) {
+                               syncContext.RunOnCurrentThread ();
+                               Thread.Sleep (0);
+                       }
+
+                       Assert.AreEqual ("123", progress);
+               }
+
+               async void Go (SynchronizationContext ctx)
+               {
+                       await Wait (ctx);
+
+                       progress += "2";
+               }
+
+               async Task Wait (SynchronizationContext ctx)
+               {
+                       await Task.Delay (10); // Force block suspend/return
+
+                       ctx.Post (l => progress += "3", null);
+
+                       progress += "1";
+
+                       // Exiting same context - no need to post continuation
+               }
+
+               [Test]
+               public void CompletionOnDifferentCustomSynchronizationContext ()
+               {
+                       progress = "";
+                       var syncContext = new SingleThreadSynchronizationContext ();
+                       SynchronizationContext.SetSynchronizationContext (syncContext);
+
+                       syncContext.Post (delegate {
+                               Go2 (syncContext);
+                       }, null);
+
+                       // Custom message loop
+                       var cts = new CancellationTokenSource ();
+                       cts.CancelAfter (5000);
+                       while (progress.Length != 3 && !cts.IsCancellationRequested) {
+                               syncContext.RunOnCurrentThread ();
+                               Thread.Sleep (0);
+                       }
+
+                       Assert.AreEqual ("132", progress);
+               }
+
+               async void Go2 (SynchronizationContext ctx)
+               {
+                       await Wait2 (ctx);
+
+                       progress += "2";
+               }
+
+               async Task Wait2 (SynchronizationContext ctx)
+               {
+                       await Task.Delay (10); // Force block suspend/return
+
+                       ctx.Post (l => progress += "3", null);
+
+                       progress += "1";
+
+                       SynchronizationContext.SetSynchronizationContext (null);
+               }
        }
 }
 
-#endif
\ No newline at end of file
+#endif