public void Should_Add_First_When_List_Length_Greater_One()
{
//arrange
var node1 = new MyDoublyLinkedListNode <int>(1);
var node2 = new MyDoublyLinkedListNode <int>(2);
var node3 = new MyDoublyLinkedListNode <int>(3);
var node4 = new MyDoublyLinkedListNode <int>(4);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
node2.Prev = node1;
node3.Prev = node2;
node4.Prev = node3;
var list = new MyDoublyLinkedList <int>(node1);
var node5 = new MyDoublyLinkedListNode <int>(5);
//act
list.AddFirst(node5);
//assert
list.Count.ShouldBeEquivalentTo(5);
list.Head.ShouldBeEquivalentTo(node5);
list.Tail.ShouldBeEquivalentTo(node4);
list.Head.Next.ShouldBeEquivalentTo(node1);
list.Head.Next.Next.ShouldBeEquivalentTo(node2);
list.Head.Next.Next.Next.ShouldBeEquivalentTo(node3);
list.Head.Next.Next.Next.Next.ShouldBeEquivalentTo(node4);
}
public void Should_Copy_To()
{
//arrange
var node1 = new MyDoublyLinkedListNode <int>(2);
var node2 = new MyDoublyLinkedListNode <int>(4);
var node3 = new MyDoublyLinkedListNode <int>(3);
var node4 = new MyDoublyLinkedListNode <int>(5);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
node2.Prev = node1;
node3.Prev = node2;
node4.Prev = node3;
var list = new MyDoublyLinkedList <int>(node1);
var array = new int[6];
//act
list.CopyTo(array, 2);
//assert
array[0].ShouldBeEquivalentTo(0);
array[1].ShouldBeEquivalentTo(0);
array[2].ShouldBeEquivalentTo(2);
array[3].ShouldBeEquivalentTo(4);
array[4].ShouldBeEquivalentTo(3);
array[5].ShouldBeEquivalentTo(5);
}
public void Should_RemoveNode_RemoveFirst()
{
//arrange
var node1 = new MyDoublyLinkedListNode <int>(2);
var node2 = new MyDoublyLinkedListNode <int>(4);
var node3 = new MyDoublyLinkedListNode <int>(3);
var node4 = new MyDoublyLinkedListNode <int>(5);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
node2.Prev = node1;
node3.Prev = node2;
node4.Prev = node3;
var list = new MyDoublyLinkedList <int>(node1);
//act
list.Remove(node1);
//assert
list.Count.ShouldBeEquivalentTo(3);
list.Head.ShouldBeEquivalentTo(node2);
list.Head.Next.ShouldBeEquivalentTo(node3);
list.Head.Next.Next.ShouldBeEquivalentTo(node4);
}
public MyDoublyLinkedList <int> RemoveDups(MyDoublyLinkedList <int> list)
{
if (list == null)
{
throw new ArgumentNullException();
}
var head = list.Head;
while (head != null)
{
var current = head.Next;
while (current != null)
{
if (current.Data == head.Data)
{
current.Prev.Next = current.Next;
if (current.Next != null)
{
current.Next.Prev = current.Prev;
}
}
current = current.Next;
}
head = head.Next;
}
return(list);
}
public void RemoveDups_Should_Check_One_Duplicate()
{
//arrange
var list = new MyDoublyLinkedList <int>();
var node1 = new MyDoublyLinkedListNode <int>(1);
var node2 = new MyDoublyLinkedListNode <int>(1);
node1.Next = node2;
node2.Prev = node1;
list.Head = node1;
var resultList = new MyDoublyLinkedList <int>();
resultList.Head = new MyDoublyLinkedListNode <int>(1);
//act
var result = _linkedList.RemoveDups(list);
//assert
var head = result.Head;
var resultListHead = resultList.Head;
while (head != null)
{
head.Data.ShouldBeEquivalentTo(resultListHead.Data);
head = head.Next;
resultListHead = resultListHead.Next;
}
resultListHead.ShouldBeEquivalentTo(null);
}
public void AddAtDifferentPlacesTest()
{
var myLinkedList = new MyDoublyLinkedList();
myLinkedList.AddAtHead(7);
myLinkedList.AddAtHead(2);
ValidateDoublyLinkedList(myLinkedList);
myLinkedList.AddAtHead(1);
ValidateDoublyLinkedList(myLinkedList);
myLinkedList.AddAtIndex(3, 0);
ValidateDoublyLinkedList(myLinkedList);
myLinkedList.DeleteAtIndex(2);
ValidateDoublyLinkedList(myLinkedList);
myLinkedList.AddAtHead(6);
ValidateDoublyLinkedList(myLinkedList);
myLinkedList.AddAtTail(4);
ValidateDoublyLinkedList(myLinkedList);
myLinkedList.Get(4).Should().Be(4);
myLinkedList.AddAtHead(4);
ValidateDoublyLinkedList(myLinkedList);
myLinkedList.AddAtIndex(5, 0);
ValidateDoublyLinkedList(myLinkedList);
myLinkedList.AddAtHead(6);
ValidateDoublyLinkedList(myLinkedList);
}
public void Should_FindLast_Check_Order()
{
//arrange
var node1 = new MyDoublyLinkedListNode <int>(2);
var node2 = new MyDoublyLinkedListNode <int>(4);
var node3 = new MyDoublyLinkedListNode <int>(3);
var node4 = new MyDoublyLinkedListNode <int>(1);
var node5 = new MyDoublyLinkedListNode <int>(3);
var node6 = new MyDoublyLinkedListNode <int>(6);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
node4.Next = node5;
node5.Next = node6;
node2.Prev = node1;
node3.Prev = node2;
node4.Prev = node3;
node5.Prev = node4;
node6.Prev = node5;
var list = new MyDoublyLinkedList <int>(node1);
//act
var result = list.FindLast(3);
//assert
result.ShouldBeEquivalentTo(node5);
}
public void Should_Add_Before_Throw_Does_Not_Have_Node()
{
//arrange
var node1 = new MyDoublyLinkedListNode <int>(1);
var node2 = new MyDoublyLinkedListNode <int>(2);
var node3 = new MyDoublyLinkedListNode <int>(3);
var node4 = new MyDoublyLinkedListNode <int>(4);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
node2.Prev = node1;
node3.Prev = node2;
node4.Prev = node3;
var list = new MyDoublyLinkedList <int>(node1);
var node5 = new MyDoublyLinkedListNode <int>(5);
//act
Action act = () => list.AddBefore(new MyDoublyLinkedListNode <int>(6), node5);
//assert
act.ShouldThrow <InvalidOperationException>();
}
public void Should_Add_After_Check_Tail()
{
//arrange
var node1 = new MyDoublyLinkedListNode <int>(1);
var node2 = new MyDoublyLinkedListNode <int>(2);
var node3 = new MyDoublyLinkedListNode <int>(3);
var node4 = new MyDoublyLinkedListNode <int>(4);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
node2.Prev = node1;
node3.Prev = node2;
node4.Prev = node3;
var list = new MyDoublyLinkedList <int>(node1);
var node5 = new MyDoublyLinkedListNode <int>(5);
//act
list.AddAfter(node4, node5);
//assert
list.Count.ShouldBeEquivalentTo(5);
list.Head.ShouldBeEquivalentTo(node1);
list.Tail.ShouldBeEquivalentTo(node5);
list.Head.Next.ShouldBeEquivalentTo(node2);
list.Head.Next.Next.ShouldBeEquivalentTo(node3);
list.Head.Next.Next.Next.ShouldBeEquivalentTo(node4);
list.Head.Next.Next.Next.Next.ShouldBeEquivalentTo(node5);
}
public void Should_Clear()
{
//arrange
var node1 = new MyDoublyLinkedListNode <int>(2);
var node2 = new MyDoublyLinkedListNode <int>(4);
var node3 = new MyDoublyLinkedListNode <int>(3);
var node4 = new MyDoublyLinkedListNode <int>(5);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
node2.Prev = node1;
node3.Prev = node2;
node4.Prev = node3;
var list = new MyDoublyLinkedList <int>(node1);
//act
list.Clear();
//assert
list.Count.ShouldBeEquivalentTo(0);
list.Head.ShouldBeEquivalentTo(list.Tail);
list.Head.Should().BeNull();
}
public void Should_RemoveValue_False()
{
//arrange
var node1 = new MyDoublyLinkedListNode <int>(2);
var node2 = new MyDoublyLinkedListNode <int>(4);
var node3 = new MyDoublyLinkedListNode <int>(3);
var node4 = new MyDoublyLinkedListNode <int>(5);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
node2.Prev = node1;
node3.Prev = node2;
node4.Prev = node3;
var list = new MyDoublyLinkedList <int>(node1);
//act
var result = list.Remove(6);
//assert
result.ShouldBeEquivalentTo(false);
list.Count.ShouldBeEquivalentTo(4);
list.Head.ShouldBeEquivalentTo(node1);
list.Head.Next.ShouldBeEquivalentTo(node2);
list.Head.Next.Next.ShouldBeEquivalentTo(node3);
list.Head.Next.Next.Next.ShouldBeEquivalentTo(node4);
}
public void Should_Copy_To_Throw_If_Incorrect_ArrayIndex()
{
//arrange
var node1 = new MyDoublyLinkedListNode <int>(2);
var node2 = new MyDoublyLinkedListNode <int>(4);
var node3 = new MyDoublyLinkedListNode <int>(3);
var node4 = new MyDoublyLinkedListNode <int>(5);
node1.Next = node2;
node2.Next = node3;
node3.Next = node4;
node2.Prev = node1;
node3.Prev = node2;
node4.Prev = node3;
var list = new MyDoublyLinkedList <int>(node1);
var array = new int[3];
//act
Action actLower = () => list.CopyTo(array, -1);
Action actHigher = () => list.CopyTo(array, 1);
//assert
actLower.ShouldThrow <ArgumentOutOfRangeException>();
actHigher.ShouldThrow <ArgumentOutOfRangeException>();
}
public void MyLinkedList_Equals_OriginalLinkedList()
{
LinkedList <int> originalLinkedList = _linkedListService.CreateLinkedList(new LinkedList <int>()) as LinkedList <int>;
MyDoublyLinkedList <int> myLinkedList = _linkedListService.CreateLinkedList(new MyDoublyLinkedList <int>()) as MyDoublyLinkedList <int>;
ArrangeAndActUponLinkedLists(originalLinkedList, myLinkedList);
Assert.Equal(myLinkedList, originalLinkedList);
}
public void AddAtTailTest()
{
var myLinkedList = new MyDoublyLinkedList();
myLinkedList.AddAtTail(1);
ValidateDoublyLinkedList(myLinkedList);
myLinkedList.Get(0).Should().Be(1);
}
public void Should_Copy_To_Throw_If_Null()
{
//arrange
var list = new MyDoublyLinkedList <int>();
//act
Action act = () => list.CopyTo(null, 1);
//assert
act.ShouldThrow <ArgumentNullException>();
}
public void Should_Add_First_Throw_If_Null()
{
//arrange
var list = new MyDoublyLinkedList <int>();
//act
Action act = () => list.AddFirst(null);
//assert
act.ShouldThrow <ArgumentNullException>();
}
public void Should_RemoveNode_Throw_If_Empty()
{
//arrange
var list = new MyDoublyLinkedList <int>();
//act
Action act = () => list.Remove(null);
//assert
act.ShouldThrow <ArgumentNullException>();
}
public static void AddAtHeadDeleteAt0Test()
{
var myLinkedList = new MyDoublyLinkedList();
myLinkedList.AddAtHead(1);
myLinkedList.DeleteAtIndex(0);
myLinkedList.Value.Should().Be(-1);
myLinkedList.Next.Should().BeNull();
myLinkedList.Prev.Should().BeNull();
}
public void Should_RemoveLast_Throw_If_Empty()
{
//arrange
var list = new MyDoublyLinkedList <int>();
//act
Action act = () => list.RemoveLast();
//assert
act.ShouldThrow <InvalidOperationException>();
}
public void RemoveDups_Should_Check_Empty_List()
{
//arrange
var list = new MyDoublyLinkedList <int>();
//act
var result = _linkedList.RemoveDups(list);
//assert
result.Should().NotBe(null);
result.Head.ShouldBeEquivalentTo(null);
}
public void Should_Create_Empty_List()
{
//arrange
//act
var list = new MyDoublyLinkedList <int>();
//assert
list.Head.ShouldBeEquivalentTo(null);
list.Tail.ShouldBeEquivalentTo(null);
list.Count.ShouldBeEquivalentTo(0);
}
public void Should_Copy_To_Empty_List()
{
//arrange
var list = new MyDoublyLinkedList <int>();
var array = new int[3];
//act
list.CopyTo(array, 1);
//assert
array[0].ShouldBeEquivalentTo(0);
array[1].ShouldBeEquivalentTo(0);
array[2].ShouldBeEquivalentTo(0);
}
public void Should_RemoveNode_Length_One()
{
//arrange
var node = new MyDoublyLinkedListNode <int>(2);
var list = new MyDoublyLinkedList <int>(node);
//act
list.Remove(node);
//assert
list.Count.ShouldBeEquivalentTo(0);
list.Head.ShouldBeEquivalentTo(list.Tail);
list.Head.Should().BeNull();
}
public void Should_Create_List_With_Value()
{
//arrange
int value = 5;
//act
var list = new MyDoublyLinkedList <int>(value);
//assert
list.Head.Should().NotBeNull();
list.Head.Data.ShouldBeEquivalentTo(value);
list.Tail.Should().NotBeNull();
list.Tail.Data.ShouldBeEquivalentTo(value);
list.Count.ShouldBeEquivalentTo(1);
}
public void Should_Add_First_When_List_Is_Empty()
{
//arrange
var list = new MyDoublyLinkedList <int>();
var node = new MyDoublyLinkedListNode <int>(1);
//act
list.AddFirst(node);
//assert
list.Count.ShouldBeEquivalentTo(1);
list.Head.ShouldBeEquivalentTo(list.Tail);
list.Head.ShouldBeEquivalentTo(node);
}
public void AddAtIndexTest()
{
var myLinkedList = new MyDoublyLinkedList();
myLinkedList.AddAtIndex(0, 10);
ValidateDoublyLinkedList(myLinkedList);
myLinkedList.AddAtIndex(0, 20);
ValidateDoublyLinkedList(myLinkedList);
myLinkedList.AddAtIndex(1, 30);
ValidateDoublyLinkedList(myLinkedList);
myLinkedList.Get(0).Should().Be(20);
}
public static void Main(string[] args)
{
MyDoublyLinkedList list = new MyDoublyLinkedList();
list.AddFirst("Hello");
list.AddLast("world");
list.AddLast("!");
list.AddLast("!");
list.AddLast("!");
list.AddLast("!");
list.RemoveByIndex(0);
list.AddFirst("Hi");
// check = true
var check = list.RemoveEveryEqual("!");
var array = list.ToArray();
// Hi
// world
foreach (var @object in array)
{
Console.WriteLine(@object);
}
list.AddFirst("Bob");
list.AddFirst("Eugene");
list[0] = "Zero";
list.RemoveByIndex(1);
list.RemoveFirst();
array = list.ToArray();
// Bob
// Hi
// world
foreach (var @object in array)
{
Console.WriteLine(@object);
}
list.Clear();
}
private static void ValidateDoublyLinkedList(MyDoublyLinkedList head)
{
head.Prev.Should().BeNull();
var prev = head;
head = head.Next;
while (head != null)
{
head.Prev.Should().BeEquivalentTo(prev);
prev.Next.Should().BeEquivalentTo(head);
head = head.Next;
prev = prev.Next;
}
}
public void AddAtHeadAtTailAtIndexTest()
{
var myLinkedList = new MyDoublyLinkedList();
myLinkedList.AddAtHead(1);
ValidateDoublyLinkedList(myLinkedList);
myLinkedList.AddAtTail(3);
ValidateDoublyLinkedList(myLinkedList);
myLinkedList.AddAtIndex(1, 2); // linked list becomes 1->2->3
ValidateDoublyLinkedList(myLinkedList);
myLinkedList.Get(1).Should().Be(2); // return 2
myLinkedList.DeleteAtIndex(1); // now the linked list is 1->3
myLinkedList.Get(1).Should().Be(3); // return 3
}
private void TestDoubleLinkedList()
{
MyDoublyLinkedList list1 = new MyDoublyLinkedList();
list1.Add(4, 0);
list1.Add(3, 0);
list1.Add(1, 0);
list1.Add(2, 1);
list1.Add(5, 4);
list1.Traverse();
list1.Delete(3);
list1.Traverse();
list1.Delete(1);
list1.Traverse();
list1.Delete(0);
list1.Traverse();
WriteLine();
var list2 = new MyDoublyLinkedList();
list2.Add("mot", 0);
list2.Add("hai", 1);
list1.Add(2, 0);
var list = list1 + list2;
list.Traverse();
WriteLine();
try
{
list.Add("data", 50);
}
catch (IndexOutOfRangeException e)
{
WriteLine(e.Message);
}
try
{
(new MyDoublyLinkedList()).Delete(0);
}
catch (InvalidOperationException e)
{
WriteLine(e.Message);
}
}
