public void PrioritizedNodeTests_Constructor() { var prioritizable = new Prioritizable(1.21f); var node = new PrioritizedNode <Prioritizable>(prioritizable); Assert.That(ReferenceEquals(node.Data, prioritizable), Is.True); }
public void SamplesItemsWhenSizeLimitReached_AddIEnumerable() { const int reservoirSize = 100; const int lowerPriority = 100; const int higherPriority = 300; const float priorityShift = 0.001f; //Concurrent Priority Queue will only hold NumberOfItemsToAddInitially items. ConcurrentPriorityQueue.Resize(reservoirSize); var higherPriorityItemsToAdd = new PrioritizedNode <TestModel> [reservoirSize]; var itemsToAddInitially = new PrioritizedNode <TestModel> [reservoirSize]; for (var i = 0; i < reservoirSize; ++i) { itemsToAddInitially[i] = Create((i + lowerPriority) * priorityShift); higherPriorityItemsToAdd[i] = Create((i + higherPriority) * priorityShift); } ConcurrentPriorityQueue.Add(itemsToAddInitially); //make sure they are all accounted for Assert.That(ConcurrentPriorityQueue.Count, Is.EqualTo(reservoirSize)); ConcurrentPriorityQueue.Add(higherPriorityItemsToAdd); //make sure the size is not over Assert.That(ConcurrentPriorityQueue.Count, Is.EqualTo(reservoirSize)); foreach (var item in ConcurrentPriorityQueue) { Assert.That(item.Data.Priority, Is.GreaterThanOrEqualTo(higherPriority * priorityShift)); } }
public void PrioritizedNodeTests_SamePriorityHashCodesDiffer() { var node1 = new PrioritizedNode <Prioritizable>(new Prioritizable(1.21f)); var node2 = new PrioritizedNode <Prioritizable>(new Prioritizable(1.21f)); Assert.That(node1.GetHashCode(), Is.Not.EqualTo(node2.GetHashCode())); }
public void PrioritizedNodeTests_DifferentPriorityABAStartLow() { var node1 = new PrioritizedNode <Prioritizable>(new Prioritizable(1.21f)); var node2 = new PrioritizedNode <Prioritizable>(new Prioritizable(5.75f)); var node3 = new PrioritizedNode <Prioritizable>(new Prioritizable(1.21f)); //node2 < node1 < node3 Assert.Multiple(() => { Assert.That(node1 > node2, Is.True); Assert.That(node1 >= node2, Is.True); Assert.That(node1 < node2, Is.False); Assert.That(node1 <= node2, Is.False); Assert.That(node1 == node2, Is.False); Assert.That(node1 != node2, Is.True); Assert.That(node1 > node3, Is.False); Assert.That(node1 >= node3, Is.False); Assert.That(node1 < node3, Is.True); Assert.That(node1 <= node3, Is.True); Assert.That(node1 == node3, Is.False); Assert.That(node1 != node3, Is.True); Assert.That(node2 > node3, Is.False); Assert.That(node2 >= node3, Is.False); Assert.That(node2 < node3, Is.True); Assert.That(node2 <= node3, Is.True); Assert.That(node2 == node3, Is.False); Assert.That(node2 != node3, Is.True); } ); }
public void PrioritizedNodeTests_SamePriorityInequalityAsNull() { var node1 = new PrioritizedNode <Prioritizable>(new Prioritizable(1.21f)); object node2 = null; Assert.That(node1.CompareTo(node2), Is.EqualTo(1)); }
public void PrioritizedNodeTests_SamePriorityInequalityAsWrongObject() { var node1 = new PrioritizedNode <Prioritizable>(new Prioritizable(1.21f)); var node2 = (object)new StringBuilder(); Assert.That(() => node1.CompareTo(node2), Throws.ArgumentException); }
public void PrioritizedNodeTests_SamePriorityInequalityNull() { var node1 = new PrioritizedNode <Prioritizable>(new Prioritizable(1.21f)); var node2 = (PrioritizedNode <Prioritizable>)null; Assert.Multiple(() => { Assert.That(() => node1 > null, Throws.ArgumentNullException); Assert.That(() => node1 >= null, Throws.ArgumentNullException); Assert.That(() => node1 <= null, Is.False); Assert.That(() => node1 < null, Is.False); Assert.That(() => null > node1, Is.False); Assert.That(() => null >= node1, Is.False); Assert.That(() => null <= node1, Throws.ArgumentNullException); Assert.That(() => null < node1, Throws.ArgumentNullException); Assert.That(() => node1 > node2, Throws.ArgumentNullException); Assert.That(() => node1 >= node2, Throws.ArgumentNullException); Assert.That(() => node1 <= node2, Is.False); Assert.That(() => node1 < node2, Is.False); Assert.That(() => node2 > node1, Is.False); Assert.That(() => node2 >= node1, Is.False); Assert.That(() => node2 <= node1, Throws.ArgumentNullException); Assert.That(() => node2 < node1, Throws.ArgumentNullException); }); }
public void PrioritizedNodeTests_identityOperatorEqual() { var node1 = new PrioritizedNode <Prioritizable>(new Prioritizable(1.21f)); #pragma warning disable CS1718 // Comparison made to same variable var result = node1 == node1; #pragma warning restore CS1718 // Comparison made to same variable Assert.That(result, Is.True); }
public void PrioritizedNodeTests_SamePriorityNotEqual() { var node1 = new PrioritizedNode <Prioritizable>(new Prioritizable(1.21f)); var node2 = new PrioritizedNode <Prioritizable>(new Prioritizable(1.21f)); Assert.That(node1, Is.Not.EqualTo(node2)); var result = node1 != node2; Assert.That(result, Is.True); }
public void PrioritizedNodeTests_SamePriorityInequalityAsObject() { var node1 = new PrioritizedNode <Prioritizable>(new Prioritizable(1.21f)); var node2 = (object)new PrioritizedNode <Prioritizable>(new Prioritizable(1.21f)); var result = node1.CompareTo(node2); Assert.Multiple(() => { Assert.That(result, Is.EqualTo(-1)); }); }
public void PrioritizedNodeTests_SamePriorityInequality() { var node1 = new PrioritizedNode <Prioritizable>(new Prioritizable(1.21f)); var node2 = new PrioritizedNode <Prioritizable>(new Prioritizable(1.21f)); var resultGreaterthan = node1 > node2; var resultGreaterthanorequal = node1 >= node2; var resultLessthan = node1 < node2; var resultLessthanorequal = node1 <= node2; Assert.Multiple(() => { Assert.That(resultGreaterthan, Is.False); Assert.That(resultGreaterthanorequal, Is.False); Assert.That(resultLessthan, Is.True); Assert.That(resultLessthanorequal, Is.True); }); }
private static void ExerciseFullApi(IResizableCappedCollection <PrioritizedNode <TestModel> > concurrentPriorityQueue, PrioritizedNode <TestModel>[] eventsToAdd, int countOfThreads) { // Add the new events foreach (var evt in eventsToAdd) { concurrentPriorityQueue.Add(evt); } //make sure each of the new events can be found (tests equality op) foreach (var ev in eventsToAdd) { Assert.That(concurrentPriorityQueue, Contains.Item(ev)); } //copy the CPQ to an array var destinationArray = new PrioritizedNode <TestModel> [eventsToAdd.Count() * countOfThreads]; concurrentPriorityQueue.CopyTo(destinationArray, 0); //check that the copied contents contains our events foreach (var ev in eventsToAdd) { Assert.That(destinationArray, Contains.Item(ev)); } //count how many are actually in the destinationArray var nonnullCount = 0; while (nonnullCount < destinationArray.Length && null != destinationArray[nonnullCount]) { ++nonnullCount; } //make sure the array is sorted properly for (var index = 1; index < nonnullCount; ++index) { Assert.That(destinationArray[index - 1].Data.Priority, Is.GreaterThanOrEqualTo(destinationArray[index].Data.Priority)); } //make sure that remove is not supported Assert.That(() => concurrentPriorityQueue.Remove(eventsToAdd[0]), Throws.TypeOf <NotSupportedException>()); }
public void PrioritizedNodeTests_DifferentPrioritySecondLower() { var node1 = new PrioritizedNode <Prioritizable>(new Prioritizable(5.75f)); var node2 = new PrioritizedNode <Prioritizable>(new Prioritizable(1.21f)); //node1 < node2 var resultGreaterthan = node1 > node2; var resultGreaterthanorequal = node1 >= node2; var resultLessthan = node1 < node2; var resultLessthanorequal = node1 <= node2; var resultEqual = node1 == node2; var resultNotEqual = node1 != node2; Assert.Multiple(() => { Assert.That(resultGreaterthan, Is.False); Assert.That(resultGreaterthanorequal, Is.False); Assert.That(resultLessthan, Is.True); Assert.That(resultLessthanorequal, Is.True); Assert.That(resultEqual, Is.False); Assert.That(resultNotEqual, Is.True); }); }
public void SamplesItemsWhenSizeLimitReached() { const int numberOfItemsToAddInitially = 100; const int numberOfItemsToAddAfterReservoirLimitReached = 100; //Concurrent Priority Queue will only hold NumberOfItemsToAddInitially items. ConcurrentPriorityQueue.Resize(numberOfItemsToAddInitially); var itemsToAddInitially = new PrioritizedNode <TestModel> [numberOfItemsToAddInitially]; for (var i = 0; i < numberOfItemsToAddInitially; ++i) { itemsToAddInitially[i] = Create(i * 0.001f); } //fill the CPQ with values 100-199 foreach (var itemToAdd in itemsToAddInitially) { Assert.IsTrue(ConcurrentPriorityQueue.Add(itemToAdd), "failed to add initial value"); } //make sure they are all accounted for Assert.AreEqual(ConcurrentPriorityQueue.Count, numberOfItemsToAddInitially); //now add more items that will cause the items from above to get removed. these will be valued 0-99 (precisely 100 less than those above) for (var i = 0; i < numberOfItemsToAddAfterReservoirLimitReached; ++i) { var itemToAdd = Create((i + 100) * 0.001f); var itemThatWillGetRemoved = itemsToAddInitially[i]; //each one we add will cause the corresponding smaller item to get removed. Assert.IsTrue(ConcurrentPriorityQueue.Add(itemToAdd), "failed to add subsequent value"); Assert.IsTrue(ConcurrentPriorityQueue.Contains(itemToAdd), "added value not found"); Assert.IsFalse(ConcurrentPriorityQueue.Contains(itemThatWillGetRemoved), "initial value did not get removed on addition of subsequent value"); Assert.AreEqual(ConcurrentPriorityQueue.Count, numberOfItemsToAddInitially); } }
public void PrioritizedNodeTests_identityHashCodesSame() { var node1 = new PrioritizedNode <Prioritizable>(new Prioritizable(1.21f)); Assert.That(node1.GetHashCode(), Is.EqualTo(node1.GetHashCode())); }
public void PrioritizedNodeTests_identityEqualTo() { var node1 = new PrioritizedNode <Prioritizable>(new Prioritizable(1.21f)); Assert.That(node1, Is.EqualTo(node1)); }