コード例 #1
0
        public void ReverseTest2()
        {
            string test1 = "test1";
            string test6 = "test6";

            BiDirectionalList <object> oldList = new BiDirectionalList <object>(
                "", "abcde", new Node <object>('3'), 4, 5.0
                );

            oldList.AddNode(test6);

            BiDirectionalList <string> strList1 = new BiDirectionalList <string>("", "abcde", "3", "4", "5.0");
            BiDirectionalList <string> strList2 = strList1.Clone();

            BiDirectionalList <object> newList = oldList.Clone();
            string comp1 = oldList.ToString();
            string comp2 = newList.ToString();

            Assert.AreEqual(comp1, comp2);

            newList.Reverse();
            Assert.IsFalse(this.CompareReversedList(oldList, newList));
            Assert.IsTrue(this.CompareReversedList(oldList, newList, true));

            Assert.IsFalse(strList1.Equals(strList2));
            Assert.IsTrue(strList1.Equals(strList2, true));

            Node <object> node1 = newList.InsertNode(test1);

            Assert.AreEqual(newList.Head, node1);

            Node <object> node5 = newList.DeleteNode(-1);

            Assert.IsNull(newList.FindNode(node5));

            Node <object> node6 = newList.AddNode(test6);

            Assert.AreEqual(newList.Last, node6);
        }
コード例 #2
0
        public void DeleteNodeTest()
        {
            Node <string> node1 = new Node <string>("abc");
            BiDirectionalList <string> aList = new BiDirectionalList <string>(node1);

            Assert.AreEqual(aList.Current, node1);
            Assert.AreEqual(aList.Current, aList.Head);
            Assert.AreEqual(aList.Current, aList.Last);
            Assert.AreEqual(aList.Count, 1);

            Node <string> node2 = aList.DeleteNode(node1);

            Assert.AreEqual(node1, node2);

            node2 = aList.AddNode(node1);
            Assert.AreEqual(node1, node2);

            node2 = aList.DeleteNode();
            Assert.AreEqual(node1, node2);

            node2.Value = "second-node";
            aList.AddNode(node2.Value); // adding the value, not the node
            node2 = aList.Current;
            Assert.IsTrue(node1.Equals(node2));
            Assert.AreEqual(node1, node2);

            aList.InsertNode(node1);
            aList.Current.Value = "first-node";
            Assert.AreEqual(aList.Head, node1);
            Assert.AreEqual(aList.Last, node2);
            Assert.IsNull(aList.DeleteNode(""));

            Node <string> node3 = aList.AddNode("3rd-node", node2.Value);

            Assert.AreEqual(aList.Last, node3);
            Assert.AreEqual(aList.Count, 3);

            aList.SeekToHead();
            Assert.AreEqual(aList.Current, aList.Head);
            aList.SeekToLast();
            Assert.AreEqual(aList.Current, aList.Last);
            aList.SeekToNext();
            Assert.IsNotNull(aList.Current);
            aList.SeekToPrevious();
            Assert.AreEqual(aList.Current.Value, node2.Value);
            aList.SeekToPrevious();
            Assert.AreEqual(aList.Current, node1);
            aList.SeekToPrevious();
            aList.SeekToNext();
            Assert.AreEqual(aList.Current.Value, node2.Value);
            aList.SeekToNext();
            Assert.AreEqual(aList.Current, node3);

            node2 = aList.DeleteNode(node2.Value);
            Assert.AreEqual(aList.Current, node1);

            aList.AddNode(node2.Value, 1);
            Assert.AreEqual(aList.Current.Value, node2.Value);

            aList.DeleteNode();
            aList.InsertNode(node2.Value, 2);
            Assert.AreEqual(aList.Current.Value, node2.Value);

            aList.Clear();
            Assert.AreEqual(aList.IsEmpty, true);
            Assert.AreEqual(aList.Count, 0);
            Assert.IsNull(aList.DeleteNode());
            Assert.IsNull(aList.Current);
            Assert.IsNull(aList.Head);
            Assert.IsNull(aList.Last);
        }