public void Remove_SingleElement_ShouldWork()
        {
            var sll = new SimpleLinkedList<bool> { true };
            sll.Remove(0);

            Assert.AreEqual(0, sll.Count());
        }
示例#2
0
        public void Test_SimpleLinkedList()
        {
            var linkedList = new SimpleLinkedList <int>();

            linkedList.Add(0);
            Assert.IsTrue(linkedList.Count == 1);
            Assert.IsTrue(linkedList.Contains(0));
            Assert.IsFalse(linkedList.Contains(1));

            linkedList.Remove(0);
            Assert.IsTrue(linkedList.Count == 0);
            linkedList.Add(1);
            Assert.IsTrue(linkedList.Count == 1);
            Assert.IsTrue(linkedList.Contains(1));
            Assert.IsFalse(linkedList.Contains(0));

            linkedList.Clear();

            var tempList = new List <int>();

            for (int i = 0; i < 1024 * 32; i++)
            {
                var v = _random.Next(0, 256);

                if (_random.Next(0, 2) == 0)
                {
                    linkedList.Add(v);
                    tempList.Add(v);
                }
                else
                {
                    linkedList.Remove(v);
                    tempList.Remove(v);
                }
            }

            {
                tempList.Sort();

                var tempList2 = linkedList.ToList();
                tempList2.Sort();

                Assert.IsTrue(CollectionUtilities.Equals(tempList, tempList2));
            }
        }
            public void RemoveMethod_RemovesTheOnlyItemFromList()
            {
                SimpleLinkedList <string> linkedList = new SimpleLinkedList <string>();

                linkedList.AddFirst("asdf");

                linkedList.Remove("asdf");

                Assert.Null(linkedList.Find("asdf"));
            }
示例#4
0
        public void CheckListImplementation()
        {
            var        myList  = new SimpleLinkedList <int>();
            List <int> netList = new List <int>();

            myList.AddFirst(1);
            foreach (var i in myList)
            {
                netList.Add(i);
            }
            LinkedList <int> nwtList = new LinkedList <int>();

            Assert.Equal(1, netList[0]);

            myList.AddFirst(0);
            Assert.Equal(0, myList.Head.Value);
            Assert.Equal(1, myList.Last.Value);

            SimpleLinkedList <int> my3 = new SimpleLinkedList <int>(new[] { 1, 2, 3 });

            var node2 = my3.Find(2);

            my3.Remove(node2);

            netList.Clear();
            foreach (var i in my3)
            {
                netList.Add(i);
            }

            Assert.Equal(1, netList[0]);
            Assert.Equal(3, netList[1]);

            my3.Remove(my3.Head);

            netList.Clear();
            foreach (var i in my3)
            {
                netList.Add(i);
            }
            Assert.Equal(3, netList[0]);
        }
            public void RemoveMethod_SetsThe_LastProperty_ToTheSecondToLastNodeIfTheItemToBeRemovedIsTheTailOfTheList()
            {
                SimpleLinkedList <string> linkedList = new SimpleLinkedList <string>();

                linkedList.AddLast("new Item 1");
                linkedList.AddLast("new Item 2");

                linkedList.Remove("new Item 2");

                Assert.Equal("new Item 1", linkedList.Last.Item);
            }
            public void RemoveMethod_SetsThe_LinkProperty_Of_LastProperty_ToNull()
            {
                SimpleLinkedList <string> linkedList = new SimpleLinkedList <string>();

                linkedList.AddLast("new Item 1");
                linkedList.AddLast("new Item 2");

                linkedList.Remove("new Item 2");

                Assert.Null(linkedList.Last.Link);
            }
            public void RemoveMethod_ReturnsTrueIfItemToBeRemovedIsFound()
            {
                SimpleLinkedList <string> linkedList = new SimpleLinkedList <string>();

                linkedList.AddLast("asdf");
                linkedList.AddLast("qwer");

                bool result = linkedList.Remove("asdf");

                Assert.True(result);
            }
        public void Remove_SecondElement_ShouldWork()
        {
            var sll = new SimpleLinkedList<bool> { true, false, true, true, true };
            sll.Remove(1);

            Assert.AreEqual(4, sll.Count());
            Assert.AreEqual(true, sll.First());
            Assert.AreEqual(true, sll.Skip(1).First());
            Assert.AreEqual(true, sll.Skip(2).First());
            Assert.AreEqual(true, sll.Last());
        }
            public void RemoveMethod_RemovesCorrectItemFromListWithMultipleItems()
            {
                SimpleLinkedList <string> linkedList = new SimpleLinkedList <string>();

                linkedList.AddFirst("asdf");
                linkedList.AddFirst("middle");
                linkedList.AddFirst("qwer");

                linkedList.Remove("middle");

                Assert.Null(linkedList.Find("middle"));
            }
            public void RemoveMethod_DecrementsLengthOfList()
            {
                SimpleLinkedList <string> linkedList = new SimpleLinkedList <string>();
                int expectedCount = 0;

                linkedList.AddLast("asdf"); expectedCount++;
                linkedList.AddLast("qwer"); expectedCount++;
                linkedList.AddLast("zxcv"); expectedCount++;

                linkedList.Remove("asdf"); expectedCount--;

                Assert.Equal(expectedCount, linkedList.Count);
            }
