public void DisposeNotify_Requires_WaitHandle()
{
SimpleTimerHarness harness = new SimpleTimerHarness();
VersionedTimer <int> timer = new VersionedTimer <int>(123, harness.Callback);
Assert2.Throws <ArgumentNullException>(() => timer.Dispose(null));
}
public void Change_ViaTimeSpan_DoesNotAllow_Negative_Timeout()
{
SimpleTimerHarness harness = new SimpleTimerHarness();
VersionedTimer <int> timer = new VersionedTimer <int>(123, harness.Callback);
using ( timer )
{
// Smallest negative possible.
Assert2.Throws <ArgumentException>(() =>
{
timer.Change(TimeSpan.FromTicks(-1), Timeout.InfiniteTimeSpan, 0);
});
// Edge case near -1 ms (a special value), low side.
Assert2.Throws <ArgumentException>(() =>
{
timer.Change(nearOneMsPlus, Timeout.InfiniteTimeSpan, 0);
});
// Edge case near -1 ms (a special value), high side.
Assert2.Throws <ArgumentException>(() =>
{
timer.Change(nearOneMsMinus, Timeout.InfiniteTimeSpan, 0);
});
// More negative.
Assert2.Throws <ArgumentException>(() =>
{
timer.Change(MSecs(-2), Timeout.InfiniteTimeSpan, 0);
});
}
}
public void RepeatedPostpone_MultiShot()
{
int count = 200;
SimpleTimerHarness harness = new SimpleTimerHarness();
VersionedTimer <int> timer = new VersionedTimer <int>(456, harness.Callback);
using ( timer )
{
for (int i = 0; i < count; i++)
{
timer.Change(1000, 100, i);
Thread.Sleep(50);
}
// Verify the timer fires repeatedly.
for (int i = 0; i < 10; i++)
{
harness.Wait();
}
timer.Change(Timeout.Infinite, Timeout.Infinite, 0);
Assert.AreEqual(10, harness.Callbacks);
Assert.AreEqual(456, harness.ObservedState);
Assert.AreEqual(count - 1, harness.ObservedVersion);
}
}
public void Change_ViaInts_AllowsInfinite()
{
SimpleTimerHarness harness = new SimpleTimerHarness();
VersionedTimer <int> timer = new VersionedTimer <int>(123, harness.Callback);
using ( timer )
{
timer.Change(10, Timeout.Infinite, 0);
timer.Change(Timeout.Infinite, Timeout.Infinite, 1);
}
}
public void Change_ViaTimeSpan_Allows_Zero()
{
SimpleTimerHarness harness = new SimpleTimerHarness();
VersionedTimer <int> timer = new VersionedTimer <int>(123, harness.Callback);
using ( timer )
{
timer.Change(TimeSpan.Zero, Timeout.InfiniteTimeSpan, 1);
timer.Change(TimeSpan.Zero, TimeSpan.Zero, 2);
}
}
public void Dispose_AllowsMultipleDisposes()
{
SimpleTimerHarness harness = new SimpleTimerHarness();
VersionedTimer <int> timer = new VersionedTimer <int>(123, harness.Callback);
timer.Change(10, Timeout.Infinite, 0);
Assert.IsTrue(harness.Wait(), "Timer did not fire.");
timer.Dispose();
timer.Dispose();
}
public void VerifyDisposalNotify_NonePending()
{
for (int i = 0; i < 100; i++)
{
VersionedTimer <int> timer;
SimpleTimerHarness harness = new SimpleTimerHarness();
using (var disposeNotify = new AutoResetEvent(false))
{
timer = new VersionedTimer <int>(123, harness.Callback);
timer.Dispose(disposeNotify);
Assert.IsTrue(disposeNotify.WaitOne(5 * 1000), "Timer disposal notification did not fire.");
}
}
}
public void DisposeAfterSingleShot()
{
for (int i = 0; i < 100; i++)
{
VersionedTimer <int> timer;
SimpleTimerHarness harness = new SimpleTimerHarness();
timer = new VersionedTimer <int>(123, harness.Callback);
using ( timer )
{
timer.Change(10, Timeout.Infinite, 0);
Assert.IsTrue(harness.Wait(), "Timer did not fire.");
}
}
}
public void Change_ViaTimeSpan_MultiShot_Allows_Positive()
{
SimpleTimerHarness harness = new SimpleTimerHarness();
VersionedTimer <int> timer = new VersionedTimer <int>(123, harness.Callback);
using ( timer )
{
timer.Change(MSecs(100), MSecs(100), 1);
timer.Change(MSecs(100), MSecs(200), 1);
for (int i = 1; i <= 100; i++)
{
timer.Change(MSecs(100), MSecs(100 + i), 1);
}
timer.Change(MSecs(100), MSecs(int.MaxValue), 1);
}
}
public void Change_ViaInts_SingleShot_AllowsPositive()
{
SimpleTimerHarness harness = new SimpleTimerHarness();
VersionedTimer <int> timer = new VersionedTimer <int>(123, harness.Callback);
using ( timer )
{
timer.Change(100, Timeout.Infinite, 1);
timer.Change(200, Timeout.Infinite, 2);
for (int i = 1; i <= 100; i++)
{
timer.Change(100 + i, Timeout.Infinite, 1);
}
timer.Change(int.MaxValue, Timeout.Infinite, 1);
}
}
public void DisposeWhilePending()
{
SimpleTimerHarness harness = new SimpleTimerHarness();
for (int i = 0; i < 1000; i++)
{
VersionedTimer <int> timer;
timer = new VersionedTimer <int>(123, harness.Callback);
timer.Change(1000, Timeout.Infinite, 1);
timer.Dispose();
}
Thread.Sleep(1500);
Assert.AreEqual(harness.Callbacks, 0);
}
public void SingleShot()
{
SimpleTimerHarness harness = new SimpleTimerHarness();
using (var timer = new VersionedTimer <int>(123, harness.Callback))
{
harness.ExpectDelays(100, Timeout.Infinite);
timer.Change(100, Timeout.Infinite, 1);
// Give the timer some rope to hang itself by if it's accidentally going to fire
// multiple times.
Thread.Sleep(500);
Assert.IsTrue(harness.Wait(), "Timer never fired.");
Assert.AreEqual(123, harness.ObservedState, "Timer fired with wrong state.");
Assert.AreEqual(1, harness.ObservedVersion, "Timer fired with wrong version.");
Assert.AreEqual(1, harness.Callbacks, "Timer fired wrong number of times.");
Assert.AreEqual(0, harness.TimeoutError.TotalMilliseconds, 30, "Timer timeout was inaccurate.");
}
}
public void MultiShot()
{
SimpleTimerHarness harness = new SimpleTimerHarness();
Stopwatch watch = new Stopwatch();
watch.Start();
watch.Reset();
using (var timer = new VersionedTimer <int>(123, harness.Callback))
{
harness.ExpectDelays(75, 150);
timer.Change(75, 150, 1);
watch.Start();
Thread.Sleep(75 + 150 * 4);
for (int i = 1; i <= 5; i++)
{
Assert.IsTrue(harness.Wait(), string.Format("Timer period #{0} never fired.", i));
}
timer.Change(Timeout.Infinite, Timeout.Infinite, 2);
watch.Stop();
TimeSpan elapsed = watch.Elapsed;
int numFirings = (int)((elapsed.TotalMilliseconds - 75.0) / 150.0) + 1;
Assert.AreEqual(123, harness.ObservedState, 123, "Timer fired with wrong state.");
Assert.AreEqual(1, harness.ObservedVersion, "Timer fired with wrong version.");
Assert.AreEqual(numFirings, harness.Callbacks, "Timer fired wrong number of times.");
Assert.AreEqual(0, harness.TimeoutError.TotalMilliseconds, 30, "Timer timeout was inaccurate.");
Assert.AreEqual(0, harness.PeriodErrors.Average(x => x.TotalMilliseconds), 30, "Timer period was inaccurate.");
Assert.AreEqual(0, harness.PeriodErrors.Max(x => x.TotalMilliseconds), 30, "Timer period was inaccurate.");
Trace.WriteLine(string.Format(
"{0} callbacks occurred in {1:0.000} ms.",
harness.Callbacks, elapsed.TotalMilliseconds
));
}
}
public void VerifyObjectDisposedException()
{
VersionedTimer <int> timer;
SimpleTimerHarness harness = new SimpleTimerHarness();
timer = new VersionedTimer <int>(123, harness.Callback);
try
{
timer.Change(10, Timeout.Infinite, 0);
Assert.IsTrue(harness.Wait(), "Timer did not fire.");
}
finally
{
timer.Dispose();
}
Assert2.Throws <ObjectDisposedException>(() =>
{
timer.Change(100, 100, 1);
});
}
public void Change_ViaTimeSpan_SingleShot_Allows_Positive()
{
SimpleTimerHarness harness = new SimpleTimerHarness();
VersionedTimer <int> timer = new VersionedTimer <int>(123, harness.Callback);
using ( timer )
{
timer.Change(MSecs(100), Timeout.InfiniteTimeSpan, 1);
timer.Change(MSecs(200), Timeout.InfiniteTimeSpan, 1);
for (int i = 1; i <= 100; i++)
{
timer.Change(MSecs(100 + i), Timeout.InfiniteTimeSpan, 1);
}
timer.Change(MSecs(int.MaxValue), Timeout.InfiniteTimeSpan, 1);
timer.Change(VTimeout.MaxTimeout, Timeout.InfiniteTimeSpan, 1);
timer.Change(TimeSpan.Zero, VTimeout.MaxTimeout, 1);
timer.Change(VTimeout.MaxTimeout, VTimeout.MaxTimeout, 1);
}
}
public void Change_ViaInts_DoesNotAllowNegative_Period()
{
SimpleTimerHarness harness = new SimpleTimerHarness();
VersionedTimer <int> timer = new VersionedTimer <int>(123, harness.Callback);
using ( timer )
{
Assert2.Throws <ArgumentException>(() =>
{
timer.Change(0, -2, 0);
});
Assert2.Throws <ArgumentException>(() =>
{
timer.Change(0, -3, 0);
});
Assert2.Throws <ArgumentException>(() =>
{
timer.Change(0, int.MinValue, 0);
});
}
}
public void Change_ViaTimeSpan_DoesNotAllow_ExcessiveSpan()
{
SimpleTimerHarness harness = new SimpleTimerHarness();
VersionedTimer <int> timer = new VersionedTimer <int>(123, harness.Callback);
using ( timer )
{
Assert2.Throws <ArgumentException>(() =>
{
timer.Change(excessiveSpan, Timeout.InfiniteTimeSpan, 0);
});
Assert2.Throws <ArgumentException>(() =>
{
timer.Change(TimeSpan.Zero, excessiveSpan, 0);
});
Assert2.Throws <ArgumentException>(() =>
{
timer.Change(excessiveSpan, excessiveSpan, 0);
});
}
}
