public void RemoveLastAndEmptyList() { DoublyLinkedList <int> dll = new DoublyLinkedList <int>(); dll.Add((10)); dll.Add((20)); dll.Add((30)); dll.Add((40)); /* 40 -> 30 -> 20 - > 10 * ^ | * |__________________| Head = 40, Tail = 10 */ dll.RemoveLast(); dll.RemoveLast(); dll.RemoveLast(); dll.RemoveLast(); /* * NULL, Count should be 0 */ Assert.AreEqual(dll.Head, null); Assert.AreEqual(dll.Count, 0); }
public bool FindTest() { Console.WriteLine("DoublyLinkedListTests : FindTest"); var result = true; var list = new DoublyLinkedList <string>(); list.Add("jim"); list.Add("dave"); if (list.Find("dave") == null) { result = false; } if (list.Find("jim") == null) { result = false; if (list.Find("jim").Node != "jim") { result = false; } if (list.Find("jim").Node == "jIm") { result = false; } } if (list.Find("Z") != null) { result = false; } return(result); }
public void CanRemoveItemFromDoublyLinkedList() { List <dynamic> cut = new DoublyLinkedList <dynamic>(); dynamic objectToRemove = new { val = 42 }; for (int i = 1; i < 4; i++) { cut.Add(new { val = i }); } cut.Add(objectToRemove); for (int i = 1; i < 4; i++) { cut.Add(new { val = i }); } // Length should be 7 Assert.Equal(7, cut.Length()); // object to remove should be at index 3 Assert.Equal(3, cut.IndexOf(objectToRemove)); cut.Remove(objectToRemove); // Length should now be 6 Assert.Equal(6, cut.Length()); // object to remove should return index -1 Assert.Equal(-1, cut.IndexOf(objectToRemove)); }
static void Main(string[] args) { // Console.WriteLine("Hello World!"); DoublyLinkedList dll = new DoublyLinkedList(); dll.Add(3); dll.Add(5); dll.Add(9); dll.Add(10); dll.printIndo(); // dll.Reverse(); // dll.printIndo(); dll.Remove(10); dll.printIndo(); Console.WriteLine("------------------------------------------- "); dll.Remove(10); dll.printIndo(); Console.WriteLine("------------------------------------------- "); dll.Remove(3); dll.printIndo(); Console.WriteLine("------------------------------------------- "); dll.Remove(9); dll.printIndo(); Console.WriteLine("------------------------------------------- "); dll.Remove(5); dll.printIndo(); Console.WriteLine("------------------------------------------- "); }
public static void DoubleLinkedList() { DoublyLinkedList <int> dlist = new DoublyLinkedList <int>(); dlist.Add(1); dlist.Add(2); dlist.Add(3); dlist.Add(4); Assert.That(dlist.Head.Value == 1); Assert.That(dlist.Tail.Value == 4); dlist.Reverse(); Assert.That(dlist.Head.Value == 4); Assert.That(dlist.Tail.Value == 1); dlist.Reverse(); dlist.Remove(3); var node = dlist.Find(2); Assert.That(node.Next.Value == 4); node = dlist.Find(1); dlist.Remove(node); Assert.That(dlist.Head.Value == 2); }
public void BeginTestMethod() { target = new DoublyLinkedList<int>(); Assert.AreEqual(target.Leng, 0); target.Add(2); target.Add(3, 1); target.AddLast(5); }
public void should_return_the_node_if_the_value_exists() { var list = new DoublyLinkedList<int>(); list.Add(5); list.Add(3); var node = list.Find(5); Assert.That(node.Data.Equals(5), Is.True); }
public void CanReturnNotFoundOfNull() { List <object> cut = new DoublyLinkedList <object>(); cut.Add(new { val = 1 }); cut.Add(new { val = 2 }); Assert.Equal(-1, cut.IndexOf(null)); }
public static void ClassInitializer(TestContext context) { head = new DoublyLinkedListNode <int>(-1); doublyLinkedList = new DoublyLinkedList <int>(head); doublyLinkedList.Add(4); doublyLinkedList.Add(41); doublyLinkedList.Add(54); doublyLinkedList.Add(9); }
public void Clear() { DoublyLinkedList<int> list = new DoublyLinkedList<int>(); list.Add(3); list.Add(5); list.Add(7); list.Clear(); list.ShouldBeEmpty(); }
public void Contains() { DoublyLinkedList<int> list = new DoublyLinkedList<int>(); list.Add(3); list.Add(5); list.Add(7); bool isTrue = list.Contains(3); Assert.AreEqual(true, isTrue); }
public void CopyTo() { DoublyLinkedList<int> list = new DoublyLinkedList<int>(); int[] array = new int[3]; list.Add(3); list.Add(5); list.Add(7); list.CopyTo(array, 0); }
public void CopyToWithLessSpaceInTheArray() { DoublyLinkedList<int> list = new DoublyLinkedList<int>(); int[] array = new int[3]; list.Add(3); list.Add(5); list.Add(7); list.CopyTo(array, 2); }
public void CanAddNullValueToDoublyLinkedList() { List <object> cut = new DoublyLinkedList <object>(); cut.Add(new { val = 1 }); cut.Add(null); cut.Add(new { val = 2 }); Assert.Equal(1, cut.IndexOf(null)); }
public void Add_NewUnitAddToTail_NewLinkedListWithUnit() { DoublyLinkedList <int> dll = new DoublyLinkedList <int>(); dll.Add(5); dll.Add(3); dll.Add(2); Assert.AreEqual(3, dll.Count); }
public void should_make_the_node_tail_of_the_list() { var list = new DoublyLinkedList<int>(); list.Add(5); list.Add(3); Assert.That(list.Tail.Data.Equals(3), Is.True); Assert.That(list.Head.Data.Equals(5), Is.True); Assert.That(list.Head.Next.Data.Equals(3), Is.True); }
public static void RunEleven() { DoublyLinkedList doubLinkedList = new DoublyLinkedList(); doubLinkedList.Add(5); doubLinkedList.Add(6); doubLinkedList.Add(7); doubLinkedList.Add(8); }
public void TestDoublyLinkedListAdd() { DoublyLinkedList<string> list = new DoublyLinkedList<string>(); list.Add("One"); list.Add("Two"); list.Add("Three"); Assert.AreEqual(3, list.Count); }
public static void ClassInitializer(TestContext context) { head = new DoublyLinkedListNode<int>(-1); doublyLinkedList= new DoublyLinkedList<int>(head); doublyLinkedList.Add(4); doublyLinkedList.Add(41); doublyLinkedList.Add(54); doublyLinkedList.Add(9); }
public void TestLengthString() { // Given DoublyLinkedList <string> list = new DoublyLinkedList <string>(); list.Add("1"); list.Add("2"); // When /Then Assert.That(list.Length(), Is.EqualTo(2)); }
public void TestLength() { // Given DoublyLinkedList <int> list = new DoublyLinkedList <int>(); list.Add(1); list.Add(2); // When /Then Assert.That(list.Length(), Is.EqualTo(2)); }
public void CanGetIndexOfValueWithDoublyLinkedListsContainingNulls() { List <object> cut = new DoublyLinkedList <object>(); var valueToFind = new { val = 1 }; cut.Add(null); cut.Add(valueToFind); cut.Add(null); Assert.Equal(1, cut.IndexOf(valueToFind)); }
public void TestDoublyLinkedListAdd() { DoublyLinkedList <string> list = new DoublyLinkedList <string>(); list.Add("One"); list.Add("Two"); list.Add("Three"); Assert.AreEqual(3, list.Count); }
public void AddingElementToLinkedList() { DoublyLinkedList <int> linkedList = new DoublyLinkedList <int>(); linkedList.Add(5); linkedList.Add(10); linkedList.Add(15); Assert.That(linkedList.SequenceEqual(new int[] { 5, 10, 15 }), "Add does not add correctly elements to the linked list"); }
public void DoublyLinkedList_Should_AddItemToEndOfList_When_GivenItem() { int item1 = 5; int item2 = 12; list.Add(item1); list.Add(item2); Assert.That(list.Head.Next, Is.EqualTo(list.Tail)); }
public void Contains_SearchFiveInList_TrueReturned() { DoublyLinkedList <int> dll = new DoublyLinkedList <int>(); dll.Add(5); dll.Add(10); dll.Add(2); Assert.IsTrue(dll.Contains(5)); }
static void Main(string[] args) { Console.WriteLine("Doubly Linked Lists:"); DoublyLinkedList list1 = new DoublyLinkedList(); ////Add a pile of nodes to our list list1.Add(7); list1.Add(12); list1.Add(15); list1.Add(20); list1.Add(21); list1.Add(22); list1.Add(23); list1.Add(24); list1.Add(25); list1.PrintValues(); ////Test deleting a non existent node Console.WriteLine($"Did we remove a node? {list1.Remove(2)}"); ////Test deleting the first node Console.WriteLine($"Did we remove a node? {list1.Remove(7)}"); ////Test deleting a middle node Console.WriteLine($"Did we remove a node? {list1.Remove(20)}"); ////Test deleting the end node Console.WriteLine($"Did we remove a node? {list1.Remove(25)}"); list1.PrintValues(); list1.Reverse(); list1.PrintValues(); }
public void Should_Return_Element_At_The_Specified_Position() { var list = new DoublyLinkedList <int>(); list.Add(5); list.Add(6); var actualElement = list.ElementAt(1); actualElement.Should().Be(6); }
public void Should_Return_Removing_Item() { var list = new DoublyLinkedList <int>(); list.Add(2); list.Add(5); var removedItem = list.RemoveAt(1); removedItem.Should().Be(5); }
public void Should_Not_Change_Collection_If_It_Does_Not_Contain_Specified_Item() { var list = new DoublyLinkedList <int>(); list.Add(1); list.Add(2); list.Remove(4); list.Should().BeEquivalentTo(new[] { 1, 2 }); }
public void Should_Throw_IndexOutOfRangeException_If_Index_Bigger_Or_Equal_Than_Length() { var list = new DoublyLinkedList <int>(); list.Add(1); list.Add(3); Action action = () => list.ElementAt(2); action.Should().ThrowExactly <IndexOutOfRangeException>(); }
public void Should_Throw_IndexOutOfRangeException_If_Index_For_RemoveAt_Less_Than_Zero() { var list = new DoublyLinkedList <int>(); list.Add(2); list.Add(5); Action action = () => list.RemoveAt(-1); action.Should().ThrowExactly <IndexOutOfRangeException>(); }
public void Should_Throw_IndexOutOfRangeException_If_Index_Less_Than_Zero() { var list = new DoublyLinkedList <int>(); list.Add(1); list.Add(3); Action action = () => list.ElementAt(-2); action.Should().ThrowExactly <IndexOutOfRangeException>(); }
public void RemoveFromCount() { DoublyLinkedList doubleList = new DoublyLinkedList(); doubleList.Add("David"); doubleList.Add("James"); doubleList.Add("Pirate Pete"); doubleList.Add("Brenda"); doubleList.Delete("James"); Assert.AreEqual(doubleList.Count(), 3); }
public void Should_Increment_Length_Of_The_List_When_Element_Added() { var list = new DoublyLinkedList <int>(); list.Add(1); list.Add(2); var actualLength = list.Length; actualLength.Should().Be(2); }
public void Should_Remove_Element_At_The_Specified_Position() { var list = new DoublyLinkedList <int>(); list.Add(5); list.Add(6); list.RemoveAt(1); list.Should().BeEquivalentTo(new[] { 5 }); }
public void Clear_DeleteUnitsFromList_EmptyLinkedList() { DoublyLinkedList <int> dll = new DoublyLinkedList <int>(); dll.Add(5); dll.Add(10); dll.Add(2); dll.Clear(); Assert.IsTrue(dll.IsEmpty); }
public void RemoveCountTest() { var list = new DoublyLinkedList <int>(); list.Add(10); list.Add(20); list.Add(30); list.Remove(10); list.Remove(20); Assert.AreEqual(list.Count, 1); }
public void List_AddsLastIfUsingAddMethod() { var doubly = new DoublyLinkedList <int>(); doubly.Add(100); doubly.Add(200); doubly.Add(300); Assert.Equal(3, doubly.Size); Assert.Equal(300, doubly.TailNode.Value); }
public void AddAtHead() { DoublyLinkedList<int> list = new DoublyLinkedList<int>(); int[] array = new int[3]; list.Add(3); list.ShouldContain(3); list.Add(5); list.ShouldContain(5); list.Add(7); list.ShouldContain(7); list.CopyTo(array, 0); }
public void TestDoublyLinkedListIndexer() { DoublyLinkedList<string> list = new DoublyLinkedList<string>(); list.Add("One"); list.Add("Two"); list.Add("Three"); list[0] = "Zero"; string[] array = new string[list.Count]; list.CopyTo(array); Assert.AreEqual("Zero, Two, Three", string.Join(", ", array)); }
public void TestDoublyLinkedListInsert_InsertInTheMiddle() { DoublyLinkedList<string> list = new DoublyLinkedList<string>(); list.Add("One"); list.Add("Two"); list.Add("Three"); list[0] = "Zero"; list.Insert(1, "Ten"); string[] array = new string[list.Count]; list.CopyTo(array); Assert.AreEqual("Zero, Ten, Two, Three", string.Join(", ", array)); }
public void TestDoublyLinkedListForEach() { DoublyLinkedList<string> list = new DoublyLinkedList<string>(); list.Add("One"); list.Add("Two"); list.Add("Three"); list[0] = "Zero"; string[] array = new string[list.Count]; int index = 0; foreach (string item in list) { array[index] = item; index++; } Assert.AreEqual("Zero, Two, Three", string.Join(", ", array)); }
public void should_delete_the_value_if_it_exists() { var list = new DoublyLinkedList<int>(); list.Add(5); list.Add(2); list.Add(3); list.Delete(2); Assert.That(list.Tail.Data.Equals(3), Is.True); Assert.That(list.Head.Data.Equals(5), Is.True); Assert.That(list.Head.Next.Data.Equals(3), Is.True); list.Delete(5); Assert.That(list.Tail.Data.Equals(3), Is.True); Assert.That(list.Head.Data.Equals(3), Is.True); list.Delete(3); Assert.That(list.Tail, Is.Null); Assert.That(list.Head, Is.Null); }
public void CopyToWithNegativeIndex() { DoublyLinkedList<int> list = new DoublyLinkedList<int>(); int[] array = new int[3]; list.Add(3); list.Add(5); list.Add(7); list.CopyTo(array, -2); }
public void TestDoublyLinkedListIndexOf() { DoublyLinkedList<string> list = new DoublyLinkedList<string>(); list.Add("One"); list.Add("Two"); list.Add("Three"); list[0] = "Zero"; list.Insert(2, "Four"); Assert.AreEqual(3, list.IndexOf("Three")); }
public void CountTest() { DoublyLinkedList<int> dll = new DoublyLinkedList<int> {10, 5}; dll.RemoveFirst(); dll.RemoveLast(); dll.Add(10); dll.AddAfter(dll.Head, 30); dll.AddBefore(dll.Head.Next, 20); Assert.AreEqual(3, dll.Count); }
public void CountPUT([PexAssumeUnderTest]IList<int> values, int randomPick1) { PexAssume.IsFalse(values.Contains(randomPick1)); PexAssume.IsTrue(values.Count > 1); DoublyLinkedList<int> dll = new DoublyLinkedList<int> (values); dll.RemoveFirst(); dll.RemoveLast(); PexAssert.AreEqual(values.Count-2, dll.Count); dll.Add(randomPick1); dll.AddAfter(dll.Head, values[0]); dll.AddBefore(dll.Head.Next, values[values.Count-1]); PexAssert.AreEqual(values.Count+1, dll.Count); }
public void Count() { DoublyLinkedList<int> list = new DoublyLinkedList<int>(); list.Add(3); list.Add(5); list.Add(7); int numberOfItems = list.Count; Assert.AreEqual(3, numberOfItems); }
public void Find() { DoublyLinkedList<int> list = new DoublyLinkedList<int>(); list.Add(3); list.Add(5); list.Add(7); list.Contains(7).ShouldBeTrue(); list.Contains(2).ShouldBeFalse(); }
public void RemoveForAListWithTwoItems() { DoublyLinkedList<int> list = new DoublyLinkedList<int>(); int[] array = new int[5]; list.Add(7); list.Add(6); list.Add(5); list.Add(4); list.Add(3); list.CopyTo(array, 0); list.Remove(5); list.CopyTo(array, 0); list.ShouldNotContain(5); list.ShouldContain(3); }