Merge lp:~simone.busoli/nunitv2/1066386 into lp:nunitv2

[Simone Busoli]

No changes for support to async void tests are required.
Now the test context flows across threads, either created explicitly in the test body or as a consequence of writing async tests methods.

I tried to limit the changes to the minimum. ContextDictionary inherited Hashtable and was passed around as IDictionary but since I had to make it inherit from MarshalByRefObject I removed the inheritance from Hashtable, replaced with IDictionary and moved to composition, which in turn forced the implementation of the interface methods, all currently throwing NotImplementedException except the indexer.

[Simone Busoli (simone.busoli)]

All tests using TestContext are currently failing when built for .net >= 4.0 for CAS violations, including the newly added ones.

[Charlie Poole (charlie.poole)]

Looks good... thanks.

review: Approve

=== modified file 'src/NUnitCore/core/ContextDictionary.cs'
--- src/NUnitCore/core/ContextDictionary.cs	2012-09-25 16:39:42 +0000
+++ src/NUnitCore/core/ContextDictionary.cs	2012-10-14 11:24:24 +0000
@@ -5,22 +5,25 @@
 // ****************************************************************
 
 using System;
-using System.Collections;
-
+using System.Collections;
+using System.Runtime.Remoting.Messaging;
+
 namespace NUnit.Core
 {
-    public class ContextDictionary : Hashtable
+	[Serializable]
+    public class ContextDictionary : MarshalByRefObject, IDictionary, ILogicalThreadAffinative
     {
         internal TestExecutionContext _context;
+		private readonly Hashtable _storage = new Hashtable();
 
         public ContextDictionary() { }
 
         public ContextDictionary(TestExecutionContext context)
         {
             _context = context;
-        }
-
-        public override object this[object key]
+        }
+
+		public object this[object key]
         {
             get
             {
@@ -43,13 +46,87 @@
                             ? _context.TestPackage.Settings["WorkDirectory"]
                             : Environment.CurrentDirectory;
                     default:
-                        return base[key];
+                        return _storage[key];
                 }
             }
             set
             {
-                base[key] = value;
+                _storage[key] = value;
             }
-        }
+        }
+
+		#region IDictionary Interface non-implementation
+
+		void IDictionary.Remove(object key)
+		{
+			throw new NotImplementedException();
+		}
+
+		ICollection IDictionary.Keys
+		{
+			get { throw new NotImplementedException(); }
+		}
+
+		ICollection IDictionary.Values
+		{
+			get { throw new NotImplementedException(); }
+		}
+
+		bool IDictionary.IsReadOnly
+		{
+			get { throw new NotImplementedException(); }
+		}
+
+		bool IDictionary.IsFixedSize
+		{
+			get { throw new NotImplementedException(); }
+		}
+
+		bool IDictionary.Contains(object key)
+		{
+			throw new NotImplementedException();
+		}
+
+		void IDictionary.Add(object key, object value)
+		{
+			throw new NotImplementedException();
+		}
+
+		void IDictionary.Clear()
+		{
+			throw new NotImplementedException();
+		}
+
+		IDictionaryEnumerator IDictionary.GetEnumerator()
+		{
+			throw new NotImplementedException();
+		}
+
+		IEnumerator IEnumerable.GetEnumerator()
+		{
+			throw new NotImplementedException();
+		}
+
+		void ICollection.CopyTo(Array array, int index)
+		{
+			throw new NotImplementedException();
+		}
+
+		int ICollection.Count
+		{
+			get { throw new NotImplementedException(); }
+		}
+
+		object ICollection.SyncRoot
+		{
+			get { throw new NotImplementedException(); }
+		}
+
+		bool ICollection.IsSynchronized
+		{
+			get { throw new NotImplementedException(); }
+		}
+
+		#endregion
     }
-}
+}
\ No newline at end of file

