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); }