public void TestInsertRemove()
{
FWList <int> list = new FWList <int>();
for (int i = 0; i <= 12; i++)
{
list.Insert(i, i);
}
ExpectList(list, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
for (int i = 1; i <= 6; i++)
{
list.RemoveAt(i);
}
ExpectList(list, 0, 2, 4, 6, 8, 10, 12);
Assert.AreEqual(0, list.Pop());
list.Insert(5, -2);
ExpectList(list, 2, 4, 6, 8, 10, -2, 12);
list.Insert(5, -1);
ExpectList(list, 2, 4, 6, 8, 10, -1, -2, 12);
list.Remove(-1);
list.Remove(12);
list[list.Count - 1] = 12;
ExpectList(list, 2, 4, 6, 8, 10, 12);
// Make sure FWList.Clear doesn't disturb FVList
FVList <int> v = list.WithoutFirst(4);
list.Clear();
ExpectList(list);
ExpectList(v, 10, 12);
// Some simple InsertRange calls where some immutable items must be
// converted to mutable
FVList <int> oneTwo = new FVList <int>(1, 2);
FVList <int> threeFour = new FVList <int>(3, 4);
list = oneTwo.ToFWList();
list.InsertRange(1, threeFour);
ExpectList(list, 1, 3, 4, 2);
list = threeFour.ToFWList();
list.InsertRange(2, oneTwo);
ExpectList(list, 3, 4, 1, 2);
// More tests...
list.RemoveRange(0, 2);
ExpectList(list, 1, 2);
list.InsertRange(2, new int[] { 3, 3, 4, 4, 4, 5, 6, 7, 8, 9 });
ExpectList(list, 1, 2, 3, 3, 4, 4, 4, 5, 6, 7, 8, 9);
list.RemoveRange(3, 3);
ExpectList(list, 1, 2, 3, 4, 5, 6, 7, 8, 9);
v = list.ToFVList();
list.RemoveRange(5, 4);
ExpectList(list, 1, 2, 3, 4, 5);
ExpectList(v, 1, 2, 3, 4, 5, 6, 7, 8, 9);
}
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 RandomTest()
{
int seed = Environment.TickCount;
Random r = new Random(seed);
int action, index, iteration = 0, i = -1;
FWList <int> wlist = new FWList <int>();
List <int> list = new List <int>();
// Perform a series of random operations on FWList:
// - Calling the setter
// - RemoveAt
// - Add to front
// - Insert
// - Making part of the list immutable
try {
for (iteration = 0; iteration < 100; iteration++)
{
action = r.Next(5);
int range = list.Count + (action >= 2 ? 1 : 0);
if (range == 0)
{
iteration--; continue;
}
index = r.Next(range);
switch (action)
{
case 0:
list.RemoveAt(index);
wlist.RemoveAt(index);
break;
case 1:
list[index] = iteration;
wlist[index] = iteration;
break;
case 2:
list.Insert(0, iteration);
wlist.Add(iteration);
break;
case 3:
list.Insert(index, iteration);
wlist.Insert(index, iteration);
break;
case 4:
FVList <int> v = wlist.WithoutFirst(index);
if (r.Next(2) == 0)
{
v.Add(index);
}
break;
}
Assert.AreEqual(list.Count, wlist.Count);
for (i = 0; i < list.Count; i++)
{
Assert.AreEqual(list[i], wlist[i]);
}
}
} catch (Exception e) {
Console.WriteLine("{0} with seed {1} at iteration {2}, i={3}", e.GetType().Name, seed, iteration, i);
throw;
}
}
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);
}