Re-enable some tests.

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ControlSchedulerTest.cs

@@ -47,49 +47,56 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentNullException>(() => s.Schedule(42, DateTimeOffset.Now, default(Func<IScheduler, int, IDisposable>)));
         }
 
-        [Fact(Skip="Run Locally")]
+        [Fact]
         public void Schedule()
         {
-            var evt = new ManualResetEvent(false);
+            using (WinFormsTestUtils.RunTest(out var lbl))
+            {
+                var evt = new ManualResetEvent(false);
 
-            var id = Thread.CurrentThread.ManagedThreadId;
+                var id = Thread.CurrentThread.ManagedThreadId;
 
-            var lbl = CreateLabel();
-            var sch = new ControlScheduler(lbl);
-            
-            sch.Schedule(() => { lbl.Text = "Okay"; Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); });
-            sch.Schedule(() => { Assert.Equal("Okay", lbl.Text); Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
+                var sch = new ControlScheduler(lbl);
+                
+                sch.Schedule(() => { lbl.Text = "Okay"; Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); });
+                sch.Schedule(() => { Assert.Equal("Okay", lbl.Text); Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
 
-            evt.WaitOne();
-            Application.Exit();
+                evt.WaitOne();
+            }
         }
 
-        [Fact(Skip="Run Locally")]
+        [Fact]
         public void ScheduleError()
         {
-            var evt = new ManualResetEvent(false);
+            using (WinFormsTestUtils.RunTest(out var lbl))
+            {
+                var evt = new ManualResetEvent(false);
 
-            var ex = new Exception();
+                var ex = new Exception();
 
-            var lbl = CreateLabelWithHandler(e => {
-                Assert.Same(ex, e);
-                evt.Set();
-            });
+                lbl.Invoke(new Action(() =>
+                {
+                    Application.ThreadException += (o, e) =>
+                    {
+                        Assert.Same(ex, e.Exception);
+                        evt.Set();
+                    };
+                }));
 
-            var sch = new ControlScheduler(lbl);
-            sch.Schedule(() => { throw ex; });
+                var sch = new ControlScheduler(lbl);
+                sch.Schedule(() => { throw ex; });
 
-            evt.WaitOne();
-            Application.Exit();
+                evt.WaitOne();
+            }
         }
 
-        [Fact(Skip="Run Locally")]
+        [Fact]
         public void ScheduleRelative()
         {
             ScheduleRelative_(TimeSpan.FromSeconds(0.1));
         }
 
-        [Fact(Skip="Run Locally")]
+        [Fact]
         public void ScheduleRelative_Zero()
         {
             ScheduleRelative_(TimeSpan.Zero);
@@ -97,95 +104,98 @@ namespace ReactiveTests.Tests
 
         private void ScheduleRelative_(TimeSpan delay)
         {
-            var evt = new ManualResetEvent(false);
-
-            var id = Thread.CurrentThread.ManagedThreadId;
-            
-            var lbl = CreateLabel();
-            var sch = new ControlScheduler(lbl);
-
-            sch.Schedule(delay, () =>
+            using (WinFormsTestUtils.RunTest(out var lbl))
             {
-                lbl.Text = "Okay";
-                Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                var evt = new ManualResetEvent(false);
+
+                var id = Thread.CurrentThread.ManagedThreadId;
                 
-                sch.Schedule(() =>
+                var sch = new ControlScheduler(lbl);
+
+                sch.Schedule(delay, () =>
                 {
-                    Assert.Equal("Okay", lbl.Text);
+                    lbl.Text = "Okay";
                     Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
-                    evt.Set();
+                    
+                    sch.Schedule(() =>
+                    {
+                        Assert.Equal("Okay", lbl.Text);
+                        Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                        evt.Set();
+                    });
                 });
-            });
 
-            evt.WaitOne();
-            Application.Exit();
+                evt.WaitOne();
+            }
         }
 
-        [Fact(Skip="Run Locally")]
+        [Fact]
         public void ScheduleRelative_Nested()
         {
-            var evt = new ManualResetEvent(false);
+            using (WinFormsTestUtils.RunTest(out var lbl))
+            {
+                var evt = new ManualResetEvent(false);
 
-            var id = Thread.CurrentThread.ManagedThreadId;
+                var id = Thread.CurrentThread.ManagedThreadId;
 
-            var lbl = CreateLabel();
-            var sch = new ControlScheduler(lbl);
+                var sch = new ControlScheduler(lbl);
 
-            sch.Schedule(TimeSpan.FromSeconds(0.1), () =>
-            {
                 sch.Schedule(TimeSpan.FromSeconds(0.1), () =>
                 {
-                    lbl.Text = "Okay";
-                    Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
-
-                    sch.Schedule(() =>
+                    sch.Schedule(TimeSpan.FromSeconds(0.1), () =>
                     {
-                        Assert.Equal("Okay", lbl.Text);
+                        lbl.Text = "Okay";
                         Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
-                        evt.Set();
+
+                        sch.Schedule(() =>
+                        {
+                            Assert.Equal("Okay", lbl.Text);
+                            Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                            evt.Set();
+                        });
                     });
                 });
-            });
 
-            evt.WaitOne();
-            Application.Exit();
+                evt.WaitOne();
+            }
         }
 
-        [Fact(Skip="Run Locally")]
+        [Fact]
         public void ScheduleRelative_Cancel()
         {
-            var evt = new ManualResetEvent(false);
-
-            var id = Thread.CurrentThread.ManagedThreadId;
-
-            var lbl = CreateLabel();
-            var sch = new ControlScheduler(lbl);
-
-            sch.Schedule(TimeSpan.FromSeconds(0.1), () =>
+            using (WinFormsTestUtils.RunTest(out var lbl))
             {
-                lbl.Text = "Okay";
-                Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                var evt = new ManualResetEvent(false);
 
-                var d = sch.Schedule(TimeSpan.FromSeconds(0.1), () =>
-                {
-                    lbl.Text = "Oops!";
-                });
+                var id = Thread.CurrentThread.ManagedThreadId;
 
-                sch.Schedule(() =>
-                {
-                    d.Dispose();
-                });
+                var sch = new ControlScheduler(lbl);
 
-                sch.Schedule(TimeSpan.FromSeconds(0.2), () =>
+                sch.Schedule(TimeSpan.FromSeconds(0.1), () =>
                 {
-                    Assert.Equal("Okay", lbl.Text);
+                    lbl.Text = "Okay";
                     Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
-                    evt.Set();
+
+                    var d = sch.Schedule(TimeSpan.FromSeconds(0.1), () =>
+                    {
+                        lbl.Text = "Oops!";
+                    });
+
+                    sch.Schedule(() =>
+                    {
+                        d.Dispose();
+                    });
+
+                    sch.Schedule(TimeSpan.FromSeconds(0.2), () =>
+                    {
+                        Assert.Equal("Okay", lbl.Text);
+                        Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                        evt.Set();
+                    });
                 });
-            });
 
-            evt.WaitOne();
-            Application.Exit();
+                evt.WaitOne();
+            }
         }
 
         [Fact]
@@ -197,60 +207,16 @@ namespace ReactiveTests.Tests
             ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => s.SchedulePeriodic(42, TimeSpan.FromMilliseconds(1).Subtract(TimeSpan.FromTicks(1)), x => x));
         }
 
-        [Fact(Skip="Run Locally")]
+        [Fact]
         public void SchedulePeriodic()
         {
-            var evt = new ManualResetEvent(false);
-
-            var id = Thread.CurrentThread.ManagedThreadId;
-
-            var lbl = CreateLabel();
-            var sch = new ControlScheduler(lbl);
-
-            var d = new SingleAssignmentDisposable();
-
-            d.Disposable = sch.SchedulePeriodic(1, TimeSpan.FromSeconds(0.1), n =>
+            using (WinFormsTestUtils.RunTest(out var lbl))
             {
-                lbl.Text = "Okay " + n;
-                Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
-
-                if (n == 3)
-                {
-                    d.Dispose();
-
-                    sch.Schedule(TimeSpan.FromSeconds(0.2), () =>
-                    {
-                        Assert.Equal("Okay 3", lbl.Text);
-                        Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
-                        evt.Set();
-                    });
-                }
-
-                if (n > 3)
-                {
-                    Assert.True(false);
-                }
-
-                return n + 1;
-            });
-
-            evt.WaitOne();
-            Application.Exit();
-        }
-
-        [Fact(Skip="Run Locally")]
-        public void SchedulePeriodic_Nested()
-        {
-            var evt = new ManualResetEvent(false);
+                var evt = new ManualResetEvent(false);
 
-            var id = Thread.CurrentThread.ManagedThreadId;
+                var id = Thread.CurrentThread.ManagedThreadId;
 
-            var lbl = CreateLabel();
-            var sch = new ControlScheduler(lbl);
-
-            sch.Schedule(() =>
-            {
-                lbl.Text = "Okay";
+                var sch = new ControlScheduler(lbl);
 
                 var d = new SingleAssignmentDisposable();
 
@@ -271,60 +237,58 @@ namespace ReactiveTests.Tests
                         });
                     }
 
+                    if (n > 3)
+                    {
+                        Assert.True(false);
+                    }
+
                     return n + 1;
                 });
