public void TestEmptyListOperations()
{
FWList <int> a = new FWList <int>();
FWList <int> b = new FWList <int>();
a.AddRange(b);
a.InsertRange(0, b);
a.RemoveRange(0, 0);
Assert.That(!a.Remove(0));
Assert.That(a.IsEmpty);
Assert.That(a.WithoutFirst(0).IsEmpty);
a.Add(1);
Assert.That(a.WithoutFirst(1).IsEmpty);
b.AddRange(a);
ExpectList(b, 1);
b.RemoveAt(0);
Assert.That(b.IsEmpty);
b.InsertRange(0, a);
ExpectList(b, 1);
b.RemoveRange(0, 1);
Assert.That(b.IsEmpty);
b.Insert(0, a[0]);
ExpectList(b, 1);
b.Remove(a.First);
Assert.That(b.IsEmpty);
}
public void TestFork()
{
FWList <int> A = new FWList <int>();
A.AddRange(new int[] { 5, 6, 7 });
FWList <int> B = A.Clone();
A.Push(4);
ExpectList(B, 5, 6, 7);
ExpectList(A, 4, 5, 6, 7);
B.Push(-4);
ExpectList(B, -4, 5, 6, 7);
Assert.That(A.WithoutFirst(2) == B.WithoutFirst(2));
}
public void TestMutabilification()
{
// Make a single block mutable
FVList <int> v = new FVList <int>(0, 1);
FWList <int> w = v.ToFWList();
ExpectList(w, 0, 1);
w[0] = 2;
ExpectList(w, 2, 1);
ExpectList(v, 0, 1);
// Make another block, make the front block mutable, then the block-of-2
v.Push(-1);
w = v.ToFWList();
w[0] = 3;
ExpectList(w, 3, 0, 1);
Assert.That(w.WithoutFirst(1) == v.WithoutFirst(1));
w[1] = 2;
ExpectList(w, 3, 2, 1);
Assert.That(w.WithoutFirst(1) != v.WithoutFirst(1));
// Now for a more complicated case: create a long immutable chain by
// using a nasty access pattern, add a mutable block in front, then
// make some of the immutable blocks mutable. This will cause several
// immutable blocks to be consolidated into one mutable block,
// shortening the chain.
v = new FVList <int>(6);
v = v.Add(-1).Tail.Add(5).Add(-1).Tail.Add(4).Add(-1).Tail.Add(3);
v = v.Add(-1).Tail.Add(2).Add(-1).Tail.Add(1).Add(-1).Tail.Add(0);
ExpectList(v, 0, 1, 2, 3, 4, 5, 6);
// At this point, every block in the chain has only one item (it's
// a linked list!) and the capacity of each block is 2.
Assert.AreEqual(7, v.BlockChainLength);
w = v.ToFWList();
w.AddRange(new int[] { 5, 4, 3, 2, 1 });
Assert.AreEqual(w.Count, 12);
ExpectList(w, 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6);
// Indices: 0 1 2 3 4 5 6 7 8 9 10 11
// Blocks: block A | B | C| D| E| F| G| H
Assert.AreEqual(8, w.BlockChainLength);
Assert.AreEqual(4, w.LocalCount);
w[8] = -3;
ExpectList(w, 5, 4, 3, 2, 1, 0, 1, 2, -3, 4, 5, 6);
// Blocks: block A | block I | F| G| H
Assert.AreEqual(5, w.BlockChainLength);
}
public void SimpleTests()
{
// Tests simple adds and removes from the front of the list. It
// makes part of its tail immutable, but doesn't make it mutable
// again. Also, we test operations that don't modify the list.
FWList <int> list = new FWList <int>();
Assert.That(list.IsEmpty);
// create VListBlockOfTwo
list = new FWList <int>(10, 20);
ExpectList(list, 10, 20);
// Add()
list.Clear();
list.Add(1);
Assert.That(!list.IsEmpty);
list.Add(2);
Assert.AreEqual(1, list.BlockChainLength);
list.Add(3);
Assert.AreEqual(2, list.BlockChainLength);
ExpectList(list, 3, 2, 1);
FVList <int> snap = list.ToFVList();
ExpectList(snap, 3, 2, 1);
// AddRange(), Push(), Pop()
list.Push(4);
list.AddRange(new int[] { 6, 5 });
ExpectList(list, 6, 5, 4, 3, 2, 1);
Assert.AreEqual(list.Pop(), 6);
ExpectList(list, 5, 4, 3, 2, 1);
list.RemoveRange(0, 2);
ExpectList(list, 3, 2, 1);
// Double the list
list.AddRange(list);
ExpectList(list, 3, 2, 1, 3, 2, 1);
list.RemoveRange(0, 3);
// Fill a third block
list.AddRange(new int[] { 9, 8, 7, 6, 5, 4 });
list.AddRange(new int[] { 14, 13, 12, 11, 10 });
ExpectList(list, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1);
// Remove(), enumerator
list.Remove(14);
list.Remove(13);
list.Remove(12);
list.Remove(11);
ExpectListByEnumerator(list, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1);
// IndexOutOfRangeException
AssertThrows <IndexOutOfRangeException>(delegate() { int i = list[-1]; });
AssertThrows <IndexOutOfRangeException>(delegate() { int i = list[10]; });
AssertThrows <IndexOutOfRangeException>(delegate() { list.Insert(-1, -1); });
AssertThrows <IndexOutOfRangeException>(delegate() { list.Insert(list.Count + 1, -1); });
AssertThrows <IndexOutOfRangeException>(delegate() { list.RemoveAt(-1); });
AssertThrows <IndexOutOfRangeException>(delegate() { list.RemoveAt(list.Count); });
// Front, Contains, IndexOf
Assert.That(list.First == 10);
Assert.That(list.Contains(9));
Assert.That(list[list.IndexOf(2)] == 2);
Assert.That(list[list.IndexOf(9)] == 9);
Assert.That(list[list.IndexOf(7)] == 7);
Assert.That(list.IndexOf(-1) == -1);
// snap is still the same
ExpectList(snap, 3, 2, 1);
}