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);
}