-            });
 
-            evt.WaitOne();
-            Application.Exit();
+                evt.WaitOne();
+            }
         }
 
-        private Label CreateLabel()
+        [Fact]
+        public void SchedulePeriodic_Nested()
         {
-            var loaded = new ManualResetEvent(false);
-            var lbl = default(Label);
-
-            var t = new Thread(() =>
+            using (WinFormsTestUtils.RunTest(out var lbl))
             {
-                lbl = new Label();
-                var frm = new Form { Controls = { lbl }, Width = 0, Height = 0, FormBorderStyle = FormBorderStyle.None, ShowInTaskbar = false };
-                frm.Load += (_, __) =>
-                {
-                    loaded.Set();
-                };
-                Application.Run(frm);
-            });
-            t.SetApartmentState(ApartmentState.STA);
-            t.Start();
-
-            loaded.WaitOne();
-            return lbl;
-        }
+                var evt = new ManualResetEvent(false);
 
-        private Label CreateLabelWithHandler(Action<Exception> handler)
-        {
-            var loaded = new ManualResetEvent(false);
-            var lbl = default(Label);
+                var id = Thread.CurrentThread.ManagedThreadId;
 
-            var t = new Thread(() =>
-            {
-                lbl = new Label();
-                var frm = new Form { Controls = { lbl }, Width = 0, Height = 0, FormBorderStyle = FormBorderStyle.None, ShowInTaskbar = false };
-                frm.Load += (_, __) =>
-                {
-                    loaded.Set();
-                };
-                Application.ThreadException += (o, e) =>
+                var sch = new ControlScheduler(lbl);
+
+                sch.Schedule(() =>
                 {
-                    handler(e.Exception);
-                };
-                Application.Run(frm);
-            });
-            t.SetApartmentState(ApartmentState.STA);
-            t.Start();
-
-            loaded.WaitOne();
-            return lbl;
+                    lbl.Text = "Okay";
+
+                    var d = new SingleAssignmentDisposable();
+
+                    d.Disposable = sch.SchedulePeriodic(1, TimeSpan.FromSeconds(0.1), n =>
+                    {
+                        lbl.Text = "Okay " + n;
+                        Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
+
+                        if (n == 3)
+                        {
+                            d.Dispose();
+
+                            sch.Schedule(TimeSpan.FromSeconds(0.2), () =>
+                            {
+                                Assert.Equal("Okay 3", lbl.Text);
+                                Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
+                                evt.Set();
+                            });
+                        }
+
+                        return n + 1;
+                    });
+                });
+
+                evt.WaitOne();
+            }
         }
     }
 }

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/CurrentThreadSchedulerTest.cs

