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_TimeIsFrozen_AttemptToMoveTimeBackwards()
{
using (var delorean = new Delorean(true))
{
Assert.ThrowsException <ArgumentOutOfRangeException>(
() => delorean.Advance(TimeSpan.FromMilliseconds(-1)));
}
}
public void Advance_Int32_TimeIsNotFrozen_ThrowsException()
{
using (var delorean = new Delorean(false))
{
Assert.ThrowsException <InvalidOperationException>(
() => delorean.Advance(1));
}
}
public void Advance_TimeSpan_TimeIsNotFrozen_ThrowsException()
{
using (var delorean = new Delorean(false))
{
Assert.ThrowsException <InvalidOperationException>(
() => delorean.Advance(TimeSpan.FromMilliseconds(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_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 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 Callback_UInt32_MultipleIntervalHitInSingleAdvance()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
object expectedState = new object();
int fired = 0;
using (var timer = TimeProvider.Timer((state) => { fired++; }, null, 100u, 50u))
{
delorean.Advance(100);
Assert.AreEqual(1, fired);
delorean.Advance(150);
Assert.AreEqual(4, fired);
}
}
}
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 Change_UInt32_HasInitialAndInterval()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
int fired = 0;
using (var timer = TimeProvider.Timer((state) => { fired++; }))
{
timer.Change(100u, 100u);
delorean.Advance(100);
Assert.AreEqual(1, fired);
delorean.Advance(100);
Assert.AreEqual(2, fired);
}
}
}
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_Int64_HasInitialGreaterThanInterval()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
int fired = 0;
using (var timer = TimeProvider.Timer((state) => fired++, null, 100L, 50L))
{
delorean.Advance(50);
Assert.AreEqual(0, fired);
delorean.Advance(50);
Assert.AreEqual(1, fired);
delorean.Advance(50);
Assert.AreEqual(2, fired);
}
}
}
public void Callback_TimeSpan_HasInitialGreaterThanInterval()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
int fired = 0;
using (var timer = TimeProvider.Timer((state) => fired++, null, TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(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_TimeSpan_HasInitialAndIntervalHitInSingleAdvance()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
int fired = 0;
using (var timer = TimeProvider.Timer((state) => { fired++; }, null, TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(50)))
{
delorean.Advance(200);
Assert.AreEqual(3, fired);
}
}
}
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_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_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 Change_TimeSpan_HasIntervalButNotInitial()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
int fired = 0;
using (var timer = TimeProvider.Timer((state) => { fired++; }))
{
timer.Change(TimeSpan.FromMilliseconds(-1), TimeSpan.FromMilliseconds(50));
delorean.Advance(1000);
Assert.AreEqual(0, fired);
}
}
}
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_Int64_HasIntervalButNotInitial()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
int fired = 0;
using (var timer = TimeProvider.Timer((state) => { fired++; }))
{
timer.Change(-1L, 50L);
delorean.Advance(1000);
Assert.AreEqual(0, fired);
}
}
}
public void Thawed_InitialHit_HasInterval_UsesInterval()
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
using (var evt = new AutoResetEvent(false))
using (var timer = TimeProvider.Timer((state) => evt.Set(), null, 250, 25))
{
delorean.Advance(250);
evt.Reset();
delorean.Thaw();
Assert.IsTrue(evt.WaitOne(100));
}
}
}
public void Change_TimeSpan_HasInitialButNotInterval(long period)
{
using (var delorean = new Delorean(true))
{
delorean.Freeze();
var fired = 0;
using (var timer = TimeProvider.Timer((state) => fired++))
{
timer.Change(TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(period));
delorean.Advance(1000);
Assert.AreEqual(1, fired);
}
}
}
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_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);
}
}
}