/// <summary> /// Add the specified ticked object to the queue, using currentTime as the time to use for the tick check. /// </summary> /// <param name='ticked'> /// The ITicked object. /// </param> /// <param name='currentTime'> /// Current time. Doesn't have to be the real time. /// </param> /// <param name='looped'> /// Sets whether the ticked item will be called once, or looped. /// </param> public void Add(ITicked ticked, DateTime currentTime, bool looped) { TickedQueueItem item = new TickedQueueItem(ticked, currentTime); item.Loop = looped; Add(item, currentTime); }
public void TestTickTimeReset() { TickedObject obj = new TickedObject(null); obj.Priority = 6; obj.TickLength = 7; var now = DateTime.UtcNow; TickedQueueItem item = new TickedQueueItem(obj, now); Assert.AreEqual(item.NextTickTime, now.AddSeconds(obj.TickLength), "Initial next tick time did not match"); var future = now.AddSeconds(3); item.ResetTickFromTime(future); Assert.AreEqual(item.NextTickTime, future.AddSeconds(obj.TickLength), "Next tick time did not match after reset"); }
public void TestTimeCompare() { var a = new TickedObject(Callback, 2, 0) {Priority = 2}; var b = new TickedObject(Callback, 1, 1) {Priority = 2}; var itemA = new TickedQueueItem(a, DateTime.UtcNow); var itemB = new TickedQueueItem(b, DateTime.UtcNow.AddSeconds(2)); var comparer = new TickedQueueItemComparer(); Assert.AreEqual(-1, comparer.Compare(itemA, itemB), "A should be lower due to earlier tick time"); b.Priority = 1; itemB = new TickedQueueItem(b); Assert.AreEqual(1, comparer.Compare(itemA, itemB), "B should be sorted lower due to the priority"); }
public void TestTickTimeCompare() { var a = new TickedObject(Callback, 2, 0) {Priority = 2}; var b = new TickedObject(Callback, 1, 1) {Priority = 2}; var itemA = new TickedQueueItem(a); var itemB = new TickedQueueItem(b); var comparer = new TickedQueueItemComparer(); Assert.AreEqual(1, comparer.Compare(itemA, itemB), "B should be lower due to lower tick time"); a.Priority = 1; itemA = new TickedQueueItem(a); Assert.AreEqual(-1, comparer.Compare(itemA, itemB), "A should be sorted lower due to the priority"); }
/// <summary> /// Add the specified item and currentTime. /// </summary> /// <param name='item'> /// The TickedQueueItem element to add to the list. /// </param> /// <param name='currentTime'> /// Current time. Doesn't have to be the real time. /// </param> /// <remarks> /// Notice that unlike the two public methods that receive an ITicked, /// this one expects a TickedQueueItem. It was done to avoid having to /// discard a TickedQueueItem instance every time that a looped item is /// ticked and re-added to the queue. As such, it expects to already /// have been configured for if to loop or not. /// </remarks> private void Add(TickedQueueItem item, DateTime currentTime) { item.ResetTickFromTime(currentTime); int index = _queue.BinarySearch(item, new TickedQueueItemComparer()); //if the binary search doesn't find something identical, it'll return a //negative value signifying where the new item should reside, so bitflipping //that gives the new index if (index < 0) { index = ~index; } _queue.Insert(index, item); }
public void TestEqualTimeCompare() { var a = new TickedObject(Callback); var b = new TickedObject(Callback); var time = DateTime.UtcNow; //forcing the time used so that there isn't any difference in the two calls var itemA = new TickedQueueItem(a, time); var itemB = new TickedQueueItem(b, time); // For items with equal times and priorities, we will state that the // first item is always lower than the second, so that the second is // always placed later in the queue var comparer = new TickedQueueItemComparer(); Assert.AreEqual(-1, comparer.Compare(itemA, itemB), "Comparison should yield lower for a"); }
public void TestCase () { TickedObject obj = new TickedObject(null); obj.Priority = 6; obj.TickLength = 7; TickedQueueItem item = new TickedQueueItem(obj); Assert.AreEqual(item.Priority, obj.Priority, "TickedQueueItem should report the same priority as the wrapped object"); DateTime testTime = DateTime.UtcNow; Assert.IsFalse(item.CheckTickReady(testTime), "CheckTickReady should return false when time is before next scheduled tick"); DateTime testTimePlus4 = testTime.AddSeconds(4); Assert.IsFalse(item.CheckTickReady(testTimePlus4), "CheckTickReady should return false when time is before next scheduled tick"); DateTime testTimePlus8 = testTime.AddSeconds(8); Assert.IsTrue(item.CheckTickReady(testTimePlus8), "CheckTickReady should return true when time is after next scheduled tick"); }
public void TestTimeCompare() { TickedObject a = new TickedObject(Callback, 0); a.Priority = 2; a.TickLength = 2; TickedObject b = new TickedObject(Callback, 1); b.Priority = 2; b.TickLength = 1; TickedQueueItem itemA = new TickedQueueItem(a, DateTime.UtcNow); TickedQueueItem itemB = new TickedQueueItem(b, DateTime.UtcNow.AddSeconds(2)); TickedQueueItemComparer comparer = new TickedQueueItemComparer(); Assert.AreEqual(-1, comparer.Compare(itemA, itemB), "A should be lower due to earlier tick time"); b.Priority = 1; itemB = new TickedQueueItem(b); Assert.AreEqual(1, comparer.Compare(itemA, itemB), "B should be sorted lower due to the priority"); }
public void TestPriorityCompare() { TickedObject a = new TickedObject(Callback, 0); a.Priority = 5; TickedObject b = new TickedObject(Callback, 1); b.Priority = 2; DateTime time = DateTime.UtcNow; //forcing the time used so that there isn't any difference in the two calls TickedQueueItem itemA = new TickedQueueItem(a, time); TickedQueueItem itemB = new TickedQueueItem(b, time); TickedQueueItemComparer comparer = new TickedQueueItemComparer(); Assert.AreEqual(1, comparer.Compare(itemA, itemB), "Comparison should yield lower for a"); Assert.AreEqual(-1, comparer.Compare(itemB, itemA), "Reverse comparison should yield lower for b"); a.Priority = 2; itemA = new TickedQueueItem(a, time); Assert.AreEqual(0, comparer.Compare(itemA, itemB), "Identical priorities should give equal comparison - {0} {1}", itemA); }
public void TestCase() { TickedObject obj = new TickedObject(null); obj.Priority = 6; obj.TickLength = 7; TickedQueueItem item = new TickedQueueItem(obj); Assert.AreEqual(item.Priority, obj.Priority, "TickedQueueItem should report the same priority as the wrapped object"); DateTime testTime = DateTime.UtcNow; Assert.IsFalse(item.CheckTickReady(testTime), "CheckTickReady should return false when time is before next scheduled tick"); DateTime testTimePlus4 = testTime.AddSeconds(4); Assert.IsFalse(item.CheckTickReady(testTimePlus4), "CheckTickReady should return false when time is before next scheduled tick"); DateTime testTimePlus8 = testTime.AddSeconds(8); Assert.IsTrue(item.CheckTickReady(testTimePlus8), "CheckTickReady should return true when time is after next scheduled tick"); }
public void TestPriorityCompare() { var a = new TickedObject(Callback, 0, 0) {Priority = 5}; var b = new TickedObject(Callback, 0, 1) {Priority = 2}; var time = DateTime.UtcNow; //forcing the time used so that there isn't any difference in the two calls var itemA = new TickedQueueItem(a, time); var itemB = new TickedQueueItem(b, time); var comparer = new TickedQueueItemComparer(); Assert.AreEqual(1, comparer.Compare(itemA, itemB), "Comparison should yield lower for a"); Assert.AreEqual(-1, comparer.Compare(itemB, itemA), "Reverse comparison should yield lower for b"); a.Priority = b.Priority; // For items with equal times and priorities, we will state that the // first item is always lower than the second, so that the second is // always placed later in the queue itemA = new TickedQueueItem(a, time); Assert.AreEqual(-1, comparer.Compare(itemA, itemB), "Expected ItemA would be deemed lower - {0} {1}", itemA, itemB); }
/// <summary> /// Add the specified item and currentTime. /// </summary> /// <param name='item'> /// The TickedQueueItem element to add to the list. /// </param> /// <param name='currentTime'> /// Current time. Doesn't have to be the real time. /// </param> /// <remarks> /// Notice that unlike the two public methods that receive an ITicked, /// this one expects a TickedQueueItem. It was done to avoid having to /// discard a TickedQueueItem instance every time that a looped item is /// ticked and re-added to the queue. As such, it expects to already /// have been configured for if to loop or not. /// </remarks> private void Add(TickedQueueItem item, DateTime currentTime) { item.ResetTickFromTime(currentTime); int index = _queue.BinarySearch(item, new TickedQueueItemComparer()); //if the binary search doesn't find something identical, it'll return a //negative value signifying where the new item should reside, so bitflipping //that gives the new index if (index < 0) index = ~index; _queue.Insert(index, item); }
/// <summary> /// Add the specified ticked object to the queue, using currentTime as the time to use for the tick check. /// </summary> /// <param name='ticked'> /// The ITicked object. /// </param> /// <param name='currentTime'> /// Current time. Doesn't have to be the real time. /// </param> /// <param name='looped'> /// Sets whether the ticked item will be called once, or looped. /// </param> public void Add(ITicked ticked, DateTime currentTime, bool looped) { var item = new TickedQueueItem(ticked, currentTime, looped); Add(item, currentTime); }
/// <summary> /// Add the specified item and currentTime. /// </summary> /// <param name='item'> /// The TickedQueueItem element to add to the list. /// </param> /// <param name='currentTime'> /// Current time. Doesn't have to be the real time. /// </param> /// <remarks> /// Notice that unlike the two public methods that receive an ITicked, /// this one expects a TickedQueueItem. It was done to avoid having to /// discard a TickedQueueItem instance every time that a looped item is /// ticked and re-added to the queue. As such, it expects to already /// have been configured for if to loop or not. /// </remarks> private void Add(TickedQueueItem item, DateTime currentTime) { item.ResetTickFromTime(currentTime); _queue.Add(item); }