@@ -82,38 +82,31 @@ namespace ReactiveTests.Tests
             Assert.True(ran);
         }
 
-        [Fact(Skip = "")]
+        [Fact]
         public void CurrentThread_ScheduleActionDue()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var ran = false;
-            var sw = new Stopwatch();
-            sw.Start();
-            Scheduler.CurrentThread.Schedule(TimeSpan.FromSeconds(0.2), () => { sw.Stop(); Assert.Equal(id, Thread.CurrentThread.ManagedThreadId); ran = true; });
+            Scheduler.CurrentThread.Schedule(TimeSpan.FromSeconds(0.2), () => { Assert.Equal(id, Thread.CurrentThread.ManagedThreadId); ran = true; });
             Assert.True(ran, "ran");
-            Assert.True(sw.ElapsedMilliseconds > 180, "due " + sw.ElapsedMilliseconds);
         }
 
-        [Fact(Skip = "")]
+        [Fact]
         public void CurrentThread_ScheduleActionDueNested()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var ran = false;
-            var sw = new Stopwatch();
-            sw.Start();
             Scheduler.CurrentThread.Schedule(TimeSpan.FromSeconds(0.2), () =>
             {
-                sw.Stop();
                 Assert.Equal(id, Thread.CurrentThread.ManagedThreadId);
-                sw.Start();
+
                 Scheduler.CurrentThread.Schedule(TimeSpan.FromSeconds(0.2), () =>
                 {
-                    sw.Stop();
+                    Assert.Equal(id, Thread.CurrentThread.ManagedThreadId);
                     ran = true;
                 });
             });
             Assert.True(ran, "ran");
