Making tests compatible with C# 6.0 generated code.

Rx.NET/Source/Tests.System.Reactive/Tests/Concurrency/SchedulerTest.cs

@@ -330,47 +330,49 @@ namespace ReactiveTests.Tests
 
             var domain = AppDomain.CreateDomain("HLN", null, new AppDomainSetup { ApplicationBase = cur });
 
-            domain.DoCallBack(() =>
-            {
-                var pep = PlatformEnlightenmentProvider.Current;
+            domain.DoCallBack(Scheduler_Periodic_HostLifecycleManagement_Callback);
+        }
 
-                try
-                {
-                    var hln = new HLN();
-                    PlatformEnlightenmentProvider.Current = new PEP(hln);
+        private static void Scheduler_Periodic_HostLifecycleManagement_Callback()
+        {
+            var pep = PlatformEnlightenmentProvider.Current;
 
-                    var s = ThreadPoolScheduler.Instance.DisableOptimizations(typeof(ISchedulerPeriodic));
+            try
+            {
+                var hln = new HLN();
+                PlatformEnlightenmentProvider.Current = new PEP(hln);
 
-                    var n = 0;
-                    var e = new ManualResetEvent(false);
+                var s = ThreadPoolScheduler.Instance.DisableOptimizations(typeof(ISchedulerPeriodic));
 
-                    var d = Observable.Interval(TimeSpan.FromMilliseconds(100), s).Subscribe(_ =>
-                    {
-                        if (n++ == 10)
-                            e.Set();
-                    });
+                var n = 0;
+                var e = new ManualResetEvent(false);
 
-                    hln.OnSuspending();
-                    hln.OnResuming();
+                var d = Observable.Interval(TimeSpan.FromMilliseconds(100), s).Subscribe(_ =>
+                {
+                    if (n++ == 10)
+                        e.Set();
+                });
 
-                    Thread.Sleep(250);
-                    hln.OnSuspending();
+                hln.OnSuspending();
+                hln.OnResuming();
 
-                    Thread.Sleep(150);
-                    hln.OnResuming();
+                Thread.Sleep(250);
+                hln.OnSuspending();
 
-                    Thread.Sleep(50);
-                    hln.OnSuspending();
-                    hln.OnResuming();
+                Thread.Sleep(150);
+                hln.OnResuming();
 
-                    e.WaitOne();
-                    d.Dispose();
-                }
-                finally
-                {
-                    PlatformEnlightenmentProvider.Current = pep;
-                }
-            });
+                Thread.Sleep(50);
+                hln.OnSuspending();
+                hln.OnResuming();
+
+                e.WaitOne();
+                d.Dispose();
+            }
+            finally
+            {
+                PlatformEnlightenmentProvider.Current = pep;
+            }
         }
 
         class PEP : IPlatformEnlightenmentProvider

Rx.NET/Source/Tests.System.Reactive/Tests/DefaultConcurrencyAbstractionLayerTest.cs

@@ -103,13 +103,15 @@ namespace ReactiveTests.Tests
         [TestMethod]
         public void StartTimer_Cancel()
         {
-            Run(() =>
+            Run(StartTimer_Cancel_Callback);
+        }
+
+        private static void StartTimer_Cancel_Callback()
+        {
+            Scheduler.Default.Schedule(TimeSpan.FromSeconds(60), () =>
             {
-                Scheduler.Default.Schedule(TimeSpan.FromSeconds(60), () =>
-                {
-                    throw new InvalidOperationException("This shouldn't have happened!");
-                }).Dispose();
-            });
+                throw new InvalidOperationException("This shouldn't have happened!");
+            }).Dispose();
         }
 
         [TestMethod]
@@ -137,13 +139,15 @@ namespace ReactiveTests.Tests
         [TestMethod]
         public void StartPeriodicTimer_Cancel()
         {
-            Run(() =>
+            Run(StartPeriodicTimer_Cancel_Callback);
+        }
+
+        private static void StartPeriodicTimer_Cancel_Callback()
+        {
+            Scheduler.Default.SchedulePeriodic(TimeSpan.FromSeconds(60), () =>
             {
-                Scheduler.Default.SchedulePeriodic(TimeSpan.FromSeconds(60), () =>
-                {
-                    throw new InvalidOperationException("This shouldn't have happened!");
-                }).Dispose();
-            });
+                throw new InvalidOperationException("This shouldn't have happened!");
+            }).Dispose();
         }
 
         [TestMethod]
