public void FindNodeTest()
        {
            string[] data = { "", "abcde", "3", "4", "5", "0" };

            BiDirectionalList <string> aList = new BiDirectionalList <string>(data);
            BiDirectionalList <string> bList = aList.Clone();
            SingleLinkedList <string>  list1 = new SingleLinkedList <string>(data);
            SingleLinkedList <string>  list2 = aList.Clone();

            Assert.AreEqual(list1.ToString(), list2.ToString());
            Assert.AreEqual(list1.FindNode("3").Value, "3");

            string[] array   = aList.ToArray();
            string   ssArray = aList.ToString();

            Assert.AreEqual(String.Join(", ", array), String.Join(", ", bList.ToString()));
            Assert.AreEqual(String.Join(", ", array), String.Join(", ", data));
            Assert.AreEqual(String.Join(", ", array), ssArray);

            Node <string> node1 = aList.FindNode("abcde");

            Assert.AreEqual(aList.FindNode(node1).Value, "abcde");
            Assert.AreEqual(aList.FindNode("3").Value, "3");
            Assert.AreEqual(aList.FindNode(3).Value, "4");
            Assert.AreEqual(aList.FindNode(2).Value, aList.FindNode(-4).Value);
            Assert.AreEqual(aList.FindNode(5).Value, aList.FindNode(-1).Value);
            Assert.AreNotEqual(aList.FindNode(0).Value, "0");
            Assert.IsNotNull(aList.FindNode(-6));
            Assert.IsNull(aList.FindNode(6));
            Assert.IsNull(aList.FindNodeBackward(6));
            Assert.IsNull(aList.FindNode(-7));

            Node <string> node2 = new Node <string>("abc");

            Assert.IsNull(aList.FindNode(node2));

            Node <string> node3 = aList.InsertNode(node2.Value, 2);

            Assert.AreEqual(node2, node3);
            Assert.IsNotNull(node3);
            Assert.IsNotNull(aList.AddNode(node2, aList.Last));
            Assert.AreEqual(node2, aList.Last);

            Node <string> node4 = aList.FindNodeBackward(4);

            Assert.AreEqual(node4.Value, "3");

            Node <string> node5 = aList.FindNodeBackward(5);
            Node <string> test5 = aList.FindNode(aList.Count - 5 - 1);

            Assert.AreEqual(node5.Value, test5.Value);

            aList.InsertNode(node1, node1);
            Assert.AreEqual(node1.Value, aList.Head.Next.Value);
        }
        public void ReverseTest1()
        {
            string abc   = "abc";
            string xyz   = "xyz";
            string test1 = "test1";
            string test2 = "test2";
            string test3 = "test3";
            string test4 = "test4";

            Node <String> newNode             = null;
            BiDirectionalList <String> myList = new BiDirectionalList <String>();

            Assert.AreEqual(myList.Count, 0);

            // testing empty list
            Assert.IsNull(myList.Current);
            Assert.IsNull(myList.Head);
            Assert.IsNull(myList.Last);
            myList.Reverse();
            Assert.AreEqual(myList.Count, 0);

            // testing linked list with only one node
            newNode = myList.AddNode(test1);
            Assert.AreEqual(myList.Count, 1);
            Assert.AreEqual(myList.Head, newNode);
            Assert.AreEqual(myList.Last, myList.Current);
            Assert.AreEqual(myList.Head, myList.Current);

            myList.Reverse();
            Assert.AreEqual(myList.Count, 1);
            Assert.AreEqual(myList.Last, myList.Last);

            // reinitializing a new linked list
            myList = new BiDirectionalList <String>(test1);
            Assert.AreEqual(myList.Count, 1);

            newNode = myList.AddNode(test2);
            Assert.AreEqual(myList.Count, 2);
            Assert.AreEqual(myList.Last, newNode);
            Assert.AreNotEqual(myList.Head, newNode);
            newNode = myList.AddNode(test3);
            Assert.AreEqual(myList.Last, newNode);
            Assert.AreEqual(myList.Current.Value.ToString(), test3.ToString());
            Assert.AreNotEqual(myList.Head, newNode);
            newNode = myList.AddNode(abc);
            Assert.AreEqual(myList.Count, 4);
            Assert.AreEqual(myList.Last, newNode);
            Assert.AreNotEqual(myList.Head, newNode);
            newNode = myList.AddNode(xyz);
            Assert.AreEqual(myList.Count, 5);
            Assert.AreEqual(myList.Last, newNode);
            Assert.AreEqual(myList.Current, myList.Last);
            Assert.AreNotEqual(myList.Head, newNode);

            // searching in linked list
            Assert.AreEqual(myList.Head, myList.FindNode(0));
            Assert.AreEqual(myList.Head, myList.FindNode(test1));
            Assert.AreEqual(myList.Last, myList.FindNode(xyz));
            Assert.AreEqual(myList.Last, myList.FindNode(myList.Count - 1));
            Assert.AreNotEqual(myList.Last, myList.FindNode(myList.Head));

            myList.Last.Previous.Value = test4;
            Assert.AreEqual(myList.FindNode(3), myList.FindNode(test4));
            Assert.AreEqual(myList.FindNode(-2), myList.FindNode(test4));
            Assert.AreEqual(myList.FindNode(-1), myList.FindNode(xyz));
            Assert.AreEqual(myList.FindNode(-1), myList.Last);
            Assert.AreEqual(myList.FindNode(0), myList.Head);
            Assert.AreEqual(myList.Current, myList.Head);

            Assert.IsNull(myList.FindNode(abc));
            Assert.AreEqual(myList.Current, myList.Head);

            // saving original linked list
            Node <String> node_old = myList.Head;
            Node <String> node_nul = null;

            object[] original_list = myList.ToArray();

            Assert.IsNotNull(node_old);
            Assert.AreEqual(myList.Current.CompareTo(node_nul), 1);
            Assert.AreEqual(myList.Count, 5);

            object head = myList.Head.Value;
            object last = myList.Last.Value;

            myList.Reverse();

            Assert.AreEqual(myList.Current, myList.Last);
            Assert.AreEqual(myList.Head.Value.ToString(), last.ToString());
            Assert.AreEqual(myList.Last.Value.ToString(), head.ToString());

            Assert.AreEqual(myList.Last.Previous.Value.ToString(), test2);
            Assert.AreEqual(myList.Last.Previous.Previous.Value.ToString(), test3);
            Assert.AreEqual(myList.Head.Next.Next.Value.ToString(), test3);

            newNode = myList.Head;

            for (int n = original_list.Length - 1; n >= 0; n--)
            {
                Assert.AreEqual(original_list[n], newNode.Value);
                newNode = newNode.Next;
            }

            Node <String> node_new = myList.Last;

            Assert.IsNotNull(node_new);

            while (node_old != null)
            {
                Assert.AreEqual(node_old, node_new);
                node_new = node_new.Previous;
                node_old = node_old.Next;
            }
        }