示例#11
0
        public void TestHeadAssignmenet_RemoveFirstElementAndAddToFirstPosition_ElementShouldBeAssignedToSecondPosition()
        {
            var sll = new SimpleLinkedList<int> { 1, 2, 3, 4, 5 };
            sll.Remove(0);
            sll.Add(6, 0);

            Assert.AreEqual(5, sll.Count());
            Assert.AreEqual(6, sll.First());
            Assert.AreEqual(2, sll.Skip(1).First());
            Assert.AreEqual(3, sll.Skip(2).First());
            Assert.AreEqual(4, sll.Skip(3).First());
            Assert.AreEqual(5, sll.Skip(4).First());
            Assert.AreEqual(5, sll.Last());
        }
            public void RemoveMethod_SetsThe_LastProperty_ToNullIfTheItemToBeRemovedIsTheOnlyItemInTheList()
            {
                SimpleLinkedList <string> linkedList = new SimpleLinkedList <string>();

                linkedList.AddLast("new Item 1");

                linkedList.Remove("new Item 1");

                // acessing linkedList.Last throws exception if the tail of the list is null
                Assert.Throws <InvalidOperationException>(
                    delegate
                {
                    LinkedListNode <string> node = linkedList.Last;
                });
            }
示例#13
0
        static void Main(string[] args)
        {
            SimpleLinkedList<int> list = new SimpleLinkedList<int>();
            list.Add(1);
            list.Add(2);
            list.Add(3);
            list.Add(4);
            list.Add(5);

            string listStr = list.ToString();
            Console.WriteLine(listStr);

            /* Remove an item */
            list.Remove(5);
            listStr = list.ToString();
            Console.WriteLine(listStr);
        }
示例#14
0
        static void Main(string[] args)
        {
            SimpleLinkedList <int> list = new SimpleLinkedList <int>();

            list.Add(1);
            list.Add(2);
            list.Add(3);
            list.Add(4);
            list.Add(5);

            string listStr = list.ToString();

            Console.WriteLine(listStr);

            /* Remove an item */
            list.Remove(5);
            listStr = list.ToString();
            Console.WriteLine(listStr);
        }
            public void RemoveMethod_DecrementsLengthOfList()
            {
                SimpleLinkedList<string> linkedList = new SimpleLinkedList<string>();
                int expectedCount = 0;
                linkedList.AddLast("asdf"); expectedCount++;
                linkedList.AddLast("qwer"); expectedCount++;
                linkedList.AddLast("zxcv"); expectedCount++;

                linkedList.Remove("asdf"); expectedCount--;

                Assert.Equal(expectedCount, linkedList.Count);
            }
            public void RemoveMethod_RemovesTheOnlyItemFromList()
            {
                SimpleLinkedList<string> linkedList = new SimpleLinkedList<string>();
                linkedList.AddFirst("asdf");

                linkedList.Remove("asdf");

                Assert.Null(linkedList.Find("asdf"));
            }
            public void RemoveMethod_ReturnsTrueIfItemToBeRemovedIsFound()
            {
                SimpleLinkedList<string> linkedList = new SimpleLinkedList<string>();
                linkedList.AddLast("asdf");
                linkedList.AddLast("qwer");

                bool result = linkedList.Remove("asdf");

                Assert.True(result);
            }
            public void RemoveMethod_SetsThe_LastProperty_ToNullIfTheItemToBeRemovedIsTheOnlyItemInTheList()
            {
                SimpleLinkedList<string> linkedList = new SimpleLinkedList<string>();
                linkedList.AddLast("new Item 1");

                linkedList.Remove("new Item 1");

                // acessing linkedList.Last throws exception if the tail of the list is null
                Assert.Throws<InvalidOperationException>(
                    delegate
                    {
                        LinkedListNode<string> node = linkedList.Last;
                    });
            }
            public void RemoveMethod_SetsThe_LastProperty_ToTheSecondToLastNodeIfTheItemToBeRemovedIsTheTailOfTheList()
            {
                SimpleLinkedList<string> linkedList = new SimpleLinkedList<string>();
                linkedList.AddLast("new Item 1");
                linkedList.AddLast("new Item 2");

                linkedList.Remove("new Item 2");

                Assert.Equal("new Item 1", linkedList.Last.Item);
            }
            public void RemoveMethod_SetsThe_LinkProperty_Of_LastProperty_ToNull()
            {
                SimpleLinkedList<string> linkedList = new SimpleLinkedList<string>();
                linkedList.AddLast("new Item 1");
                linkedList.AddLast("new Item 2");

                linkedList.Remove("new Item 2");

                Assert.Null(linkedList.Last.Link);
            }
示例#21
0
 public void ShouldNotRemoveNonExistentItems()
 {
     SimpleLinkedList<int> list = new SimpleLinkedList<int>();
     list.Add(3);
     list.Add(5);
     list.Add(7);
     var oldCount = list.Count;
     list.Remove(8);
     list.Count.Equals(oldCount);
 }
示例#22
0
 public void ShouldRemoveAnItem()
 {
     SimpleLinkedList<int> list = new SimpleLinkedList<int>();
     list.Add(3);
     list.Add(5);
     list.Add(7);
     list.Remove(3);
     list.ShouldNotContain(3);
 }
            public void RemoveMethod_RemovesCorrectItemFromListWithMultipleItems()
            {
                SimpleLinkedList<string> linkedList = new SimpleLinkedList<string>();
                linkedList.AddFirst("asdf");
                linkedList.AddFirst("middle");
                linkedList.AddFirst("qwer");

                linkedList.Remove("middle");

                Assert.Null(linkedList.Find("middle"));
            }