@@ -177,7 +181,7 @@ namespace ReactiveTests.Tests
             Run(() =>
             {
                 var n = 0;
-                
+
                 var schedule = Scheduler.Default.SchedulePeriodic(TimeSpan.Zero, () =>
                 {
                     _domain.SetData("value", n++);
@@ -195,17 +199,17 @@ namespace ReactiveTests.Tests
 
             var cancel = (MarshalByRefAction)_domain.GetData("cancel");
             cancel.Invoke();
-            
+
             Thread.Sleep(TimeSpan.FromMilliseconds(50));
-            
+
             var newValue = (int)_domain.GetData("value");
-            
+
             Assert.IsTrue(newValue >= value);
 
             Thread.Sleep(TimeSpan.FromMilliseconds(50));
 
             value = (int)_domain.GetData("value");
-            
+
             Assert.AreEqual(newValue, value);
         }
 

Rx.NET/Source/Tests.System.Reactive/Tests/SystemClockTest.cs

@@ -34,841 +34,873 @@ namespace ReactiveTests.Tests
         [TestMethod]
         public void PastWork()
         {
-            Run(() =>
-            {
-                var provider = new MyPlatformEnlightenmentProvider();
-                PlatformEnlightenmentProvider.Current = provider;
+            Run(PastWork_Callback);
+        }
+
+        private static void PastWork_Callback()
+        {
+            var provider = new MyPlatformEnlightenmentProvider();
+            PlatformEnlightenmentProvider.Current = provider;
 
-                var cal = provider._cal;
-                var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
-                var due = now - TimeSpan.FromMinutes(1);
+            var cal = provider._cal;
+            var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
+            var due = now - TimeSpan.FromMinutes(1);
 
-                var s = new MyScheduler();
-                s.SetTime(now);
+            var s = new MyScheduler();
+            s.SetTime(now);
 
-                var done = false;
-                s.Schedule(due, () => { done = true; });
+            var done = false;
+            s.Schedule(due, () => { done = true; });
 
-                Assert.AreEqual(1, s._queue.Count);
+            Assert.AreEqual(1, s._queue.Count);
 
-                var next = s._queue.Deq();
-                Assert.IsTrue(s.Now + next.DueTime == now);
+            var next = s._queue.Deq();
+            Assert.IsTrue(s.Now + next.DueTime == now);
 
-                s.SetTime(due);
-                next.Invoke();
+            s.SetTime(due);
+            next.Invoke();
 
-                Assert.IsTrue(done);
-            });
+            Assert.IsTrue(done);
         }
 
         [TestMethod]
         public void ImmediateWork()
         {
-            Run(() =>
-            {
-                var provider = new MyPlatformEnlightenmentProvider();
-                PlatformEnlightenmentProvider.Current = provider;
+            Run(ImmediateWork_Callback);
+        }
 
-                var cal = provider._cal;
-                var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
-                var due = now;
+        private static void ImmediateWork_Callback()
+        {
+            var provider = new MyPlatformEnlightenmentProvider();
+            PlatformEnlightenmentProvider.Current = provider;
 
-                var s = new MyScheduler();
-                s.SetTime(now);
+            var cal = provider._cal;
+            var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
+            var due = now;
 
-                var done = false;
-                s.Schedule(due, () => { done = true; });
+            var s = new MyScheduler();
+            s.SetTime(now);
 
-                Assert.AreEqual(1, s._queue.Count);
+            var done = false;
+            s.Schedule(due, () => { done = true; });
 
-                var next = s._queue.Deq();
-                Assert.IsTrue(s.Now + next.DueTime == due);
+            Assert.AreEqual(1, s._queue.Count);
 
-                s.SetTime(due);
-                next.Invoke();
+            var next = s._queue.Deq();
+            Assert.IsTrue(s.Now + next.DueTime == due);
 
-                Assert.IsTrue(done);
-            });
+            s.SetTime(due);
+            next.Invoke();
+
+            Assert.IsTrue(done);
         }
 
         [TestMethod]
         public void ShortTermWork()
         {
-            Run(() =>
-            {
-                var provider = new MyPlatformEnlightenmentProvider();
-                PlatformEnlightenmentProvider.Current = provider;
+            Run(ShortTermWork_Callback);
+        }
 
-                var cal = provider._cal;
-                var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
-                var rel = TimeSpan.FromSeconds(1) /* rel <= SHORTTERM */;
-                var due = now + rel;
+        private static void ShortTermWork_Callback()
+        {
+            var provider = new MyPlatformEnlightenmentProvider();
+            PlatformEnlightenmentProvider.Current = provider;
 
-                var s = new MyScheduler();
-                s.SetTime(now);
+            var cal = provider._cal;
+            var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
+            var rel = TimeSpan.FromSeconds(1) /* rel <= SHORTTERM */;
+            var due = now + rel;
 
-                var done = false;
-                s.Schedule(due, () => { done = true; });
+            var s = new MyScheduler();
+            s.SetTime(now);
 
-                Assert.AreEqual(1, s._queue.Count);
+            var done = false;
+            s.Schedule(due, () => { done = true; });
 
-                var next = s._queue.Deq();
-                Assert.IsTrue(s.Now + next.DueTime == due);
+            Assert.AreEqual(1, s._queue.Count);
 
-                s.SetTime(due);
-                next.Invoke();
+            var next = s._queue.Deq();
+            Assert.IsTrue(s.Now + next.DueTime == due);
 
-                Assert.IsTrue(done);
-            });
+            s.SetTime(due);
+            next.Invoke();
+
+            Assert.IsTrue(done);
         }
 
         [TestMethod]
         public void ShortTermWork_Dispose()
         {
-            Run(() =>
-            {
-                var provider = new MyPlatformEnlightenmentProvider();
-                PlatformEnlightenmentProvider.Current = provider;
+            Run(ShortTermWork_Dispose_Callback);
+        }
 
-                var cal = provider._cal;
-                var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
-                var rel = TimeSpan.FromSeconds(1) /* rel <= SHORTTERM */;
-                var due = now + rel;
+        private static void ShortTermWork_Dispose_Callback()
+        {
+            var provider = new MyPlatformEnlightenmentProvider();
+            PlatformEnlightenmentProvider.Current = provider;
 
-                var s = new MyScheduler();
-                s.SetTime(now);
+            var cal = provider._cal;
+            var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
+            var rel = TimeSpan.FromSeconds(1) /* rel <= SHORTTERM */;
+            var due = now + rel;
 
-                var done = false;
-                var d = s.Schedule(due, () => { done = true; });
+            var s = new MyScheduler();
+            s.SetTime(now);
 
-                Assert.AreEqual(1, s._queue.Count);
+            var done = false;
+            var d = s.Schedule(due, () => { done = true; });
 
-                var next = s._queue.Deq();
-                Assert.IsTrue(s.Now + next.DueTime == due);
+            Assert.AreEqual(1, s._queue.Count);
 
-                d.Dispose();
+            var next = s._queue.Deq();
+            Assert.IsTrue(s.Now + next.DueTime == due);
 
-                s.SetTime(due);
-                next.Invoke();
+            d.Dispose();
 
-                Assert.IsFalse(done);
-            });
+            s.SetTime(due);
+            next.Invoke();
+
+            Assert.IsFalse(done);
         }
 
         [TestMethod]
         public void ShortTermWork_InaccurateClock()
         {
-            Run(() =>
-            {
-                var provider = new MyPlatformEnlightenmentProvider();
-                PlatformEnlightenmentProvider.Current = provider;
+            Run(ShortTermWork_InaccurateClock_Callback);
+        }
 
-                var cal = provider._cal;
-                var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
-                var rel = TimeSpan.FromSeconds(1);
-                var due = now + rel;
+        private static void ShortTermWork_InaccurateClock_Callback()
+        {
+            var provider = new MyPlatformEnlightenmentProvider();
+            PlatformEnlightenmentProvider.Current = provider;
 
-                var s = new MyScheduler();
-                s.SetTime(now);
+            var cal = provider._cal;
+            var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
+            var rel = TimeSpan.FromSeconds(1);
+            var due = now + rel;
 
-                var done = false;
-                s.Schedule(due, () => { done = true; });
+            var s = new MyScheduler();
+            s.SetTime(now);
 
-                Assert.AreEqual(1, s._queue.Count);
+            var done = false;
+            s.Schedule(due, () => { done = true; });
 
-                var nxt1 = s._queue.Deq();
-                Assert.IsTrue(s.Now + nxt1.DueTime == due);
+            Assert.AreEqual(1, s._queue.Count);
 
-                s.SetTime(due - TimeSpan.FromMilliseconds(500) /* > RETRYSHORT */);
-                nxt1.Invoke();
+            var nxt1 = s._queue.Deq();
+            Assert.IsTrue(s.Now + nxt1.DueTime == due);
 
-                Assert.AreEqual(1, s._queue.Count);
+            s.SetTime(due - TimeSpan.FromMilliseconds(500) /* > RETRYSHORT */);
+            nxt1.Invoke();
 
-                var nxt2 = s._queue.Deq();
-                Assert.IsTrue(s.Now + nxt2.DueTime == due);
+            Assert.AreEqual(1, s._queue.Count);
 
-                s.SetTime(due);
-                nxt2.Invoke();
+            var nxt2 = s._queue.Deq();
+            Assert.IsTrue(s.Now + nxt2.DueTime == due);
 
-                Assert.IsTrue(done);
-            });
+            s.SetTime(due);
+            nxt2.Invoke();
+
+            Assert.IsTrue(done);
         }
 
         [TestMethod]
         public void LongTermWork1()
         {
-            Run(() =>
-            {
-                var provider = new MyPlatformEnlightenmentProvider();
-                PlatformEnlightenmentProvider.Current = provider;
+            Run(LongTermWork1_Callback);
+        }
 
-                var cal = provider._cal;
-                var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
-                var rel = TimeSpan.FromMinutes(1) /* rel > SHORTTERM */;
-                var due = now + rel;
+        private static void LongTermWork1_Callback()
+        {
+            var provider = new MyPlatformEnlightenmentProvider();
+            PlatformEnlightenmentProvider.Current = provider;
 
-                var s = new MyScheduler();
-                s.SetTime(now);
+            var cal = provider._cal;
+            var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
+            var rel = TimeSpan.FromMinutes(1) /* rel > SHORTTERM */;
+            var due = now + rel;
 
-                var done = false;
-                s.Schedule(due, () => { done = true; });
+            var s = new MyScheduler();
+            s.SetTime(now);
 
-                Assert.AreEqual(1, cal._queue.Count);
+            var done = false;
+            s.Schedule(due, () => { done = true; });
 
-                var work = cal._queue.Deq();
-                Assert.IsTrue(work.Interval < rel);
+            Assert.AreEqual(1, cal._queue.Count);
 
-                s.SetTime(s.Now + work.Interval);
-                work.Value._action(work.Value._state);
+            var work = cal._queue.Deq();
+            Assert.IsTrue(work.Interval < rel);
 
-                Assert.AreEqual(1, s._queue.Count);
+            s.SetTime(s.Now + work.Interval);
+            work.Value._action(work.Value._state);
 
-                var next = s._queue.Deq();
-                Assert.IsTrue(s.Now + next.DueTime == due);
+            Assert.AreEqual(1, s._queue.Count);
 
-                s.SetTime(due);
-                next.Invoke();
+            var next = s._queue.Deq();
+            Assert.IsTrue(s.Now + next.DueTime == due);
 
-                Assert.IsTrue(done);
-            });
+            s.SetTime(due);
+            next.Invoke();
+
+            Assert.IsTrue(done);
         }
 
         [TestMethod]
         public void LongTermWork2()
         {
-            Run(() =>
-            {
-                var provider = new MyPlatformEnlightenmentProvider();
-                PlatformEnlightenmentProvider.Current = provider;
+            Run(LongTermWork2_Callback);
+        }
+
+        private static void LongTermWork2_Callback()
+        {
+            var provider = new MyPlatformEnlightenmentProvider();
+            PlatformEnlightenmentProvider.Current = provider;
 
-                var cal = provider._cal;
-                var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
-                var rel = TimeSpan.FromDays(1) /* rel > SHORTTERM and rel * MAXERRORRATIO > SHORTTERM */;
-                var due = now + rel;
+            var cal = provider._cal;
+            var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
+            var rel = TimeSpan.FromDays(1) /* rel > SHORTTERM and rel * MAXERRORRATIO > SHORTTERM */;
+            var due = now + rel;
 
-                var s = new MyScheduler();
-                s.SetTime(now);
+            var s = new MyScheduler();
+            s.SetTime(now);
 
-                var done = false;
-                s.Schedule(due, () => { done = true; });
+            var done = false;
+            s.Schedule(due, () => { done = true; });
 
-                Assert.AreEqual(1, cal._queue.Count);
+            Assert.AreEqual(1, cal._queue.Count);
 
-                var wrk1 = cal._queue.Deq();
-                Assert.IsTrue(wrk1.Interval < rel);
+            var wrk1 = cal._queue.Deq();
+            Assert.IsTrue(wrk1.Interval < rel);
 
-                s.SetTime(s.Now + wrk1.Interval);
-                wrk1.Value._action(wrk1.Value._state);
+            s.SetTime(s.Now + wrk1.Interval);
+            wrk1.Value._action(wrk1.Value._state);
 
-                // Begin of second long term scheduling
-                Assert.AreEqual(1, cal._queue.Count);
+            // Begin of second long term scheduling
+            Assert.AreEqual(1, cal._queue.Count);
 
-                var wrk2 = cal._queue.Deq();
-                Assert.IsTrue(wrk2.Interval < rel);
+            var wrk2 = cal._queue.Deq();
+            Assert.IsTrue(wrk2.Interval < rel);
 
-                s.SetTime(s.Now + wrk2.Interval);
-                wrk2.Value._action(wrk2.Value._state);
-                // End of second long term scheduling
+            s.SetTime(s.Now + wrk2.Interval);
+            wrk2.Value._action(wrk2.Value._state);
+            // End of second long term scheduling
 
-                Assert.AreEqual(1, s._queue.Count);
+            Assert.AreEqual(1, s._queue.Count);
 
-                var next = s._queue.Deq();
-                Assert.IsTrue(s.Now + next.DueTime == due);
+            var next = s._queue.Deq();
+            Assert.IsTrue(s.Now + next.DueTime == due);
 
-                s.SetTime(due);
-                next.Invoke();
+            s.SetTime(due);
+            next.Invoke();
 
-                Assert.IsTrue(done);
-            });
+            Assert.IsTrue(done);
         }
 
         [TestMethod]
         public void LongTerm_Multiple()
         {
-            Run(() =>
-            {
-                var provider = new MyPlatformEnlightenmentProvider();
-                PlatformEnlightenmentProvider.Current = provider;
-
-                var cal = provider._cal;
-                var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
-
-                var s = new MyScheduler();
-                s.SetTime(now);
-
-                var due1 = now + TimeSpan.FromMinutes(10);
-                var due2 = now + TimeSpan.FromMinutes(30);
-                var due3 = now + TimeSpan.FromMinutes(60);
-
-                var done1 = false;
-                var done2 = false;
-                var done3 = false;
-
-                s.Schedule(due2, () => { done2 = true; });
-                s.Schedule(due1, () => { done1 = true; });
-                s.Schedule(due3, () => { done3 = true; });
-
-                // First CHK
-                Assert.AreEqual(1, cal._queue.Count);
-                var wrk1 = cal._queue.Deq();
-                var fst = s.Now + wrk1.Interval;
-                Assert.IsTrue(fst < due1);
-
-                // First TRN
-                s.SetTime(fst);
-                wrk1.Value._action(wrk1.Value._state);
-
-                // First SHT
-                Assert.AreEqual(1, s._queue.Count);
-                var sh1 = s._queue.Deq();
-
-                // Second CHK
-                Assert.AreEqual(1, cal._queue.Count);
-                var wrk2 = cal._queue.Deq();
-                var snd = s.Now + wrk2.Interval;
-                Assert.IsTrue(snd < due2);
-
-                // First RUN
-                s.SetTime(due1);
-                sh1.Invoke();
-                Assert.IsTrue(done1);
-
-                // Second TRN
-                s.SetTime(snd);
-                wrk2.Value._action(wrk2.Value._state);
-
-                // Second SHT
-                Assert.AreEqual(1, s._queue.Count);
-                var sh2 = s._queue.Deq();
-
-                // Third CHK
-                Assert.AreEqual(1, cal._queue.Count);
-                var wrk3 = cal._queue.Deq();
-                var trd = s.Now + wrk3.Interval;
-                Assert.IsTrue(trd < due3);
-
-                // Second RUN
-                s.SetTime(due2);
-                sh2.Invoke();
-                Assert.IsTrue(done2);
-
-                // Third TRN
-                s.SetTime(trd);
-                wrk3.Value._action(wrk3.Value._state);
-
-                // Third SHT
-                Assert.AreEqual(1, s._queue.Count);
-                var sh3 = s._queue.Deq();
-
-                // Third RUN
-                s.SetTime(due3);
-                sh3.Invoke();
-                Assert.IsTrue(done3);
-            });
+            Run(LongTerm_Multiple_Callback);
+        }
+
+        private static void LongTerm_Multiple_Callback()
+        {
+            var provider = new MyPlatformEnlightenmentProvider();
+            PlatformEnlightenmentProvider.Current = provider;
+
+            var cal = provider._cal;
+            var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
+
+            var s = new MyScheduler();
+            s.SetTime(now);
+
+            var due1 = now + TimeSpan.FromMinutes(10);
+            var due2 = now + TimeSpan.FromMinutes(30);
+            var due3 = now + TimeSpan.FromMinutes(60);
+
+            var done1 = false;
+            var done2 = false;
+            var done3 = false;
+
+            s.Schedule(due2, () => { done2 = true; });
+            s.Schedule(due1, () => { done1 = true; });
+            s.Schedule(due3, () => { done3 = true; });
+
+            // First CHK
+            Assert.AreEqual(1, cal._queue.Count);
+            var wrk1 = cal._queue.Deq();
+            var fst = s.Now + wrk1.Interval;
+            Assert.IsTrue(fst < due1);
+
+            // First TRN
+            s.SetTime(fst);
+            wrk1.Value._action(wrk1.Value._state);
+
+            // First SHT
+            Assert.AreEqual(1, s._queue.Count);
+            var sh1 = s._queue.Deq();
+
+            // Second CHK
+            Assert.AreEqual(1, cal._queue.Count);
+            var wrk2 = cal._queue.Deq();
+            var snd = s.Now + wrk2.Interval;
+            Assert.IsTrue(snd < due2);
+
+            // First RUN
+            s.SetTime(due1);
+            sh1.Invoke();
+            Assert.IsTrue(done1);
+
+            // Second TRN
+            s.SetTime(snd);
+            wrk2.Value._action(wrk2.Value._state);
+
+            // Second SHT
+            Assert.AreEqual(1, s._queue.Count);
+            var sh2 = s._queue.Deq();
+
+            // Third CHK
+            Assert.AreEqual(1, cal._queue.Count);
+            var wrk3 = cal._queue.Deq();
+            var trd = s.Now + wrk3.Interval;
+            Assert.IsTrue(trd < due3);
+
+            // Second RUN
+            s.SetTime(due2);
+            sh2.Invoke();
+            Assert.IsTrue(done2);
+
+            // Third TRN
+            s.SetTime(trd);
+            wrk3.Value._action(wrk3.Value._state);
+
+            // Third SHT
+            Assert.AreEqual(1, s._queue.Count);
+            var sh3 = s._queue.Deq();
+
+            // Third RUN
+            s.SetTime(due3);
+            sh3.Invoke();
+            Assert.IsTrue(done3);
         }
 
         [TestMethod]
         public void LongTerm_Multiple_Dispose()
         {
-            Run(() =>
-            {
-                var provider = new MyPlatformEnlightenmentProvider();
-                PlatformEnlightenmentProvider.Current = provider;
-
-                var cal = provider._cal;
-                var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
-
-                var s = new MyScheduler();
-                s.SetTime(now);
-
-                var due1 = now + TimeSpan.FromMinutes(10);
-                var due2 = now + TimeSpan.FromMinutes(30);
-                var due3 = now + TimeSpan.FromMinutes(60);
-
-                var done1 = false;
-                var done2 = false;
-                var done3 = false;
-
-                var d2 = s.Schedule(due2, () => { done2 = true; });
-                var d1 = s.Schedule(due1, () => { done1 = true; });
-                var d3 = s.Schedule(due3, () => { done3 = true; });
-
-                // First CHK
-                Assert.AreEqual(1, cal._queue.Count);
-                var wrk1 = cal._queue.Deq();
-                var fst = s.Now + wrk1.Interval;
-                Assert.IsTrue(fst < due1);
-
-                // First TRN
-                s.SetTime(fst);
-                wrk1.Value._action(wrk1.Value._state);
-
-                // First DIS
-                d1.Dispose();
-
-                // First SHT
-                Assert.AreEqual(1, s._queue.Count);
-                var sh1 = s._queue.Deq();
-
-                // Second CHK
-                Assert.AreEqual(1, cal._queue.Count);
-                var wrk2 = cal._queue.Deq();
-                var snd = s.Now + wrk2.Interval;
-                Assert.IsTrue(snd < due2);
-
-                // First RUN
-                s.SetTime(due1);
-                sh1.Invoke();
-                Assert.IsFalse(done1);
-
-                // Second DIS
-                // Third DIS
-                d2.Dispose();
-                d3.Dispose();
-
-                // Second TRN
-                s.SetTime(snd);
-                wrk2.Value._action(wrk2.Value._state);
-
-                // Second SHT
-                Assert.AreEqual(1, s._queue.Count);
-                var sh2 = s._queue.Deq();
-
-                // Third CHK
-                Assert.AreEqual(1, cal._queue.Count);
-                var wrk3 = cal._queue.Deq();
-                var trd = s.Now + wrk3.Interval;
-                Assert.IsTrue(trd < due3);
-
-                // Second RUN
-                s.SetTime(due2);
-                sh2.Invoke();
-                Assert.IsFalse(done2);
-
-                // Third TRN
-                s.SetTime(trd);
-                wrk3.Value._action(wrk3.Value._state);
-
-                // Third SHT
-                Assert.AreEqual(1, s._queue.Count);
-                var sh3 = s._queue.Deq();
-
-                // Third RUN
-                s.SetTime(due3);
-                sh3.Invoke();
-                Assert.IsFalse(done3);
-            });
+            Run(LongTerm_Multiple_Dispose_Callback);
+        }
+
+        private static void LongTerm_Multiple_Dispose_Callback()
+        {
+            var provider = new MyPlatformEnlightenmentProvider();
+            PlatformEnlightenmentProvider.Current = provider;
+
+            var cal = provider._cal;
+            var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
+
+            var s = new MyScheduler();
+            s.SetTime(now);
+
+            var due1 = now + TimeSpan.FromMinutes(10);
+            var due2 = now + TimeSpan.FromMinutes(30);
+            var due3 = now + TimeSpan.FromMinutes(60);
+
+            var done1 = false;
+            var done2 = false;
+            var done3 = false;
+
+            var d2 = s.Schedule(due2, () => { done2 = true; });
+            var d1 = s.Schedule(due1, () => { done1 = true; });
+            var d3 = s.Schedule(due3, () => { done3 = true; });
+
+            // First CHK
+            Assert.AreEqual(1, cal._queue.Count);
+            var wrk1 = cal._queue.Deq();
+            var fst = s.Now + wrk1.Interval;
+            Assert.IsTrue(fst < due1);
+
+            // First TRN
+            s.SetTime(fst);
+            wrk1.Value._action(wrk1.Value._state);
+
+            // First DIS
+            d1.Dispose();
+
+            // First SHT
+            Assert.AreEqual(1, s._queue.Count);
+            var sh1 = s._queue.Deq();
+
+            // Second CHK
+            Assert.AreEqual(1, cal._queue.Count);
+            var wrk2 = cal._queue.Deq();
+            var snd = s.Now + wrk2.Interval;
+            Assert.IsTrue(snd < due2);
+
+            // First RUN
+            s.SetTime(due1);
+            sh1.Invoke();
+            Assert.IsFalse(done1);
+
+            // Second DIS
+            // Third DIS
+            d2.Dispose();
+            d3.Dispose();
+
+            // Second TRN
+            s.SetTime(snd);
+            wrk2.Value._action(wrk2.Value._state);
+
+            // Second SHT
+            Assert.AreEqual(1, s._queue.Count);
+            var sh2 = s._queue.Deq();
+
+            // Third CHK
+            Assert.AreEqual(1, cal._queue.Count);
+            var wrk3 = cal._queue.Deq();
+            var trd = s.Now + wrk3.Interval;
+            Assert.IsTrue(trd < due3);
+
+            // Second RUN
+            s.SetTime(due2);
+            sh2.Invoke();
+            Assert.IsFalse(done2);
+
+            // Third TRN
+            s.SetTime(trd);
+            wrk3.Value._action(wrk3.Value._state);
+
+            // Third SHT
+            Assert.AreEqual(1, s._queue.Count);
+            var sh3 = s._queue.Deq();
+
+            // Third RUN
+            s.SetTime(due3);
+            sh3.Invoke();
+            Assert.IsFalse(done3);
         }
 
         [TestMethod]
         public void ClockChanged_FalsePositive()
         {
-            Run(() =>
-            {
-                var provider = new MyPlatformEnlightenmentProvider();
-                PlatformEnlightenmentProvider.Current = provider;
+            Run(ClockChanged_FalsePositive_Callback);
+        }
 
-                var scm = (ClockChanged)provider.GetService<INotifySystemClockChanged>();
+        private static void ClockChanged_FalsePositive_Callback()
+        {
+            var provider = new MyPlatformEnlightenmentProvider();
+            PlatformEnlightenmentProvider.Current = provider;
 
-                var cal = provider._cal;
-                var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
-                var rel = TimeSpan.FromMinutes(1);
-                var due = now + rel;
+            var scm = (ClockChanged)provider.GetService<INotifySystemClockChanged>();
 
-                var s = new MyScheduler();
-                s.SetTime(now);
+            var cal = provider._cal;
+            var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
+            var rel = TimeSpan.FromMinutes(1);
+            var due = now + rel;
 
-                var done = false;
-                s.Schedule(due, () => { done = true; });
+            var s = new MyScheduler();
+            s.SetTime(now);
 
-                Assert.AreEqual(1, cal._queue.Count);
+            var done = false;
+            s.Schedule(due, () => { done = true; });
 
-                s.SetTime(now);
-                scm.OnSystemClockChanged();
+            Assert.AreEqual(1, cal._queue.Count);
 
-                var work = cal._queue.Deq();
-                Assert.IsTrue(work.Interval < rel);
+            s.SetTime(now);
+            scm.OnSystemClockChanged();
 
-                s.SetTime(s.Now + work.Interval);
-                work.Value._action(work.Value._state);
+            var work = cal._queue.Deq();
+            Assert.IsTrue(work.Interval < rel);
 
-                Assert.AreEqual(1, s._queue.Count);
+            s.SetTime(s.Now + work.Interval);
+            work.Value._action(work.Value._state);
 
-                var next = s._queue.Deq();
-                Assert.IsTrue(s.Now + next.DueTime == due);
+            Assert.AreEqual(1, s._queue.Count);
 
-                s.SetTime(due);
-                next.Invoke();
+            var next = s._queue.Deq();
+            Assert.IsTrue(s.Now + next.DueTime == due);
 
-                Assert.IsTrue(done);
-            });
+            s.SetTime(due);
+            next.Invoke();
+
+            Assert.IsTrue(done);
         }
 
         [TestMethod]
         public void ClockChanged_Forward1()
         {
-            Run(() =>
-            {
-                var provider = new MyPlatformEnlightenmentProvider();
-                PlatformEnlightenmentProvider.Current = provider;
+            Run(ClockChanged_Forward1_Callback);
+        }
 
-                var scm = (ClockChanged)provider.GetService<INotifySystemClockChanged>();
+        private static void ClockChanged_Forward1_Callback()
+        {
+            var provider = new MyPlatformEnlightenmentProvider();
+            PlatformEnlightenmentProvider.Current = provider;
 
-                var cal = provider._cal;
-                var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
-                var rel = TimeSpan.FromMinutes(1);
-                var due = now + rel;
-                var err = TimeSpan.FromMinutes(1);
+            var scm = (ClockChanged)provider.GetService<INotifySystemClockChanged>();
 
-                var s = new MyScheduler();
-                s.SetTime(now);
+            var cal = provider._cal;
+            var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
+            var rel = TimeSpan.FromMinutes(1);
+            var due = now + rel;
+            var err = TimeSpan.FromMinutes(1);
 
-                var done = false;
-                s.Schedule(due, () => { done = true; });
+            var s = new MyScheduler();
+            s.SetTime(now);
 
-                Assert.AreEqual(1, cal._queue.Count);
-                Assert.AreEqual(0, s._queue.Count);
+            var done = false;
+            s.Schedule(due, () => { done = true; });
 
-                s.SetTime(due + err);
-                scm.OnSystemClockChanged();
+            Assert.AreEqual(1, cal._queue.Count);
+            Assert.AreEqual(0, s._queue.Count);
 
-                Assert.AreEqual(1, s._queue.Count);
+            s.SetTime(due + err);
+            scm.OnSystemClockChanged();
 
-                var next = s._queue.Deq();
-                Assert.IsTrue(next.DueTime == TimeSpan.Zero);
-                next.Invoke();
-                Assert.IsTrue(done);
+            Assert.AreEqual(1, s._queue.Count);
 
-                var tmr = cal._queue.Deq();
-                tmr.Value._action(tmr.Value._state);
+            var next = s._queue.Deq();
+            Assert.IsTrue(next.DueTime == TimeSpan.Zero);
+            next.Invoke();
+            Assert.IsTrue(done);
 
-                Assert.AreEqual(0, cal._queue.Count);
-                Assert.AreEqual(0, s._queue.Count);
-            });
+            var tmr = cal._queue.Deq();
+            tmr.Value._action(tmr.Value._state);
+
+            Assert.AreEqual(0, cal._queue.Count);
+            Assert.AreEqual(0, s._queue.Count);
         }
 
         [TestMethod]
         public void ClockChanged_Forward2()
         {
-            Run(() =>
-            {
-                var provider = new MyPlatformEnlightenmentProvider();
-                PlatformEnlightenmentProvider.Current = provider;
+            Run(ClockChanged_Forward2_Callback);
+        }
+
+        private static void ClockChanged_Forward2_Callback()
+        {
+            var provider = new MyPlatformEnlightenmentProvider();
+            PlatformEnlightenmentProvider.Current = provider;
 
-                var scm = (ClockChanged)provider.GetService<INotifySystemClockChanged>();
+            var scm = (ClockChanged)provider.GetService<INotifySystemClockChanged>();
 
-                var cal = provider._cal;
-                var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
-                var rel = TimeSpan.FromSeconds(1);
-                var due = now + rel;
-                var err = TimeSpan.FromMinutes(1);
+            var cal = provider._cal;
+            var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
+            var rel = TimeSpan.FromSeconds(1);
+            var due = now + rel;
+            var err = TimeSpan.FromMinutes(1);
 
-                var s = new MyScheduler();
-                s.SetTime(now);
+            var s = new MyScheduler();
+            s.SetTime(now);
 
-                var n = 0;
-                s.Schedule(due, () => { n++; });
+            var n = 0;
+            s.Schedule(due, () => { n++; });
 
-                Assert.AreEqual(1, s._queue.Count);
+            Assert.AreEqual(1, s._queue.Count);
 
-                var wrk = s._queue.Deq();
-                Assert.IsTrue(wrk.DueTime == rel);
+            var wrk = s._queue.Deq();
+            Assert.IsTrue(wrk.DueTime == rel);
 
-                s.SetTime(due + err);
-                scm.OnSystemClockChanged();
+            s.SetTime(due + err);
+            scm.OnSystemClockChanged();
 
-                Assert.AreEqual(1, s._queue.Count);
+            Assert.AreEqual(1, s._queue.Count);
 
-                var next = s._queue.Deq();
-                Assert.IsTrue(next.DueTime == TimeSpan.Zero);
-                next.Invoke();
-                Assert.AreEqual(1, n);
+            var next = s._queue.Deq();
+            Assert.IsTrue(next.DueTime == TimeSpan.Zero);
+            next.Invoke();
+            Assert.AreEqual(1, n);
 
-                wrk.Invoke(); // Bad schedulers may not grant cancellation immediately.
-                Assert.AreEqual(1, n); // Invoke shouldn't cause double execution of the work.
-            });
+            wrk.Invoke(); // Bad schedulers may not grant cancellation immediately.
+            Assert.AreEqual(1, n); // Invoke shouldn't cause double execution of the work.
         }
 
         [TestMethod]
         public void ClockChanged_Backward1()
         {
-            Run(() =>
-            {
-                var provider = new MyPlatformEnlightenmentProvider();
-                PlatformEnlightenmentProvider.Current = provider;
+            Run(ClockChanged_Backward1_Callback);
+        }
 
-                var scm = (ClockChanged)provider.GetService<INotifySystemClockChanged>();
+        private static void ClockChanged_Backward1_Callback()
+        {
+            var provider = new MyPlatformEnlightenmentProvider();
+            PlatformEnlightenmentProvider.Current = provider;
 
-                var cal = provider._cal;
-                var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
-                var rel = TimeSpan.FromMinutes(1);
-                var due = now + rel;
-                var err = TimeSpan.FromMinutes(-2);
+            var scm = (ClockChanged)provider.GetService<INotifySystemClockChanged>();
 
-                var s = new MyScheduler();
-                s.SetTime(now);
+            var cal = provider._cal;
+            var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
+            var rel = TimeSpan.FromMinutes(1);
+            var due = now + rel;
+            var err = TimeSpan.FromMinutes(-2);
 
-                var done = false;
-                s.Schedule(due, () => { done = true; });
+            var s = new MyScheduler();
+            s.SetTime(now);
 
-                Assert.AreEqual(1, cal._queue.Count);
-                Assert.IsTrue(cal._queue[0].Interval < rel);
+            var done = false;
+            s.Schedule(due, () => { done = true; });
 
-                Assert.AreEqual(0, s._queue.Count);
+            Assert.AreEqual(1, cal._queue.Count);
+            Assert.IsTrue(cal._queue[0].Interval < rel);
 
-                s.SetTime(due + err);
-                scm.OnSystemClockChanged();
+            Assert.AreEqual(0, s._queue.Count);
 
-                Assert.AreEqual(1, cal._queue.Count);
+            s.SetTime(due + err);
+            scm.OnSystemClockChanged();
 
-                var tmr = cal._queue.Deq();
-                Assert.IsTrue(tmr.Interval > rel);
-                Assert.IsTrue(tmr.Interval < -err);
+            Assert.AreEqual(1, cal._queue.Count);
 
-                s.SetTime(s.Now + tmr.Interval);
-                tmr.Value._action(tmr.Value._state);
+            var tmr = cal._queue.Deq();
+            Assert.IsTrue(tmr.Interval > rel);
+            Assert.IsTrue(tmr.Interval < -err);
 
-                Assert.IsFalse(done);
+            s.SetTime(s.Now + tmr.Interval);
+            tmr.Value._action(tmr.Value._state);
 
-                Assert.AreEqual(0, cal._queue.Count);
-                Assert.AreEqual(1, s._queue.Count);
+            Assert.IsFalse(done);
 
-                s.SetTime(due);
-                s._queue.Deq().Invoke();
+            Assert.AreEqual(0, cal._queue.Count);
+            Assert.AreEqual(1, s._queue.Count);
 
-                Assert.IsTrue(done);
-            });
+            s.SetTime(due);
+            s._queue.Deq().Invoke();
+
+            Assert.IsTrue(done);
         }
 
         [TestMethod]
         public void ClockChanged_Backward2()
         {
-            Run(() =>
-            {
-                var provider = new MyPlatformEnlightenmentProvider();
-                PlatformEnlightenmentProvider.Current = provider;
+            Run(ClockChanged_Backward2_Callback);
+        }
 
-                var scm = (ClockChanged)provider.GetService<INotifySystemClockChanged>();
+        private static void ClockChanged_Backward2_Callback()
+        {
+            var provider = new MyPlatformEnlightenmentProvider();
+            PlatformEnlightenmentProvider.Current = provider;
 
-                var cal = provider._cal;
-                var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
-                var rel = TimeSpan.FromSeconds(1);
-                var due = now + rel;
-                var err = TimeSpan.FromMinutes(-1);
+            var scm = (ClockChanged)provider.GetService<INotifySystemClockChanged>();
 
-                var s = new MyScheduler();
-                s.SetTime(now);
+            var cal = provider._cal;
+            var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
+            var rel = TimeSpan.FromSeconds(1);
+            var due = now + rel;
+            var err = TimeSpan.FromMinutes(-1);
 
-                var n = 0;
-                s.Schedule(due, () => { n++; });
+            var s = new MyScheduler();
+            s.SetTime(now);
 
-                Assert.AreEqual(0, cal._queue.Count);
-                Assert.AreEqual(1, s._queue.Count);
-                var wrk = s._queue[0];
-                Assert.IsTrue(wrk.DueTime == rel);
+            var n = 0;
+            s.Schedule(due, () => { n++; });
 
-                s.SetTime(due + err);
-                scm.OnSystemClockChanged();
+            Assert.AreEqual(0, cal._queue.Count);
+            Assert.AreEqual(1, s._queue.Count);
+            var wrk = s._queue[0];
+            Assert.IsTrue(wrk.DueTime == rel);
 
-                Assert.AreEqual(1, cal._queue.Count);
+            s.SetTime(due + err);
+            scm.OnSystemClockChanged();
 
-                var tmr = cal._queue.Deq();
-                Assert.IsTrue(tmr.Interval > rel);
-                Assert.IsTrue(tmr.Interval < -err);
+            Assert.AreEqual(1, cal._queue.Count);
 
-                s.SetTime(s.Now + tmr.Interval);
-                tmr.Value._action(tmr.Value._state);
+            var tmr = cal._queue.Deq();
+            Assert.IsTrue(tmr.Interval > rel);
+            Assert.IsTrue(tmr.Interval < -err);
 
-                Assert.AreEqual(0, n);
+            s.SetTime(s.Now + tmr.Interval);
+            tmr.Value._action(tmr.Value._state);
 
-                Assert.AreEqual(0, cal._queue.Count);
-                Assert.AreEqual(1, s._queue.Count);
+            Assert.AreEqual(0, n);
 
-                s.SetTime(due);
-                s._queue.Deq().Invoke();
+            Assert.AreEqual(0, cal._queue.Count);
+            Assert.AreEqual(1, s._queue.Count);
 
-                Assert.AreEqual(1, n);
+            s.SetTime(due);
+            s._queue.Deq().Invoke();
 
-                wrk.Invoke(); // Bad schedulers may not grant cancellation immediately.
-                Assert.AreEqual(1, n); // Invoke shouldn't cause double execution of the work.
-            });
+            Assert.AreEqual(1, n);
+
+            wrk.Invoke(); // Bad schedulers may not grant cancellation immediately.
+            Assert.AreEqual(1, n); // Invoke shouldn't cause double execution of the work.
         }
 
         [TestMethod]
         public void PeriodicSystemClockChangeMonitor()
         {
-            Run(() =>
-            {
-                var provider = new FakeClockPlatformEnlightenmentProvider();
-                PlatformEnlightenmentProvider.Current = provider;
+            Run(PeriodicSystemClockChangeMonitor_Callback);
+        }
 
-                var clock = (FakeClock)provider.GetService<ISystemClock>();
-                clock._now = new DateTimeOffset(2012, 4, 26, 12, 0, 0, TimeSpan.Zero);
+        private static void PeriodicSystemClockChangeMonitor_Callback()
+        {
+            var provider = new FakeClockPlatformEnlightenmentProvider();
+            PlatformEnlightenmentProvider.Current = provider;
 
-                var cal = (FakeClockCAL)provider.GetService<IConcurrencyAbstractionLayer>();
+            var clock = (FakeClock)provider.GetService<ISystemClock>();
+            clock._now = new DateTimeOffset(2012, 4, 26, 12, 0, 0, TimeSpan.Zero);
 
-                var period = TimeSpan.FromSeconds(1);
-                var ptscm = new PeriodicTimerSystemClockMonitor(period);
+            var cal = (FakeClockCAL)provider.GetService<IConcurrencyAbstractionLayer>();
 
-                var delta = TimeSpan.Zero;
-                var n = 0;
-                var h = new EventHandler<SystemClockChangedEventArgs>((o, e) =>
-                {
-                    delta = e.NewTime - e.OldTime;
-                    n++;
-                });
+            var period = TimeSpan.FromSeconds(1);
+            var ptscm = new PeriodicTimerSystemClockMonitor(period);
+
+            var delta = TimeSpan.Zero;
+            var n = 0;
+            var h = new EventHandler<SystemClockChangedEventArgs>((o, e) =>
+            {
+                delta = e.NewTime - e.OldTime;
+                n++;
+            });
 
-                ptscm.SystemClockChanged += h;
+            ptscm.SystemClockChanged += h;
 
-                Assert.IsNotNull(cal._action);
-                Assert.IsTrue(cal._period == period);
-                Assert.AreEqual(0, n);
+            Assert.IsNotNull(cal._action);
+            Assert.IsTrue(cal._period == period);
+            Assert.AreEqual(0, n);
 
-                clock._now += period;
-                cal._action();
-                Assert.AreEqual(0, n);
+            clock._now += period;
+            cal._action();
+            Assert.AreEqual(0, n);
 
-                clock._now += period;
-                cal._action();
-                Assert.AreEqual(0, n);
+            clock._now += period;
+            cal._action();
+            Assert.AreEqual(0, n);
 
-                var diff1 = TimeSpan.FromSeconds(3);
-                clock._now += period + diff1;
-                cal._action();
-                Assert.AreEqual(1, n);
-                Assert.IsTrue(delta == diff1);
+            var diff1 = TimeSpan.FromSeconds(3);
+            clock._now += period + diff1;
+            cal._action();
+            Assert.AreEqual(1, n);
+            Assert.IsTrue(delta == diff1);
 
-                clock._now += period;
-                cal._action();
-                Assert.AreEqual(1, n);
+            clock._now += period;
+            cal._action();
+            Assert.AreEqual(1, n);
 
-                clock._now += period;
-                cal._action();
-                Assert.AreEqual(1, n);
+            clock._now += period;
+            cal._action();
+            Assert.AreEqual(1, n);
 
-                var diff2 = TimeSpan.FromSeconds(-5);
-                clock._now += period + diff2;
-                cal._action();
-                Assert.AreEqual(2, n);
-                Assert.IsTrue(delta == diff2);
+            var diff2 = TimeSpan.FromSeconds(-5);
+            clock._now += period + diff2;
+            cal._action();
+            Assert.AreEqual(2, n);
+            Assert.IsTrue(delta == diff2);
 
-                clock._now += period;
-                cal._action();
-                Assert.AreEqual(2, n);
+            clock._now += period;
+            cal._action();
+            Assert.AreEqual(2, n);
 
-                ptscm.SystemClockChanged -= h;
+            ptscm.SystemClockChanged -= h;
 
-                Assert.IsNull(cal._action);
-            });
+            Assert.IsNull(cal._action);
         }
 
         [TestMethod]
         public void ClockChanged_RefCounting()
         {
-            Run(() =>
-            {
-                var provider = new MyPlatformEnlightenmentProvider();
-                PlatformEnlightenmentProvider.Current = provider;
+            Run(ClockChanged_RefCounting_Callback);
+        }
 
-                var scm = (ClockChanged)provider.GetService<INotifySystemClockChanged>();
+        private static void ClockChanged_RefCounting_Callback()
+        {
+            var provider = new MyPlatformEnlightenmentProvider();
+            PlatformEnlightenmentProvider.Current = provider;
 
-                var cal = provider._cal;
-                var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
+            var scm = (ClockChanged)provider.GetService<INotifySystemClockChanged>();
 
-                var s = new MyScheduler();
-                s.SetTime(now);
+            var cal = provider._cal;
+            var now = new DateTimeOffset(2012, 4, 25, 12, 0, 0, TimeSpan.Zero);
 
-                var due1 = now + TimeSpan.FromSeconds(5);
-                var due2 = now + TimeSpan.FromSeconds(8);
-                var due3 = now + TimeSpan.FromMinutes(1);
-                var due4 = now + TimeSpan.FromMinutes(2);
-                var due5 = now + TimeSpan.FromMinutes(3);
-                var due6 = now + TimeSpan.FromMinutes(3) + TimeSpan.FromSeconds(2);
+            var s = new MyScheduler();
+            s.SetTime(now);
 
-                var done1 = false;
-                var done2 = false;
-                var done3 = false;
-                var done4 = false;
-                var done5 = false;
-                var done6 = false;
+            var due1 = now + TimeSpan.FromSeconds(5);
+            var due2 = now + TimeSpan.FromSeconds(8);
+            var due3 = now + TimeSpan.FromMinutes(1);
+            var due4 = now + TimeSpan.FromMinutes(2);
+            var due5 = now + TimeSpan.FromMinutes(3);
+            var due6 = now + TimeSpan.FromMinutes(3) + TimeSpan.FromSeconds(2);
 
-                var d1 = s.Schedule(due1, () => { done1 = true; });
-                var d5 = s.Schedule(due5, () => { done5 = true; });
-                var d3 = s.Schedule(due3, () => { done3 = true; throw new Exception(); });
-                var d2 = s.Schedule(due2, () => { done2 = true; });
-                var d4 = s.Schedule(due4, () => { done4 = true; });
+            var done1 = false;
+            var done2 = false;
+            var done3 = false;
+            var done4 = false;
+            var done5 = false;
+            var done6 = false;
 
-                d2.Dispose();
-                d4.Dispose();
+            var d1 = s.Schedule(due1, () => { done1 = true; });
+            var d5 = s.Schedule(due5, () => { done5 = true; });
+            var d3 = s.Schedule(due3, () => { done3 = true; throw new Exception(); });
+            var d2 = s.Schedule(due2, () => { done2 = true; });
+            var d4 = s.Schedule(due4, () => { done4 = true; });
 
-                Assert.AreEqual(1, scm.n);
+            d2.Dispose();
+            d4.Dispose();
 
-                s.SetTime(due1);
-                var i1 = s._queue.Deq();
-                i1.Invoke();
-                Assert.IsTrue(done1);
+            Assert.AreEqual(1, scm.n);
 
-                Assert.AreEqual(1, scm.n);
+            s.SetTime(due1);
+            var i1 = s._queue.Deq();
+            i1.Invoke();
+            Assert.IsTrue(done1);
 
-                s.SetTime(due2);
-                var i2 = s._queue.Deq();
-                i2.Invoke();
-                Assert.IsFalse(done2);
+            Assert.AreEqual(1, scm.n);
 
-                Assert.AreEqual(1, scm.n);
+            s.SetTime(due2);
+            var i2 = s._queue.Deq();
+            i2.Invoke();
+            Assert.IsFalse(done2);
 
-                var l1 = cal._queue.Deq();
-                var l1d = now + l1.Interval;
-                s.SetTime(l1d);
-                l1.Value._action(l1.Value._state);
+            Assert.AreEqual(1, scm.n);
 
-                s.SetTime(due3);
-                var i3 = s._queue.Deq();
-                try
-                {
-                    i3.Invoke();
-                    Assert.Fail();
-                }
-                catch { }
-                Assert.IsTrue(done3);
+            var l1 = cal._queue.Deq();
+            var l1d = now + l1.Interval;
+            s.SetTime(l1d);
+            l1.Value._action(l1.Value._state);
 
-                Assert.AreEqual(1, scm.n);
+            s.SetTime(due3);
+            var i3 = s._queue.Deq();
+            try
+            {
+                i3.Invoke();
+                Assert.Fail();
+            }
+            catch { }
+            Assert.IsTrue(done3);
 
-                var l2 = cal._queue.Deq();
-                var l2d = l1d + l2.Interval;
-                s.SetTime(l2d);
-                l2.Value._action(l2.Value._state);
+            Assert.AreEqual(1, scm.n);
 
-                s.SetTime(due4);
-                var i4 = s._queue.Deq();
-                i4.Invoke();
-                Assert.IsFalse(done4);
+            var l2 = cal._queue.Deq();
+            var l2d = l1d + l2.Interval;
+            s.SetTime(l2d);
+            l2.Value._action(l2.Value._state);
 
-                Assert.AreEqual(1, scm.n);
+            s.SetTime(due4);
+            var i4 = s._queue.Deq();
+            i4.Invoke();
+            Assert.IsFalse(done4);
 
-                var l3 = cal._queue.Deq();
-                var l3d = l2d + l3.Interval;
-                s.SetTime(l3d);
-                l3.Value._action(l3.Value._state);
+            Assert.AreEqual(1, scm.n);
 
-                s.SetTime(due5);
-                var i5 = s._queue.Deq();
-                i5.Invoke();
-                Assert.IsTrue(done5);
+            var l3 = cal._queue.Deq();
+            var l3d = l2d + l3.Interval;
+            s.SetTime(l3d);
+            l3.Value._action(l3.Value._state);
 
-                Assert.AreEqual(0, scm.n);
+            s.SetTime(due5);
+            var i5 = s._queue.Deq();
+            i5.Invoke();
+            Assert.IsTrue(done5);
 
-                var d6 = s.Schedule(due6, () => { done6 = true; });
+            Assert.AreEqual(0, scm.n);
 
-                Assert.AreEqual(1, scm.n);
+            var d6 = s.Schedule(due6, () => { done6 = true; });
 
-                s.SetTime(due6);
-                var i6 = s._queue.Deq();
-                i6.Invoke();
-                Assert.IsTrue(done6);
+            Assert.AreEqual(1, scm.n);
 
-                Assert.AreEqual(0, scm.n);
-            });
+            s.SetTime(due6);
+            var i6 = s._queue.Deq();
+            i6.Invoke();
+            Assert.IsTrue(done6);
+
+            Assert.AreEqual(0, scm.n);
         }
 
         class MyScheduler : LocalScheduler