public void Deque_AddToBack_AddsItemInOrder()
{
Deque <int> q = new Deque <int>();
q.AddToBack(13);
q.AddToBack(17);
Assert.AreEqual(2, q.Count, "Deque should remember its items");
Assert.IsTrue(q.SequenceEqual(new[] { 13, 17 }), "Deque should remember its items");
}
public void Constructor_CapacityOf0_PermitsAdd()
{
var deque = new Deque <int>(0);
deque.AddToBack(13);
Assert.Equal(new[] { 13 }, deque);
}
public void Insert_AtCount_IsSameAsAddToBack()
{
var deque1 = new Deque <int>(new[] { 1, 2 });
var deque2 = new Deque <int>(new[] { 1, 2 });
deque1.Insert(deque1.Count, 0);
deque2.AddToBack(0);
Assert.Equal(deque1, deque2);
}
public void Add_IsAddToBack()
{
var deque1 = new Deque <int>(new[] { 1, 2 });
var deque2 = new Deque <int>(new[] { 1, 2 });
((ICollection <int>)deque1).Add(3);
deque2.AddToBack(3);
Assert.Equal(deque1, deque2);
}
public void ToArray_CopiesToNewArray()
{
var deque = new Deque <int>(new[] { 0, 1 });
deque.AddToBack(13);
var result = deque.ToArray();
Assert.Equal(new[] { 0, 1, 13 }, result);
}
public void Capacity_Set_WhenSplit_PreservesData()
{
var deque = new Deque <int>(new int[] { 1, 2, 3 });
deque.RemoveFromFront();
deque.AddToBack(4);
Assert.Equal(3, deque.Capacity);
deque.Capacity = 7;
Assert.Equal(7, deque.Capacity);
Assert.Equal(new[] { 2, 3, 4 }, deque);
}
private void InsertTest(IReadOnlyCollection <int> initial, IReadOnlyCollection <int> items)
{
var totalCapacity = initial.Count + items.Count;
for (int rotated = 0; rotated <= totalCapacity; ++rotated)
{
for (int index = 0; index <= initial.Count; ++index)
{
// Calculate the expected result using the slower List<int>.
var result = new List <int>(initial);
for (int i = 0; i != rotated; ++i)
{
var item = result[0];
result.RemoveAt(0);
result.Add(item);
}
result.InsertRange(index, items);
// First, start off the deque with the initial items.
var deque = new Deque <int>(initial);
// Ensure there's enough room for the inserted items.
deque.Capacity += items.Count;
// Rotate the existing items.
for (int i = 0; i != rotated; ++i)
{
var item = deque[0];
deque.RemoveFromFront();
deque.AddToBack(item);
}
// Do the insert.
deque.InsertRange(index, items);
// Ensure the results are as expected.
Assert.Equal(result, deque);
}
}
}
private void RemoveTest(IReadOnlyCollection <int> initial)
{
for (int count = 0; count <= initial.Count; ++count)
{
for (int rotated = 0; rotated <= initial.Count; ++rotated)
{
for (int index = 0; index <= initial.Count - count; ++index)
{
// Calculated the expected result using the slower List<int>.
var result = new List <int>(initial);
for (int i = 0; i != rotated; ++i)
{
var item = result[0];
result.RemoveAt(0);
result.Add(item);
}
result.RemoveRange(index, count);
// First, start off the deque with the initial items.
var deque = new Deque <int>(initial);
// Rotate the existing items.
for (int i = 0; i != rotated; ++i)
{
var item = deque[0];
deque.RemoveFromFront();
deque.AddToBack(item);
}
// Do the remove.
deque.RemoveRange(index, count);
// Ensure the results are as expected.
Assert.Equal(result, deque);
}
}
}
}
