public void TestInsertRemove()
{
FVList <int> list = new FVList <int>(9);
FVList <int> list2 = new FVList <int>(10, 11);
list.Insert(1, 12);
list.Insert(1, list2[0]);
list.Insert(2, list2[1]);
ExpectList(list, 9, 10, 11, 12);
for (int i = 0; i < 9; i++)
{
list.Insert(i, i);
}
ExpectList(list, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
list2 = list;
for (int i = 1; i <= 6; i++)
{
list2.RemoveAt(i);
}
ExpectList(list2, 0, 2, 4, 6, 8, 10, 12);
ExpectList(list, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12); // unchanged
Assert.AreEqual(0, list2.Pop());
list2.Insert(5, -2);
ExpectList(list2, 2, 4, 6, 8, 10, -2, 12);
list2.Insert(5, -1);
ExpectList(list2, 2, 4, 6, 8, 10, -1, -2, 12);
// Test changing items
list = list2;
for (int i = 0; i < list.Count; i++)
{
list[i] = i;
}
ExpectList(list, 0, 1, 2, 3, 4, 5, 6, 7);
ExpectList(list2, 2, 4, 6, 8, 10, -1, -2, 12);
list2.Clear();
ExpectList(list2);
Assert.AreEqual(5, list[5]);
}
public void SimpleTests()
{
// In this simple test, I only add and remove items from the front
// of a FVList, but forking is also tested.
FVList <int> list = new FVList <int>();
Assert.That(list.IsEmpty);
// Adding to VListBlockOfTwo
list = new FVList <int>(10, 20);
ExpectList(list, 10, 20);
list = new FVList <int>();
list.Add(1);
Assert.That(!list.IsEmpty);
list.Add(2);
ExpectList(list, 2, 1);
// A fork in VListBlockOfTwo. Note that list2 will use two VListBlocks
// here but list will only use one.
FVList <int> list2 = list.WithoutFirst(1);
list2.Add(3);
ExpectList(list, 2, 1);
ExpectList(list2, 3, 1);
// Try doubling list2
list2.AddRange(list2);
ExpectList(list2, 3, 1, 3, 1);
// list now uses two arrays
list.Add(4);
ExpectList(list, 4, 2, 1);
// Try doubling list using a different overload of AddRange()
list.AddRange((IList <int>)list);
ExpectList(list, 4, 2, 1, 4, 2, 1);
list = list.WithoutFirst(3);
ExpectList(list, 4, 2, 1);
// Remove(), Pop()
Assert.That(list2.Remove(3));
ExpectList(list2, 1, 3, 1);
Assert.That(!list2.Remove(0));
Assert.AreEqual(1, list2.Pop());
Assert.That(list2.Remove(3));
ExpectList(list2, 1);
Assert.AreEqual(1, list2.Pop());
ExpectList(list2);
AssertThrows <Exception>(delegate() { list2.Pop(); });
// Add many, SubList(). This will fill 3 arrays (sizes 8, 4, 2) and use
// 1 element of a size-16 array. Oh, and test the enumerator.
for (int i = 5; i <= 16; i++)
{
list.Add(i);
}
ExpectList(list, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 2, 1);
list2 = list.WithoutFirst(6);
ExpectListByEnumerator(list2, 10, 9, 8, 7, 6, 5, 4, 2, 1);
AssertThrows <IndexOutOfRangeException>(delegate() { int i = list[-1]; });
AssertThrows <IndexOutOfRangeException>(delegate() { int i = list[15]; });
// IndexOf, contains
Assert.That(list.Contains(11));
Assert.That(!list2.Contains(11));
Assert.That(list[list.IndexOf(2)] == 2);
Assert.That(list[list.IndexOf(1)] == 1);
Assert.That(list[list.IndexOf(15)] == 15);
Assert.That(list.IndexOf(3) == -1);
// PreviousIn(), this[], Front
FVList <int> list3 = list2;
Assert.AreEqual(11, (list3 = list3.PreviousIn(list))[0]);
Assert.AreEqual(12, (list3 = list3.PreviousIn(list))[0]);
Assert.AreEqual(13, (list3 = list3.PreviousIn(list))[0]);
Assert.AreEqual(14, (list3 = list3.PreviousIn(list)).First);
Assert.AreEqual(15, (list3 = list3.PreviousIn(list)).First);
Assert.AreEqual(16, (list3 = list3.PreviousIn(list)).First);
AssertThrows <Exception>(delegate() { list3.PreviousIn(list); });
// Tail
Assert.AreEqual(10, (list3 = list3.WithoutFirst(6))[0]);
Assert.AreEqual(9, (list3 = list3.Tail)[0]);
Assert.AreEqual(8, (list3 = list3.Tail)[0]);
Assert.AreEqual(7, (list3 = list3.Tail).First);
Assert.AreEqual(6, (list3 = list3.Tail).First);
Assert.AreEqual(5, (list3 = list3.Tail).First);
Assert.AreEqual(4, (list3 = list3.Tail)[0]);
Assert.AreEqual(2, (list3 = list3.Tail)[0]);
Assert.AreEqual(1, (list3 = list3.Tail)[0]);
Assert.That((list3 = list3.Tail).IsEmpty);
// list2 is still the same
ExpectList(list2, 10, 9, 8, 7, 6, 5, 4, 2, 1);
// ==, !=, Equals(), AddRange(a, b)
Assert.That(!list2.Equals("hello"));
list3 = list2;
Assert.That(list3.Equals(list2));
Assert.That(list3 == list2);
// This AddRange forks the list. List2 end up with block sizes 8 (3
// used), 8 (3 used), 4, 2.
list2.AddRange(list2, list2.WithoutFirst(3));
ExpectList(list2, 10, 9, 8, 10, 9, 8, 7, 6, 5, 4, 2, 1);
Assert.That(list3 != list2);
// List3 is a sublist of list, but list2 no longer is
Assert.That(list3.PreviousIn(list).First == 11);
AssertThrows <InvalidOperationException>(delegate() { list2.PreviousIn(list); });
list2 = list2.WithoutFirst(3);
Assert.That(list3 == list2);
}