Example #1
0
        public void TestInsertRemove()
        {
            RVList <int> list  = new RVList <int>(9);
            RVList <int> list2 = new RVList <int>(10, 11);

            list.Insert(0, 12);
            list.Insert(1, list2[1]);
            list.Insert(2, list2[0]);
            ExpectList(list, 12, 11, 10, 9);
            for (int i = 0; i < 9; i++)
            {
                list.Insert(4, i);
            }
            ExpectList(list, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);

            list2 = list;
            for (int i = 1; i <= 6; i++)
            {
                list2.RemoveAt(i);
            }
            ExpectList(list2, 12, 10, 8, 6, 4, 2, 0);
            ExpectList(list, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);             // unchanged

            Assert.AreEqual(0, list2.Pop());
            list2.Insert(5, -2);
            ExpectList(list2, 12, 10, 8, 6, 4, -2, 2);
            list2.Insert(5, -1);
            ExpectList(list2, 12, 10, 8, 6, 4, -1, -2, 2);

            // 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, 12, 10, 8, 6, 4, -1, -2, 2);

            list2.Clear();
            ExpectList(list2);
            Assert.AreEqual(5, list[5]);
        }
Example #2
0
        public void SimpleTests()
        {
            // In this simple test, I only add and remove items from the back
            // of an RVList, but forking is also tested.

            RVList <int> list = new RVList <int>();

            Assert.That(list.IsEmpty);

            // Adding to VListBlockOfTwo
            list = new RVList <int>(10, 20);
            ExpectList(list, 10, 20);

            list = new RVList <int>();
            list.Add(1);
            Assert.That(!list.IsEmpty);
            list.Add(2);
            ExpectList(list, 1, 2);

            // A fork in VListBlockOfTwo. Note that list2 will use two VListBlocks
            // here but list will only use one.
            RVList <int> list2 = list.WithoutLast(1);

            list2.Add(3);
            ExpectList(list, 1, 2);
            ExpectList(list2, 1, 3);

            // Try doubling list2
            list2.AddRange(list2);
            ExpectList(list2, 1, 3, 1, 3);

            // list now uses two arrays
            list.Add(4);
            ExpectList(list, 1, 2, 4);

            // Try doubling list using a different overload of AddRange()
            list.AddRange((IList <int>)list);
            ExpectList(list, 1, 2, 4, 1, 2, 4);
            list = list.WithoutLast(3);
            ExpectList(list, 1, 2, 4);

            // Remove(), Pop()
            Assert.AreEqual(3, list2.Pop());
            ExpectList(list2, 1, 3, 1);
            Assert.That(!list2.Remove(0));
            Assert.AreEqual(1, list2.Pop());
            Assert.That(list2.Remove(3));
            ExpectList(list2, 1);
            Assert.That(list2.Remove(1));
            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, 1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
            list2 = list.WithoutLast(6);
            ExpectListByEnumerator(list2, 1, 2, 4, 5, 6, 7, 8, 9, 10);
            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(), Back
            RVList <int> list3 = list2;

            Assert.AreEqual(11, (list3 = list3.NextIn(list)).Last);
            Assert.AreEqual(12, (list3 = list3.NextIn(list)).Last);
            Assert.AreEqual(13, (list3 = list3.NextIn(list)).Last);
            Assert.AreEqual(14, (list3 = list3.NextIn(list)).Last);
            Assert.AreEqual(15, (list3 = list3.NextIn(list)).Last);
            Assert.AreEqual(16, (list3 = list3.NextIn(list)).Last);
            AssertThrows <Exception>(delegate() { list3.NextIn(list); });

            // Next
            Assert.AreEqual(10, (list3 = list3.WithoutLast(6)).Last);
            Assert.AreEqual(9, (list3 = list3.Tail).Last);
            Assert.AreEqual(8, (list3 = list3.Tail).Last);
            Assert.AreEqual(7, (list3 = list3.Tail).Last);
            Assert.AreEqual(6, (list3 = list3.Tail).Last);
            Assert.AreEqual(5, (list3 = list3.Tail).Last);
            Assert.AreEqual(4, (list3 = list3.Tail).Last);
            Assert.AreEqual(2, (list3 = list3.Tail).Last);
            Assert.AreEqual(1, (list3 = list3.Tail).Last);
            Assert.That((list3 = list3.Tail).IsEmpty);

            // list2 is still the same
            ExpectList(list2, 1, 2, 4, 5, 6, 7, 8, 9, 10);

            // ==, !=, 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 ends up with block sizes 8 (3
            // used), 8 (3 used), 4, 2.
            list2.AddRange(list2, list2.WithoutLast(3));
            ExpectList(list2, 1, 2, 4, 5, 6, 7, 8, 9, 10, 8, 9, 10);
            Assert.That(list3 != list2);

            // List3 is a sublist of list, but list2 no longer is
            Assert.That(list3.NextIn(list).Last == 11);
            AssertThrows <InvalidOperationException>(delegate() { list2.NextIn(list); });

            list2 = list2.WithoutLast(3);
            Assert.That(list3 == list2);
        }