=== modified file 'src/NUnitCore/core/TestExecutionContext.cs'
--- src/NUnitCore/core/TestExecutionContext.cs	2012-09-25 16:39:42 +0000
+++ src/NUnitCore/core/TestExecutionContext.cs	2012-10-14 11:24:24 +0000
@@ -3,9 +3,7 @@
 // This is free software licensed under the NUnit license. You may
 // obtain a copy of the license at http://nunit.org.
 // ****************************************************************
-using System;
-using System.Collections.Specialized;
-using System.Configuration;
+using System;
 using System.IO;
 using System.Diagnostics;
 using System.Globalization;
@@ -26,7 +24,7 @@
 	/// 
 	/// Static methods for each setting forward to the internal 
 	/// object on the top of the stack.
-	/// </summary>
+	/// </summary>
 	public class TestExecutionContext
 	{
 		#region Static Fields
@@ -398,7 +396,7 @@
         public static void Save()
         {
             current = new TestExecutionContext(current);
-            CallContext.SetData("NUnit.Framework.TestContext", current.contextDictionary);
+            CallContext.LogicalSetData("NUnit.Framework.TestContext", current.contextDictionary);
         }
 
         /// <summary>
@@ -409,7 +407,7 @@
         {
             current.ReverseChanges();
             current = current.prior;
-            CallContext.SetData("NUnit.Framework.TestContext", current.contextDictionary);
+            CallContext.LogicalSetData("NUnit.Framework.TestContext", current.contextDictionary);
         }
         #endregion
 

=== modified file 'src/NUnitCore/core/TestThread.cs'
--- src/NUnitCore/core/TestThread.cs	2011-12-26 21:24:27 +0000
+++ src/NUnitCore/core/TestThread.cs	2012-10-14 11:24:24 +0000
@@ -91,7 +91,7 @@
             this.thrownException = null;
             this.listener = listener;
             this.filter = filter;
-			this.contextDictionary = (ContextDictionary)CallContext.GetData("NUnit.Framework.TestContext");
+			this.contextDictionary = (ContextDictionary)CallContext.LogicalGetData("NUnit.Framework.TestContext");
 
             log.Debug("Starting test in separate thread");
             thread.Start();
@@ -133,7 +133,7 @@
         /// </summary>
         private void RunTestProc()
         {
-			CallContext.SetData("NUnit.Framework.TestContext", contextDictionary);
+			CallContext.LogicalSetData("NUnit.Framework.TestContext", contextDictionary);
 			
             try
             {

=== modified file 'src/NUnitCore/tests-net45/NUnitAsyncTestMethodTests.cs'
--- src/NUnitCore/tests-net45/NUnitAsyncTestMethodTests.cs	2012-10-08 22:03:22 +0000
+++ src/NUnitCore/tests-net45/NUnitAsyncTestMethodTests.cs	2012-10-14 11:24:24 +0000
@@ -1,104 +1,108 @@
-#if NET_3_5 || NET_4_0 || NET_4_5
-using System;
-using System.Collections;
-using System.Diagnostics;
-using System.Linq.Expressions;
-using System.Reflection;
-using System.Threading;
-using NUnit.Core;
-using NUnit.Core.Builders;
-using NUnit.Framework;
-using test_assembly_net45;
-
-namespace nunit.core.tests.net45
-{
-	[TestFixture]
-	public class NUnitAsyncTestMethodTests
-	{
-		private NUnitTestCaseBuilder _builder;
-
-		[SetUp]
-		public void Setup()
-		{
-			_builder = new NUnitTestCaseBuilder();
-		}
-
-		public IEnumerable TestCases
-		{
-			get
-			{
-				yield return new object[] { Method("VoidTestSuccess"), ResultState.Success, 1 };
-				yield return new object[] { Method("VoidTestFailure"), ResultState.Failure, 1 };
-				yield return new object[] { Method("VoidTestError"), ResultState.Error, 0 };
-				yield return new object[] { Method("VoidTestExpectedException"), ResultState.Success, 0 };
-
-				yield return new object[] { Method("TaskTestSuccess"), ResultState.Success, 1 };
-				yield return new object[] { Method("TaskTestFailure"), ResultState.Failure, 1 };
-				yield return new object[] { Method("TaskTestError"), ResultState.Error, 0 };
-				yield return new object[] { Method("TaskTestExpectedException"), ResultState.Success, 0 };
-
-				yield return new object[] { Method("TaskTTestCaseWithResultCheckSuccess"), ResultState.Success, 0 };
-				yield return new object[] { Method("TaskTTestCaseWithResultCheckFailure"), ResultState.Failure, 0 };
-				yield return new object[] { Method("TaskTTestCaseWithResultCheckError"), ResultState.Failure, 0 };
-				yield return new object[] { Method("TaskTTestCaseWithResultCheckSuccessReturningNull"), ResultState.Success, 0 };
-				yield return new object[] { Method("TaskTTestCaseWithoutResultCheckExpectedExceptionSuccess"), ResultState.Success, 0 };
-
-				yield return new object[] { Method("NestedVoidTestSuccess"), ResultState.Success, 1 };
-				yield return new object[] { Method("NestedVoidTestFailure"), ResultState.Failure, 1 };
-				yield return new object[] { Method("NestedVoidTestError"), ResultState.Error, 0 };
-
-				yield return new object[] { Method("NestedTaskTestSuccess"), ResultState.Success, 1 };
-				yield return new object[] { Method("NestedTaskTestFailure"), ResultState.Failure, 1 };
-				yield return new object[] { Method("NestedTaskTestError"), ResultState.Error, 0 };
-
-				yield return new object[] { Method("VoidTestMultipleSuccess"), ResultState.Success, 1 };
-				yield return new object[] { Method("VoidTestMultipleFailure"), ResultState.Failure, 1 };
-				yield return new object[] { Method("VoidTestMultipleError"), ResultState.Error, 0 };
-
-				yield return new object[] { Method("TaskTestMultipleSuccess"), ResultState.Success, 1 };
-				yield return new object[] { Method("TaskTestMultipleFailure"), ResultState.Failure, 1 };
-				yield return new object[] { Method("TaskTestMultipleError"), ResultState.Error, 0 };
-			}
-		}
-
-		[Test]
-		[TestCaseSource("TestCases")]
-		public void RunTests(MethodInfo testMethod, ResultState resultState, int assertionCount)
-		{
-			var method = _builder.BuildFrom(testMethod);
-
-			var result = method.Run(new NullListener(), TestFilter.Empty);
-
-			Assert.That(result.Executed, Is.True, "Was not executed");
-			Assert.That(result.ResultState, Is.EqualTo(resultState), "Wrong result state");
-			Assert.That(result.AssertCount, Is.EqualTo(assertionCount), "Wrong assertion count");
-		}
-
-		[Test]
-		public void SynchronizationContextSwitching()
-		{
-			var context = new CustomSynchronizationContext();
-
-			SynchronizationContext.SetSynchronizationContext(context);
-
-			var method = _builder.BuildFrom(Method("VoidAssertSynchrnoizationContext"));
-
-			var result = method.Run(new NullListener(), TestFilter.Empty);
-
-			Assert.AreSame(context, SynchronizationContext.Current);
-			Assert.That(result.Executed, Is.True, "Was not executed");
-			Assert.That(result.ResultState, Is.EqualTo(ResultState.Success), "Wrong result state");
-			Assert.That(result.AssertCount, Is.EqualTo(1), "Wrong assertion count");
-		}
-
-		private static MethodInfo Method(string name)
-		{
-			return typeof (AsyncRealFixture).GetMethod(name);
-		}
-
-		public class CustomSynchronizationContext : SynchronizationContext
-		{
-		}
-	}
-}
+#if NET_3_5 || NET_4_0 || NET_4_5
+using System;
+using System.Collections;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Threading;
+using NUnit.Core;
+using NUnit.Core.Builders;
+using NUnit.Framework;
+using test_assembly_net45;
+
+namespace nunit.core.tests.net45
+{
+	[TestFixture]
+	public class NUnitAsyncTestMethodTests
+	{
+		private NUnitTestCaseBuilder _builder;
+
+		[SetUp]
+		public void Setup()
+		{
+			_builder = new NUnitTestCaseBuilder();
+		}
+
+		public IEnumerable TestCases
+		{
+			get
+			{
+				yield return new object[] { Method(f => f.VoidTestSuccess()), ResultState.Success, 1 };
+				yield return new object[] { Method(f => f.VoidTestFailure()), ResultState.Failure, 1 };
+				yield return new object[] { Method(f => f.VoidTestError()), ResultState.Error, 0 };
+				yield return new object[] { Method(f => f.VoidTestExpectedException()), ResultState.Success, 0 };
+
+				yield return new object[] { Method(f => f.TaskTestSuccess()), ResultState.Success, 1 };
+				yield return new object[] { Method(f => f.TaskTestFailure()), ResultState.Failure, 1 };
+				yield return new object[] { Method(f => f.TaskTestError()), ResultState.Error, 0 };
+				yield return new object[] { Method(f => f.TaskTestExpectedException()), ResultState.Success, 0 };
+
+				yield return new object[] { Method(f => f.TaskTTestCaseWithResultCheckSuccess()), ResultState.Success, 0 };
+				yield return new object[] { Method(f => f.TaskTTestCaseWithResultCheckFailure()), ResultState.Failure, 0 };
+				yield return new object[] { Method(f => f.TaskTTestCaseWithResultCheckError()), ResultState.Failure, 0 };
+				yield return new object[] { Method(f => f.TaskTTestCaseWithResultCheckSuccessReturningNull()), ResultState.Success, 0 };
+				yield return new object[] { Method(f => f.TaskTTestCaseWithoutResultCheckExpectedExceptionSuccess()), ResultState.Success, 0 };
+
+				yield return new object[] { Method(f => f.NestedVoidTestSuccess()), ResultState.Success, 1 };
+				yield return new object[] { Method(f => f.NestedVoidTestFailure()), ResultState.Failure, 1 };
+				yield return new object[] { Method(f => f.NestedVoidTestError()), ResultState.Error, 0 };
+
+				yield return new object[] { Method(f => f.NestedTaskTestSuccess()), ResultState.Success, 1 };
+				yield return new object[] { Method(f => f.NestedTaskTestFailure()), ResultState.Failure, 1 };
+				yield return new object[] { Method(f => f.NestedTaskTestError()), ResultState.Error, 0 };
+
+				yield return new object[] { Method(f => f.VoidTestMultipleSuccess()), ResultState.Success, 1 };
+				yield return new object[] { Method(f => f.VoidTestMultipleFailure()), ResultState.Failure, 1 };
+				yield return new object[] { Method(f => f.VoidTestMultipleError()), ResultState.Error, 0 };
+
+				yield return new object[] { Method(f => f.TaskTestMultipleSuccess()), ResultState.Success, 1 };
+				yield return new object[] { Method(f => f.TaskTestMultipleFailure()), ResultState.Failure, 1 };
+				yield return new object[] { Method(f => f.TaskTestMultipleError()), ResultState.Error, 0 };
+
+				yield return new object[] { Method(f => f.VoidCheckTestContextAcrossTasks()), ResultState.Success, 2 };
+				yield return new object[] { Method(f => f.VoidCheckTestContextWithinTestBody()), ResultState.Success, 2 };
+				yield return new object[] { Method(f => f.TaskCheckTestContextAcrossTasks()), ResultState.Success, 2 };
+				yield return new object[] { Method(f => f.TaskCheckTestContextWithinTestBody()), ResultState.Success, 2 };
+			}
+		}
+
+		[Test]
+		[TestCaseSource("TestCases")]
+		public void RunTests(MethodInfo testMethod, ResultState resultState, int assertionCount)
+		{
+			var method = _builder.BuildFrom(testMethod);
+
+			var result = method.Run(new NullListener(), TestFilter.Empty);
+
+			Assert.That(result.Executed, Is.True, "Was not executed");
+			Assert.That(result.ResultState, Is.EqualTo(resultState), "Wrong result state");
+			Assert.That(result.AssertCount, Is.EqualTo(assertionCount), "Wrong assertion count");
+		}
+
+		[Test]
+		public void SynchronizationContextSwitching()
+		{
+			var context = new CustomSynchronizationContext();
+
+			SynchronizationContext.SetSynchronizationContext(context);
+
+			var method = _builder.BuildFrom(Method(f => f.VoidAssertSynchronizationContext()));
+
+			var result = method.Run(new NullListener(), TestFilter.Empty);
+
+			Assert.AreSame(context, SynchronizationContext.Current);
+			Assert.That(result.Executed, Is.True, "Was not executed");
+			Assert.That(result.ResultState, Is.EqualTo(ResultState.Success), "Wrong result state");
+			Assert.That(result.AssertCount, Is.EqualTo(1), "Wrong assertion count");
+		}
+
+		private static MethodInfo Method(Expression<Action<AsyncRealFixture>> action)
+		{
+			return ((MethodCallExpression)action.Body).Method;
+		}
+
+		public class CustomSynchronizationContext : SynchronizationContext
+		{
+		}
+	}
+}
 #endif
\ No newline at end of file

=== modified file 'src/NUnitCore/tests-net45/NUnitTestCaseBuilderTests.cs'
--- src/NUnitCore/tests-net45/NUnitTestCaseBuilderTests.cs	2012-10-08 22:03:22 +0000
+++ src/NUnitCore/tests-net45/NUnitTestCaseBuilderTests.cs	2012-10-14 11:24:24 +0000
@@ -1,91 +1,93 @@
-#if NET_3_5 || NET_4_0 || NET_4_5
-using System.Collections;
-using System.Reflection;
-using NUnit.Core;
-using NUnit.Core.Builders;
-using NUnit.Framework;
-using test_assembly_net45;
-
-namespace nunit.core.tests.net45
-{
-	[TestFixture]
-	public class NUnitTestCaseBuilderTests
-	{
-		private NUnitTestCaseBuilder _sut;
-
-		[SetUp]
-		public void Setup()
-		{
-			_sut = new NUnitTestCaseBuilder();
-		}
-
-		public IEnumerable AsyncTestsSource
-		{
-			get
-			{
-				yield return new object[] { Method("AsyncVoidTest"), RunState.Runnable };
-				yield return new object[] { Method("AsyncTaskTest"), RunState.Runnable };
-				yield return new object[] { Method("AsyncTaskTTest"), RunState.NotRunnable };
-			}
-		}
-
-		public IEnumerable AsyncTestCasesSource
-		{
-			get
-			{
-				yield return new object[] { Method("AsyncVoidTestCaseWithResultCheck"), RunState.NotRunnable };
-				yield return new object[] { Method("AsyncTaskTestCaseWithResultCheck"), RunState.NotRunnable };
-				yield return new object[] { Method("AsyncTaskTTestCaseWithResultCheck"), RunState.Runnable };
-				yield return new object[] { Method("AsyncVoidTestCaseWithoutResultCheck"), RunState.Runnable };
-				yield return new object[] { Method("AsyncTaskTestCaseWithoutResultCheck"), RunState.Runnable };
-				yield return new object[] { Method("AsyncTaskTTestCaseWithoutResultCheck"), RunState.NotRunnable };
-				yield return new object[] { Method("AsyncTaskTTestCaseExpectedExceptionWithoutResultCheck"), RunState.Runnable };
-			}
-		}
-
-		[TestCaseSource("AsyncTestsSource")]
-		public void AsyncTests(MethodInfo method, RunState state)
-		{
-			var built = _sut.BuildFrom(method);
-
-			Assert.That(built, Is.InstanceOf<NUnitAsyncTestMethod>());
-			Assert.That(built.RunState, Is.EqualTo(state));
-		}
-
-		[TestCaseSource("AsyncTestCasesSource")]
-		public void AsyncTestCases(MethodInfo method, RunState state)
-		{
-			var built = _sut.BuildFrom(method);
-
-			var testMethod = built.Tests[0] as NUnitAsyncTestMethod;
-
-			Assert.IsNotNull(testMethod);
-
-			Assert.That(testMethod.RunState, Is.EqualTo(state));
-		}
-
-		[Test]
-		public void Non_async_task()
-		{
-			var built = _sut.BuildFrom(Method("NonAsyncTask"));
-
-			Assert.That(built, Is.Not.InstanceOf<NUnitAsyncTestMethod>());
-			Assert.That(built.RunState, Is.EqualTo(RunState.NotRunnable));
-		}
-
-		[Test]
-		public void Non_async_task_with_result()
-		{
-			var built = _sut.BuildFrom(Method("NonAsyncTaskWithResult"));
-
-			Assert.That(built, Is.Not.InstanceOf<NUnitAsyncTestMethod>());
-			Assert.That(built.RunState, Is.EqualTo(RunState.NotRunnable));
-		}
-
-		public MethodInfo Method(string name)
-		{
-			return typeof (AsyncDummyFixture).GetMethod(name);
-		}
-	}
-}
+#if NET_3_5 || NET_4_0 || NET_4_5
+using System;
+using System.Collections;
+using System.Linq.Expressions;
+using System.Reflection;
+using NUnit.Core;
+using NUnit.Core.Builders;
+using NUnit.Framework;
+using test_assembly_net45;
+
+namespace nunit.core.tests.net45
+{
+	[TestFixture]
+	public class NUnitTestCaseBuilderTests
+	{
+		private NUnitTestCaseBuilder _sut;
+
+		[SetUp]
+		public void Setup()
+		{
+			_sut = new NUnitTestCaseBuilder();
+		}
+
+		public IEnumerable AsyncTestsSource
+		{
+			get
+			{
+				yield return new object[] { Method(f => f.AsyncVoidTest()), RunState.Runnable };
+				yield return new object[] { Method(f => f.AsyncTaskTest()), RunState.Runnable };
+				yield return new object[] { Method(f => f.AsyncTaskTTest()), RunState.NotRunnable };
+			}
+		}
+
+		public IEnumerable AsyncTestCasesSource
+		{
+			get
+			{
+				yield return new object[] { Method(f => f.AsyncVoidTestCaseWithResultCheck()), RunState.NotRunnable };
+				yield return new object[] { Method(f => f.AsyncTaskTestCaseWithResultCheck()), RunState.NotRunnable };
+				yield return new object[] { Method(f => f.AsyncTaskTTestCaseWithResultCheck()), RunState.Runnable };
+				yield return new object[] { Method(f => f.AsyncVoidTestCaseWithoutResultCheck()), RunState.Runnable };
+				yield return new object[] { Method(f => f.AsyncTaskTestCaseWithoutResultCheck()), RunState.Runnable };
+				yield return new object[] { Method(f => f.AsyncTaskTTestCaseWithoutResultCheck()), RunState.NotRunnable };
+				yield return new object[] { Method(f => f.AsyncTaskTTestCaseExpectedExceptionWithoutResultCheck()), RunState.Runnable };
+			}
+		}
+
+		[TestCaseSource("AsyncTestsSource")]
+		public void AsyncTests(MethodInfo method, RunState state)
+		{
+			var built = _sut.BuildFrom(method);
+
+			Assert.That(built, Is.InstanceOf<NUnitAsyncTestMethod>());
+			Assert.That(built.RunState, Is.EqualTo(state));
+		}
+
+		[TestCaseSource("AsyncTestCasesSource")]
+		public void AsyncTestCases(MethodInfo method, RunState state)
+		{
+			var built = _sut.BuildFrom(method);
+
+			var testMethod = built.Tests[0] as NUnitAsyncTestMethod;
+
+			Assert.IsNotNull(testMethod);
+
+			Assert.That(testMethod.RunState, Is.EqualTo(state));
+		}
+
+		[Test]
+		public void Non_async_task()
+		{
+			var built = _sut.BuildFrom(Method(f => f.NonAsyncTask()));
+
+			Assert.That(built, Is.Not.InstanceOf<NUnitAsyncTestMethod>());
+			Assert.That(built.RunState, Is.EqualTo(RunState.NotRunnable));
+		}
+
+		[Test]
+		public void Non_async_task_with_result()
+		{
+			var built = _sut.BuildFrom(Method(f => f.NonAsyncTaskWithResult()));
+
+			Assert.That(built, Is.Not.InstanceOf<NUnitAsyncTestMethod>());
+			Assert.That(built.RunState, Is.EqualTo(RunState.NotRunnable));
+		}
+
+		private static MethodInfo Method(Expression<Action<AsyncDummyFixture>> action)
+		{
+			return ((MethodCallExpression) action.Body).Method;
+		}
+	}
+}
 #endif
\ No newline at end of file

=== modified file 'src/NUnitCore/tests/CallContextTests.cs'
--- src/NUnitCore/tests/CallContextTests.cs	2009-04-18 20:57:20 +0000
+++ src/NUnitCore/tests/CallContextTests.cs	2012-10-14 11:24:24 +0000
@@ -41,13 +41,13 @@
 		[Test]
 		public void ILogicalThreadAffinativeTest()
 		{	
-			CallContext.SetData( CONTEXT_DATA, new EmptyCallContextData() );
+			CallContext.LogicalSetData( CONTEXT_DATA, new EmptyCallContextData() );
 		}
 
 		[Test]
 		public void ILogicalThreadAffinativeTestConsole()
 		{	
-			CallContext.SetData( CONTEXT_DATA, new EmptyCallContextData() );
+			CallContext.LogicalSetData( CONTEXT_DATA, new EmptyCallContextData() );
 			// TODO: make this Assertable
 			//Console.WriteLine("ILogicalThreadAffinativeTest");
 			Console.Out.Flush();
@@ -60,7 +60,7 @@
 			GenericPrincipal prpal = new GenericPrincipal(ident, 
 				new string[] {"Level1"});
 
-			CallContext.SetData( CONTEXT_DATA, new PrincipalCallContextData( prpal ) );
+			CallContext.LogicalSetData( CONTEXT_DATA, new PrincipalCallContextData( prpal ) );
 		}
 
 		[Test]

=== modified file 'src/NUnitCore/tests/TestContextTests.cs'
--- src/NUnitCore/tests/TestContextTests.cs	2012-09-25 16:39:42 +0000
+++ src/NUnitCore/tests/TestContextTests.cs	2012-10-14 11:24:24 +0000
@@ -5,7 +5,8 @@
 // ****************************************************************
 
 using System;
-using System.IO;
+using System.IO;
+using System.Threading;
 using NUnit.Framework;
 using NUnit.TestData.TestContextData;
 using NUnit.TestUtilities;
@@ -232,9 +233,27 @@
         }	
 
 	    [Test, RequiresThread]
-        public void CanAccessTestContextOnSeparateThread()
-        {
-            Assert.That(TestContext.CurrentContext.Test.Name, Is.EqualTo("CanAccessTestContextOnSeparateThread"));
-        }
+        public void CanAccessTestContextWhenRunningTestOnSeparateThread()
+        {
+			Assert.That(TestContext.CurrentContext.Test.Name, Is.EqualTo("CanAccessTestContextWhenRunningTestOnSeparateThread"));
+        }
+
+		[Test]
+		public void CanAccessTestContextFromThreadSpawnWithinTest()
+		{
+			var testName = new object[1];
+
+			var thread = new Thread(FillTestNameFromContext);
+			thread.Start(testName);
+			thread.Join();
+
+			Assert.IsNotNull(testName[0]);
+			Assert.AreEqual(testName[0], TestContext.CurrentContext.Test.Name);
+		}
+
+		private static void FillTestNameFromContext(object arg)
+		{
+			((object[])arg)[0] = TestContext.CurrentContext.Test.Name;
+		}
 	}
-}
+}
\ No newline at end of file

