X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fclass%2Fcorlib%2FTest%2FSystem.Runtime.CompilerServices%2FTaskAwaiterTest.cs;h=6a6ecc0b36d66e4bb24febc722b64536c5935179;hb=7bd7446abcbe2c93be78fd97221dcddaeb92d653;hp=1bc9d38414758f89d626e21e369236701da04839;hpb=0b4bc83e79ca3057693089dc7f926004bb9d9592;p=mono.git

diff --git a/mcs/class/corlib/Test/System.Runtime.CompilerServices/TaskAwaiterTest.cs b/mcs/class/corlib/Test/System.Runtime.CompilerServices/TaskAwaiterTest.cs
index 1bc9d384147..6a6ecc0b36d 100644
--- a/mcs/class/corlib/Test/System.Runtime.CompilerServices/TaskAwaiterTest.cs
+++ b/mcs/class/corlib/Test/System.Runtime.CompilerServices/TaskAwaiterTest.cs
@@ -26,7 +26,6 @@
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //
 
-#if NET_4_5
 
 using System;
 using System.Threading;
@@ -35,6 +34,7 @@ using NUnit.Framework;
 using System.Runtime.CompilerServices;
 using System.Collections.Generic;
 using System.Collections;
+using System.Collections.Concurrent;
 
 namespace MonoTests.System.Runtime.CompilerServices
 {
@@ -106,6 +106,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;
@@ -211,6 +248,7 @@ namespace MonoTests.System.Runtime.CompilerServices
 		}
 
 		[Test]
+		[Ignore ("Incompatible with nunitlite")]
 		public void FinishedTaskOnCompleted ()
 		{
 			var mres = new ManualResetEvent (false);
@@ -230,7 +268,7 @@ namespace MonoTests.System.Runtime.CompilerServices
 
 			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
+			// e.g. nunitlite/Touch.Unit defaults to run tests on the main thread and this will return false
 			Assert.AreEqual (Thread.CurrentThread.IsBackground, mres2.WaitOne (2000), "#2");;
 		}
 
@@ -325,7 +363,33 @@ namespace MonoTests.System.Runtime.CompilerServices
 
 			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);
+		}
 	}
 }
 
-#endif