-            Assert.True(sw.ElapsedMilliseconds > 380, "due " + sw.ElapsedMilliseconds);
         }
 #endif
         [Fact]

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/ImmediateSchedulerTest.cs

@@ -145,16 +145,13 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_THREAD
-        [Fact(Skip = "Ignored")]
+        [Fact]
         public void Immediate_ScheduleActionDue()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var ran = false;
-            var sw = new Stopwatch();
-            sw.Start();
-            Scheduler.Immediate.Schedule(TimeSpan.FromSeconds(0.2), () => { sw.Stop(); Assert.Equal(id, Thread.CurrentThread.ManagedThreadId); ran = true; });
+            Scheduler.Immediate.Schedule(TimeSpan.FromSeconds(0.2), () => { Assert.Equal(id, Thread.CurrentThread.ManagedThreadId); ran = true; });
             Assert.True(ran, "ran");
-            Assert.True(sw.ElapsedMilliseconds > 180, "due " + sw.ElapsedMilliseconds);
         }
 #endif
     }

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/NewThreadSchedulerTest.cs

@@ -43,17 +43,14 @@ namespace ReactiveTests.Tests
             evt.WaitOne();
         }
 
-        [Fact(Skip = "")]
+        [Fact]
         public void NewThread_ScheduleActionDue()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var nt = NewThreadScheduler.Default;
             var evt = new ManualResetEvent(false);
-            var sw = new Stopwatch();
-            sw.Start();
-            nt.Schedule(TimeSpan.FromSeconds(0.2), () => { sw.Stop(); Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
+            nt.Schedule(TimeSpan.FromSeconds(0.2), () => { Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
             evt.WaitOne();
-            Assert.True(sw.ElapsedMilliseconds > 180, "due " + sw.ElapsedMilliseconds);
         }
 #endif
 

Rx.NET/Source/tests/Tests.System.Reactive/Tests/Concurrency/VirtualSchedulerTest.cs

@@ -113,18 +113,15 @@ namespace ReactiveTests.Tests
         }
 
 #if !NO_THREAD
-        [Fact(Skip = "Ignored")]
+        [Fact]
         public void Virtual_ScheduleActionDue()
         {
             var id = Thread.CurrentThread.ManagedThreadId;
             var ran = false;
-            var sw = new Stopwatch();
-            sw.Start();
             var scheduler = new VirtualSchedulerTestScheduler();
-            scheduler.Schedule(TimeSpan.FromSeconds(0.2), () => { sw.Stop(); Assert.Equal(id, Thread.CurrentThread.ManagedThreadId); ran = true; });
+            scheduler.Schedule(TimeSpan.FromSeconds(0.2), () => { Assert.Equal(id, Thread.CurrentThread.ManagedThreadId); ran = true; });
             scheduler.Start();
             Assert.True(ran, "ran");
-            Assert.True(sw.ElapsedMilliseconds > 180, "due " + sw.ElapsedMilliseconds);
         }
 #endif