public void ScheduleRelative_Cancel()
{
var evt = new ManualResetEvent(false);
var id = Thread.CurrentThread.ManagedThreadId;
var disp = DispatcherHelpers.EnsureDispatcher();
var sch = new DispatcherScheduler(disp);
sch.Schedule(TimeSpan.FromSeconds(0.1), () =>
{
Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
var d = sch.Schedule(TimeSpan.FromSeconds(0.1), () =>
{
Assert.True(false);
evt.Set();
});
sch.Schedule(() =>
{
d.Dispose();
});
sch.Schedule(TimeSpan.FromSeconds(0.2), () =>
{
Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
evt.Set();
});
});
evt.WaitOne();
disp.InvokeShutdown();
}
public void Dispatcher_ScheduleActionDue()
{
var id = Thread.CurrentThread.ManagedThreadId;
var disp = EnsureDispatcher();
var sch = new DispatcherScheduler(disp);
var evt = new ManualResetEvent(false);
var sw = new Stopwatch();
sw.Start();
sch.Schedule(() =>
{
sw.Stop();
Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
sw.Start();
sch.Schedule(() =>
{
sw.Stop();
Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
evt.Set();
}, TimeSpan.FromSeconds(0.2));
}, TimeSpan.FromSeconds(0.2));
evt.WaitOne();
Assert.IsTrue(sw.ElapsedMilliseconds > 380, "due " + sw.ElapsedMilliseconds);
disp.InvokeShutdown();
}
public void Schedule_ArgumentChecking()
{
var disp = DispatcherHelpers.EnsureDispatcher();
var s = new DispatcherScheduler(disp);
ReactiveAssert.Throws<ArgumentNullException>(() => s.Schedule(42, default(Func<IScheduler, int, IDisposable>)));
ReactiveAssert.Throws<ArgumentNullException>(() => s.Schedule(42, TimeSpan.FromSeconds(1), default(Func<IScheduler, int, IDisposable>)));
ReactiveAssert.Throws<ArgumentNullException>(() => s.Schedule(42, DateTimeOffset.Now, default(Func<IScheduler, int, IDisposable>)));
}
public void Schedule_ArgumentChecking()
{
var disp = DispatcherHelpers.EnsureDispatcher();
var s = new DispatcherScheduler(disp);
ReactiveAssert.Throws <ArgumentNullException>(() => s.Schedule(42, default(Func <IScheduler, int, IDisposable>)));
ReactiveAssert.Throws <ArgumentNullException>(() => s.Schedule(42, TimeSpan.FromSeconds(1), default(Func <IScheduler, int, IDisposable>)));
ReactiveAssert.Throws <ArgumentNullException>(() => s.Schedule(42, DateTimeOffset.Now, default(Func <IScheduler, int, IDisposable>)));
}
public void Dispatcher_ScheduleAction()
{
var id = Thread.CurrentThread.ManagedThreadId;
var disp = EnsureDispatcher();
var sch = new DispatcherScheduler(disp);
var evt = new ManualResetEvent(false);
sch.Schedule(() => { Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
evt.WaitOne();
disp.InvokeShutdown();
}
public void SafeDispatch(Action action)
{
if (_dispatcher.Dispatcher.CheckAccess())
{
action();
}
else
{
_dispatcher.Schedule(action);
}
}
private void ScheduleRelative_(TimeSpan delay)
{
var evt = new ManualResetEvent(false);
var id = Thread.CurrentThread.ManagedThreadId;
var disp = DispatcherHelpers.EnsureDispatcher();
var sch = new DispatcherScheduler(disp);
sch.Schedule(delay, () =>
{
Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
sch.Schedule(delay, () =>
{
Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
evt.Set();
});
});
evt.WaitOne();
disp.InvokeShutdown();
}
private void ScheduleRelative_(TimeSpan delay)
{
using (DispatcherHelpers.RunTest(out var disp))
{
var evt = new ManualResetEvent(false);
var id = Thread.CurrentThread.ManagedThreadId;
var sch = new DispatcherScheduler(disp);
sch.Schedule(delay, () =>
{
Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
sch.Schedule(delay, () =>
{
Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
evt.Set();
});
});
evt.WaitOne();
}
}
public void Dispatcher_ScheduleActionDueNow()
{
var id = Thread.CurrentThread.ManagedThreadId;
var disp = EnsureDispatcher();
var sch = new DispatcherScheduler(disp);
var evt = new ManualResetEvent(false);
var sw = new Stopwatch();
sw.Start();
sch.Schedule(() =>
{
sw.Stop();
Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
sw.Start();
sch.Schedule(() =>
{
sw.Stop();
Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
evt.Set();
}, TimeSpan.Zero);
}, TimeSpan.Zero);
evt.WaitOne();
disp.InvokeShutdown();
}
public void Schedule()
{
var disp = DispatcherHelpers.EnsureDispatcher();
RunAsync(evt =>
{
var id = Thread.CurrentThread.ManagedThreadId;
var sch = new DispatcherScheduler(disp);
sch.Schedule(() =>
{
Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
disp.InvokeShutdown();
evt.Set();
});
});
}
public void Schedule()
{
using (DispatcherHelpers.RunTest(out var disp))
{
RunAsync(evt =>
{
var id = Thread.CurrentThread.ManagedThreadId;
var sch = new DispatcherScheduler(disp);
sch.Schedule(() =>
{
Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
evt.Set();
});
});
}
}
public void Schedule()
{
var disp = DispatcherHelpers.EnsureDispatcher();
RunAsync(evt =>
{
var id = Thread.CurrentThread.ManagedThreadId;
var sch = new DispatcherScheduler(disp);
sch.Schedule(() =>
{
#if SILVERLIGHT
Assert.Equal(id, Thread.CurrentThread.ManagedThreadId); // Single-threaded test framework
#else
Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
#endif
disp.InvokeShutdown();
evt.Set();
});
});
}
public void Dispatcher_ScheduleActionError()
{
var ex = new Exception();
var id = Thread.CurrentThread.ManagedThreadId;
var disp = EnsureDispatcher();
var evt = new ManualResetEvent(false);
disp.UnhandledException += (o, e) =>
{
Assert.AreSame(ex, e.Exception.InnerException); // CHECK
evt.Set();
e.Handled = true;
};
var sch = new DispatcherScheduler(disp);
sch.Schedule(() => { throw ex; });
evt.WaitOne();
disp.InvokeShutdown();
}
public void SchedulePeriodic()
{
using (DispatcherHelpers.RunTest(out var disp))
{
var evt = new ManualResetEvent(false);
var id = Thread.CurrentThread.ManagedThreadId;
var sch = new DispatcherScheduler(disp);
var d = new SingleAssignmentDisposable();
d.Disposable = sch.SchedulePeriodic(1, TimeSpan.FromSeconds(0.1), n =>
{
Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
if (n == 3)
{
d.Dispose();
sch.Schedule(TimeSpan.FromSeconds(0.2), () =>
{
Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId);
evt.Set();
});
}
if (n > 3)
{
Assert.True(false);
}
return(n + 1);
});
evt.WaitOne();
}
}
public void ScheduleError()
{
using (DispatcherHelpers.RunTest(out var disp))
{
var ex = new Exception();
var id = Thread.CurrentThread.ManagedThreadId;
var evt = new ManualResetEvent(false);
Exception thrownEx = null;
disp.UnhandledException += (o, e) =>
{
thrownEx = e.Exception;
evt.Set();
e.Handled = true;
};
var sch = new DispatcherScheduler(disp);
sch.Schedule(() => { throw ex; });
evt.WaitOne();
Assert.Same(ex, thrownEx);
}
}
public void ScheduleError()
{
var ex = new Exception();
var id = Thread.CurrentThread.ManagedThreadId;
var disp = DispatcherHelpers.EnsureDispatcher();
var evt = new ManualResetEvent(false);
disp.UnhandledException += (o, e) =>
{
#if NET45 || NET46
Assert.Same(ex, e.Exception); // CHECK
#else
Assert.Same(ex, e.Exception.InnerException); // CHECK
#endif
evt.Set();
e.Handled = true;
};
var sch = new DispatcherScheduler(disp);
sch.Schedule(() => { throw ex; });
evt.WaitOne();
disp.InvokeShutdown();
}
public void SchedulePeriodic()
{
var evt = new ManualResetEvent(false);
var id = Thread.CurrentThread.ManagedThreadId;
var disp = DispatcherHelpers.EnsureDispatcher();
var sch = new DispatcherScheduler(disp);
var d = new SingleAssignmentDisposable();
d.Disposable = sch.SchedulePeriodic(1, TimeSpan.FromSeconds(0.1), n =>
{
Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
if (n == 3)
{
d.Dispose();
sch.Schedule(TimeSpan.FromSeconds(0.2), () =>
{
Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
evt.Set();
});
}
if (n > 3)
{
Assert.Fail();
}
return(n + 1);
});
evt.WaitOne();
disp.InvokeShutdown();
}
public void Schedule()
{
var disp = DispatcherHelpers.EnsureDispatcher();
RunAsync(evt =>
{
var id = Thread.CurrentThread.ManagedThreadId;
var sch = new DispatcherScheduler(disp);
sch.Schedule(() =>
{
#if SILVERLIGHT
Assert.AreEqual(id, Thread.CurrentThread.ManagedThreadId); // Single-threaded test framework
#else
Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
#endif
disp.InvokeShutdown();
evt.Set();
});
});
}
public void SchedulePeriodic()
{
var evt = new ManualResetEvent(false);
var id = Thread.CurrentThread.ManagedThreadId;
var disp = DispatcherHelpers.EnsureDispatcher();
var sch = new DispatcherScheduler(disp);
var d = new SingleAssignmentDisposable();
d.Disposable = sch.SchedulePeriodic(1, TimeSpan.FromSeconds(0.1), n =>
{
Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
if (n == 3)
{
d.Dispose();
sch.Schedule(TimeSpan.FromSeconds(0.2), () =>
{
Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
evt.Set();
});
}
if (n > 3)
{
Assert.Fail();
}
return n + 1;
});
evt.WaitOne();
disp.InvokeShutdown();
}
public void ScheduleRelative_Cancel()
{
var evt = new ManualResetEvent(false);
var id = Thread.CurrentThread.ManagedThreadId;
var disp = DispatcherHelpers.EnsureDispatcher();
var sch = new DispatcherScheduler(disp);
sch.Schedule(TimeSpan.FromSeconds(0.1), () =>
{
Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
var d = sch.Schedule(TimeSpan.FromSeconds(0.1), () =>
{
Assert.Fail();
evt.Set();
});
sch.Schedule(() =>
{
d.Dispose();
});
sch.Schedule(TimeSpan.FromSeconds(0.2), () =>
{
Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
evt.Set();
});
});
evt.WaitOne();
disp.InvokeShutdown();
}
private void ScheduleRelative_(TimeSpan delay)
{
var evt = new ManualResetEvent(false);
var id = Thread.CurrentThread.ManagedThreadId;
var disp = DispatcherHelpers.EnsureDispatcher();
var sch = new DispatcherScheduler(disp);
sch.Schedule(delay, () =>
{
Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
sch.Schedule(delay, () =>
{
Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
evt.Set();
});
});
evt.WaitOne();
disp.InvokeShutdown();
}
public void ScheduleError()
{
var ex = new Exception();
var id = Thread.CurrentThread.ManagedThreadId;
var disp = DispatcherHelpers.EnsureDispatcher();
var evt = new ManualResetEvent(false);
disp.UnhandledException += (o, e) =>
{
#if DESKTOPCLR40 || DESKTOPCLR45
Assert.AreSame(ex, e.Exception); // CHECK
#else
Assert.AreSame(ex, e.Exception.InnerException); // CHECK
#endif
evt.Set();
e.Handled = true;
};
var sch = new DispatcherScheduler(disp);
sch.Schedule(() => { throw ex; });
evt.WaitOne();
disp.InvokeShutdown();
}
public static IDisposable ScheduleOnUI(this Action action)
{
return(UIDispatcherScheduler.Schedule(action));
}