=== modified file 'src/NUnitFramework/framework/TestContext.cs'
--- src/NUnitFramework/framework/TestContext.cs	2011-10-28 17:02:11 +0000
+++ src/NUnitFramework/framework/TestContext.cs	2012-10-14 11:24:24 +0000
@@ -47,7 +47,7 @@
         {
             get
             {
-                return new TestContext((IDictionary)CallContext.GetData(contextKey));
+                return new TestContext((IDictionary)CallContext.LogicalGetData(contextKey));
             }
         }
 

=== modified file 'src/tests/test-assembly-net45/AsyncRealFixture.cs'
--- src/tests/test-assembly-net45/AsyncRealFixture.cs	2012-10-08 22:03:22 +0000
+++ src/tests/test-assembly-net45/AsyncRealFixture.cs	2012-10-14 11:24:24 +0000
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Core;
@@ -101,7 +101,7 @@
 		}
 
 		[Test]
-		public async void VoidAssertSynchrnoizationContext()
+		public async void VoidAssertSynchronizationContext()
 		{
 			Assert.That(SynchronizationContext.Current, Is.InstanceOf<AsyncSynchronizationContext>());
 			await Task.Yield();
@@ -174,7 +174,7 @@
 		[Test]
 		public async void VoidTestMultipleError()
 		{
-			var result = await ReturnOne();
+			await ReturnOne();
 			await ThrowException();
 
 			Assert.Fail("Should never get here");
@@ -199,12 +199,57 @@
 		[Test]
 		public async Task TaskTestMultipleError()
 		{
-			var result = await ReturnOne();
+			await ReturnOne();
 			await ThrowException();
 
 			Assert.Fail("Should never get here");
 		}
 
+		[Test]
+		public async void VoidCheckTestContextAcrossTasks()
+		{
+			var testName = await GetTestNameFromContext();
+
+			Assert.IsNotNull(testName);
+			Assert.AreEqual(testName, TestContext.CurrentContext.Test.Name);
+		}
+
+		[Test]
+		public async Task TaskCheckTestContextAcrossTasks()
+		{
+			var testName = await GetTestNameFromContext();
+
+			Assert.IsNotNull(testName);
+			Assert.AreEqual(testName, TestContext.CurrentContext.Test.Name);
+		}
+
+		[Test]
+		public async void VoidCheckTestContextWithinTestBody()
+		{
+			var testName = TestContext.CurrentContext.Test.Name;
+
+			await ReturnOne();
+
+			Assert.IsNotNull(testName);
+			Assert.AreEqual(testName, TestContext.CurrentContext.Test.Name);
+		}
+
+		[Test]
+		public async Task TaskCheckTestContextWithinTestBody()
+		{
+			var testName = TestContext.CurrentContext.Test.Name;
+
+			await ReturnOne();
+
+			Assert.IsNotNull(testName);
+			Assert.AreEqual(testName, TestContext.CurrentContext.Test.Name);
+		}
+
+		private static Task<string> GetTestNameFromContext()
+		{
+			return Task.Run(() => TestContext.CurrentContext.Test.Name);
+		}
+
 		private static Task<int> ReturnOne()
 		{
 			return Task.Run(() => 1);