public void Callback_Int32_HasInitialAndInterval()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
object expectedState = new object();
int fired = 0;
object actualState = null;
using (var timer = TimeProvider.Timer((state) => { actualState = state; fired++; }, expectedState, 100, 100))
{
delorean.Advance(100);
Assert.AreEqual(1, fired);
Assert.AreSame(expectedState, actualState);
actualState = null;
delorean.Advance(100);
Assert.AreEqual(2, fired);
Assert.AreSame(expectedState, actualState);
actualState = null;
delorean.Advance(100);
Assert.AreEqual(3, fired);
Assert.AreSame(expectedState, actualState);
}
}
}
public void Change_Int32_HasInitialGreaterThanInterval()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
int fired = 0;
using (var timer = TimeProvider.Timer((state) => fired++))
{
timer.Change(100, 50);
delorean.Advance(50);
Assert.AreEqual(0, fired);
delorean.Advance(50);
Assert.AreEqual(1, fired);
delorean.Advance(50);
Assert.AreEqual(2, fired);
}
}
}
public void Callback_UInt32_HasInitialButNotInterval(uint period)
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
object expectedState = new object();
var fired = 0;
object actualState = null;
using (var timer = TimeProvider.Timer((state) => { actualState = state; fired++; }, expectedState, 100u, period))
{
delorean.Advance(100);
Assert.AreEqual(1, fired);
Assert.AreSame(expectedState, actualState);
actualState = null;
delorean.Advance(100);
Assert.AreEqual(1, fired);
Assert.IsNull(actualState);
}
}
}
public void Advance_TimeSpan_TimeIsNotFrozen_ThrowsException()
{
using (var delorean = new Delorean(false))
{
Assert.ThrowsException <InvalidOperationException>(
() => delorean.Advance(TimeSpan.FromMilliseconds(1)));
}
}
public void Advance_TimeSpan_TimeIsFrozen_AttemptToMoveTimeBackwards()
{
using (var delorean = new Delorean(true))
{
Assert.ThrowsException <ArgumentOutOfRangeException>(
() => delorean.Advance(TimeSpan.FromMilliseconds(-1)));
}
}
public void Callback_Int32_Invalid(int initial, int period)
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
Assert.ThrowsException <ArgumentOutOfRangeException>(() => TimeProvider.Timer((state) => { }, null, initial, period));
}
}
public void Callback_TimeSpan_Invalid(long initial, long period)
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
Assert.ThrowsException <ArgumentOutOfRangeException>(() => TimeProvider.Timer((state) => { }, null, TimeSpan.FromMilliseconds(initial), TimeSpan.FromMilliseconds(period)));
}
}
public void Advance_Int32_TimeIsNotFrozen_ThrowsException()
{
using (var delorean = new Delorean(false))
{
Assert.ThrowsException <InvalidOperationException>(
() => delorean.Advance(1));
}
}
public void Frozen_Int32_InvalidWait()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
Assert.ThrowsException <ArgumentOutOfRangeException>(() => TimeProvider.Delay(-2));
}
}
public void Change_Int64_Invalid(long initial, long period)
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
var timer = TimeProvider.Timer((state) => { });
Assert.ThrowsException <ArgumentOutOfRangeException>(() => timer.Change(initial, period));
}
}
public void Frozen_TimeSpan_InvalidWait(double milliseconds)
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
Assert.ThrowsException <ArgumentOutOfRangeException>(() => TimeProvider.Delay(TimeSpan.FromMilliseconds(milliseconds)));
}
}
public void Callback_CallbackIsNull()
{
using (var delorean = new Delorean(true))
{
Assert.ThrowsException <ArgumentNullException>(() => TimeProvider.Timer(null));
Assert.ThrowsException <ArgumentNullException>(() => TimeProvider.Timer(null, null, 0, 0));
Assert.ThrowsException <ArgumentNullException>(() => TimeProvider.Timer(null, null, 0u, 0u));
Assert.ThrowsException <ArgumentNullException>(() => TimeProvider.Timer(null, null, TimeSpan.Zero, TimeSpan.Zero));
Assert.ThrowsException <ArgumentNullException>(() => TimeProvider.Timer(null, null, 0L, 0L));
}
}
public async Task Frozen_TimeSpan_NoDelay_ReturnsImmediately(double milliseconds)
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
var delay = TimeProvider.Delay(TimeSpan.FromMilliseconds(milliseconds));
Assert.IsTrue(delay.Wait(1));
await delay;
}
}
public async Task Frozen_Int32_NoDelay_ReturnsImmediately()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
var delay = TimeProvider.Delay(0);
Assert.IsTrue(delay.Wait(1));
await delay;
}
}
public void Advance_StepByTimeSpan()
{
using (var delorean = new Delorean(true))
{
var firstNow = TimeProvider.UtcNow;
delorean.Advance(TimeSpan.FromSeconds(1.0));
var secondNow = TimeProvider.UtcNow;
Assert.AreEqual(TimeSpan.TicksPerSecond, (secondNow - firstNow).Ticks);
}
}
public void Frozen_TimeSpan_Infinite_NeverReturns(double milliseconds)
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
var delay = TimeProvider.Delay(TimeSpan.FromMilliseconds(milliseconds));
delorean.Advance(DateTime.MaxValue - TimeProvider.UtcNow);
Assert.IsFalse(delay.Wait(1));
}
}
public void Frozen_Int32_Infinite_NeverReturns()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
var delay = TimeProvider.Delay(-1);
delorean.Advance(DateTime.MaxValue - TimeProvider.UtcNow);
Assert.IsFalse(delay.Wait(1));
}
}
public void Advance_StepBySingleMillisecond()
{
using (var delorean = new Delorean(true))
{
var firstNow = TimeProvider.UtcNow;
delorean.Advance(1);
var secondNow = TimeProvider.UtcNow;
Assert.AreEqual(TimeSpan.TicksPerMillisecond, (secondNow - firstNow).Ticks);
}
}
public void Thaw_ReturnsToNormalTime()
{
using (var delorean = new Delorean(true))
{
delorean.Advance(10);
var firstNow = TimeProvider.UtcNow;
delorean.Thaw();
var secondNow = TimeProvider.UtcNow;
Assert.IsTrue(firstNow > secondNow);
}
}
public void Callback_UInt32_HasInitialAndIntervalHitInSingleAdvance()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
int fired = 0;
using (var timer = TimeProvider.Timer((state) => { fired++; }, null, 100u, 50u))
{
delorean.Advance(200);
Assert.AreEqual(3, fired);
}
}
}
public void Callback_TimeSpan_HasIntervalButNotInitial()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
int fired = 0;
using (var timer = TimeProvider.Timer((state) => { fired++; }, null, TimeSpan.FromMilliseconds(-1), TimeSpan.FromMilliseconds(50)))
{
delorean.Advance(1000);
Assert.AreEqual(0, fired);
}
}
}
public void Callback_UInt32_HasIntervalButNotInitial()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
int fired = 0;
using (var timer = TimeProvider.Timer((state) => { fired++; }, null, uint.MaxValue, 50u))
{
delorean.Advance(1000);
Assert.AreEqual(0, fired);
}
}
}
public async Task Frozen_Int32_CancellationTokenStartsCancelled()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
var token = new CancellationToken(true);
var assert = Assert.ThrowsExceptionAsync <TaskCanceledException>(
async() => await TimeProvider.Delay(5, token));
Assert.IsTrue(assert.Wait(100));
await assert;
}
}
public async Task Frozen_TimeSpan_CancellationTokenStartsCancelled(double milliseconds)
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
var token = new CancellationToken(true);
var assert = Assert.ThrowsExceptionAsync <TaskCanceledException>(
async() => await TimeProvider.Delay(TimeSpan.FromMilliseconds(milliseconds), token));
Assert.IsTrue(assert.Wait(100));
await assert;
}
}
public async Task Frozen_TimeSpan_FollowsTimeAdvances()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
var watch = Stopwatch.StartNew();
var controlledDelay = TimeProvider.Delay(TimeSpan.FromMilliseconds(500));
delorean.Advance(500);
await controlledDelay;
watch.Stop();
Assert.IsTrue(watch.ElapsedMilliseconds < 100);
}
}
public void Thawed_InitialNotHit_ContinuesRealtime()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
using (var evt = new AutoResetEvent(false))
using (var timer = TimeProvider.Timer((state) => evt.Set(), null, 25, -1))
{
delorean.Thaw();
Assert.IsTrue(evt.WaitOne(50));
Assert.IsFalse(evt.WaitOne(25));
}
}
}
public void Callback_NeverGetsCalled()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
var fired = 0;
object actualState = null;
using (var timer = TimeProvider.Timer((state) => { actualState = state; fired++; }))
{
delorean.Advance(int.MaxValue - 1);
Assert.AreEqual(0, fired);
Assert.IsNull(actualState);
}
}
}
public void Change_Int32_HasInitialAndIntervalHitInSingleAdvance()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
int fired = 0;
using (var timer = TimeProvider.Timer((state) => fired++))
{
timer.Change(100, 50);
delorean.Advance(200);
Assert.AreEqual(3, fired);
}
}
}
public void Change_Int32_HasIntervalButNotInitial()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
int fired = 0;
using (var timer = TimeProvider.Timer((state) => { fired++; }))
{
timer.Change(-1, 50);
delorean.Advance(1000);
Assert.AreEqual(0, fired);
}
}
}
public void Change_UInt32_HasInitialButNotInterval(uint period)
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
var fired = 0;
using (var timer = TimeProvider.Timer((state) => fired++))
{
timer.Change(100u, period);
delorean.Advance(1000);
Assert.AreEqual(1, fired);
}
}
}
