public void SynchronisedDoubleEndedQueueInitialisesWithCollectionCopiedToQueue()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>(items);
Assert.AreEqual(8, deque.Count);
}
public void SynchronisedDoubleEndedQueueContainsReturnsFalseIfItemIsNotInDequeue()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>(items);
Assert.IsFalse(deque.Contains(9));
}
public void SynchronisedDoubleEndedQueueInitialisesWithCollection()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>(items);
Assert.IsNotNull(deque);
}
public void SynchronisedDoubleEndedQueueCopyToThrowsIfArrayIsNull()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>(items);
Assert.Throws <ArgumentNullException>(() => deque.CopyTo(null, 0));
}
public void SynchronisedDoubleEndedQueueTryDequeueAtItemFromBackReturnsFalseIfQueueDoesNotContainItems()
{
var deque = new SynchronisedDeque <int>();
int i;
bool result = deque.TryDequeueAtItemFromBack(out i);
Assert.IsFalse(result);
}
public void SynchronisedDoubleEndedQueueClearRemovesAllItems()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>(items);
deque.Clear();
Assert.AreEqual(0, deque.Count);
}
public void SynchronisedDoubleEndedQueueDequeuingItemBackUpdatesCount()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>(items);
deque.DequeueItemFromBack();
Assert.AreEqual(7, deque.Count);
}
public void SynchronisedDoubleEndedQueueSupportsDequeuingItemFromBackOfQueue()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>(items);
int back = deque.DequeueItemFromBack();
Assert.AreEqual(8, back);
}
public void SynchronisedDoubleEndedQueueCopyToThrowsIfArrayIsLessThanZero()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>(items);
var array = new int[10];
Assert.Throws <ArgumentOutOfRangeException>(() => deque.CopyTo(array, -1));
}
public void SynchronisedDoubleEndedQueueSupportsDequeuingItemFromFrontOfQueue()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>(items);
int front = deque.DequeueItemFromFront();
Assert.AreEqual(1, front);
}
public void SynchronisedDoubleEndedQueueCopyToThrowsIfCountIsGreaterThanArrayLength()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>(items);
var array = new int[5];
Assert.Throws <ArgumentException>(() => deque.CopyTo(array, 0));
}
public void SynchronisedDoubleEndedQueueTryDequeueAtItemFromBackReturnsTrueIfQueueContainsItems()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>(items);
int i;
bool result = deque.TryDequeueAtItemFromBack(out i);
Assert.IsTrue(result);
}
public void SynchronisedDoubleEndedQueueDequeuingItemFromBackUpdatesBack()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>(items);
deque.DequeueItemFromBack();
int newBack = deque.PeekAtItemFromBack();
Assert.AreEqual(7, newBack);
}
public void SynchronisedDoubleEndedQueueTryDequeueAtItemFromBackRemovesItemFromBack()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>(items);
int i;
deque.TryDequeueAtItemFromBack(out i);
Assert.AreEqual(7, deque.Count);
}
public void SynchronisedDoubleEndedQueueTryDequeueAtItemFromFrontGetsItemFromFront()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>(items);
int i;
deque.TryDequeueAtItemFromFront(out i);
Assert.AreEqual(1, i);
}
public void SynchronisedDoubleEndedQueueCopyToCopiesContentsToArray()
{
var items = new[] { "1", "2", "3", "4", "5", "6", "7", "8" };
var deque = new SynchronisedDeque <string>(items);
var array = new string[8];
deque.CopyTo(array, 0);
array.ToList().ForEach(i => Assert.IsNotNull(i));
}
public void SynchronisedDoubleEndedQueueEnqueueItemToFrontDoesNotImpactBackOfQueue()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>(items);
int originalBack = deque.PeekAtItemFromBack();
deque.EnqueueItemToFront(9);
int newBack = deque.PeekAtItemFromBack();
Assert.AreEqual(originalBack, newBack);
}
public void SynchronisedDoubleEndedQueueSupportDequeueingFromBackUntilQueueIsEmptySingleThreaded()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>();
deque.EnqueueRangeToBack(items);
while (!deque.IsEmpty)
{
deque.DequeueItemFromBack();
}
Assert.AreEqual(0, deque.Count);
}
public void SynchronisedDoubleEndedQueueDequeuingItemBackDoesNotImpactFront()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>(items);
int originalFront = deque.PeekAtItemFromFront();
deque.DequeueItemFromBack();
int newFront = deque.PeekAtItemFromFront();
Assert.AreEqual(originalFront, newFront);
}
public void SynchronisedDoubleEndedQueueSupportEnumeration()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>(items);
Assert.DoesNotThrow(() =>
{
foreach (int i in deque)
{
//ignore
}
});
}
public void SynchronisedDoubleEndedQueueEnumerationThrowsIfCollectionIsModified()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>(items);
Assert.Throws <InvalidOperationException>(() =>
{
foreach (int i in deque)
{
deque.DequeueItemFromBack();
}
});
}
public void SynchronisedDoubleEndedQueueSupportsDequeueingFromBackUntilQueueIsEmptyMultiThreaded()
{
var items = new[] { 1, 2, 3, 4, 5, 6, 7, 8 };
var deque = new SynchronisedDeque <int>();
deque.EnqueueRangeToBack(items);
List <Task> tasks = new List <Task>();
for (int i = 0; i < items.Length * 2; i++)
{
tasks.Add(Task.Factory.StartNew(() =>
{
int j;
deque.TryDequeueAtItemFromBack(out j);
}));
}
Assert.DoesNotThrow(() => Task.WaitAll(tasks.ToArray()));
Assert.AreEqual(0, deque.Count);
}
public void SynchronisedDoubleEndedQueuePeekAtItemFromFrontThrowsIfQueueIsEmpty()
{
var deque = new SynchronisedDeque <int>();
Assert.Throws <InvalidOperationException>(() => deque.PeekAtItemFromFront());
}
public void SynchronisedDoubleEndedQueueInitialisesEmpty()
{
var deque = new SynchronisedDeque <int>();
Assert.AreEqual(0, deque.Count);
}
public void SynchronisedDoubleEndedQueueInitialises()
{
var deque = new SynchronisedDeque <int>();
Assert.IsNotNull(deque);
}
