static void Main()
{
var list = new DoublyLinkedList <int>();
list.ForEach(Console.WriteLine);
Console.WriteLine("--------------------");
list.AddLast(5);
list.AddFirst(3);
list.AddFirst(2);
list.AddLast(10);
Console.WriteLine("Count = {0}", list.Count);
list.ForEach(Console.WriteLine);
Console.WriteLine("--------------------");
list.RemoveFirst();
list.RemoveLast();
list.RemoveFirst();
list.ForEach(Console.WriteLine);
Console.WriteLine("--------------------");
list.RemoveLast();
list.ForEach(Console.WriteLine);
Console.WriteLine("--------------------");
}
public void RemoveLast_SeveralElements_ShouldRemoveElementsCorrectly()
{
// Arrange
var list = new DoublyLinkedList <int>();
list.AddFirst(10);
list.AddFirst(9);
list.AddFirst(8);
// Act
var element = list.RemoveLast();
// Assert
Assert.AreEqual(10, element);
Assert.AreEqual(2, list.Count);
var items = new List <int>();
list.ForEach(items.Add);
Console.WriteLine(items[0] + items[1]);
CollectionAssert.AreEqual(items, new List <int>()
{
8, 9
});
}
public static void Main()
{
var list = new DoublyLinkedList<int>();
list.ForEach(Console.WriteLine);
Console.WriteLine("--------------------");
list.AddLast(5);
list.AddFirst(3);
list.AddFirst(2);
list.AddLast(10);
Console.WriteLine("Count = {0}", list.Count);
list.ForEach(Console.WriteLine);
Console.WriteLine("--------------------");
list.RemoveFirst();
list.RemoveLast();
list.RemoveFirst();
list.ForEach(Console.WriteLine);
Console.WriteLine("--------------------");
list.RemoveLast();
list.ForEach(Console.WriteLine);
Console.WriteLine("--------------------");
}
public void AddFirstTest()
{
DoublyLinkedList <int> dll = new DoublyLinkedList <int>();
dll.AddFirst(10);
dll.AddFirst(20);
Assert.AreEqual(20, dll.Head.Value);
}
public void AddFirstTest()
{
var list = new DoublyLinkedList<int>();
list.AddFirst(2);
list.AddFirst(4);
list.AddFirst(6);
Assert.AreEqual(list.Head.Value, 6);
Assert.AreEqual(list.Tail.Value, 2);
}
public void List_CorrectlyAddsElement_UsingAddFirst()
{
var doubly = new DoublyLinkedList <int>();
doubly.AddFirst(100);
doubly.AddFirst(200);
Assert.Equal(200, doubly.HeadNode.Value);
Assert.Equal(100, doubly.TailNode.Value);
Assert.Equal(2, doubly.Size);
}
public void AddFirst_and_AddLast_OneItem_CorrectState()
{
_list.AddFirst(1);
Assert.AreEqual(1, _list.Count);
Assert.IsFalse(_list.IsEmpty);
Assert.AreSame(_list.Head, _list.Tail);
_list.AddLast(5);
_list.AddFirst(2);
Assert.AreEqual(3, _list.Count);
}
public static void Main()
{
var list = new DoublyLinkedList <int>();
list.AddFirst(10);
list.AddFirst(7);
list.AddFirst(33);
Console.WriteLine(list.RemoveFirst());
list.ForEach(Console.WriteLine);
}
public void AddFirst3Reverse()
{
string expected = "1/2/3/";
DoublyLinkedList testList = new DoublyLinkedList();
testList.AddFirst("1");
testList.AddFirst("2");
testList.AddFirst("3");
string actual = testList.ReverseShow();
Assert.AreEqual(expected, actual);
}
public void Clear()
{
DoublyLinkedList <int> dll = new DoublyLinkedList <int>();
dll.AddFirst(new DoublyLinkedListNode <int>(10));
dll.AddFirst(new DoublyLinkedListNode <int>(20));
dll.AddLast(new DoublyLinkedListNode <int>(30));
dll.AddLast(new DoublyLinkedListNode <int>(40));
dll.Clear();
Assert.AreEqual(dll.Count, 0);
}
public void AddFirst()
{
DoublyLinkedList <int> dll = new DoublyLinkedList <int>();
dll.AddFirst(new DoublyLinkedListNode <int>(10));
dll.AddFirst(new DoublyLinkedListNode <int>(20));
dll.AddFirst(new DoublyLinkedListNode <int>(30));
//30 <-> 20 <-> 10 : Head 20, Tail 10
Assert.AreEqual(dll.Head.Value, 30);
Assert.AreEqual(dll.Head.Next.Value, 20);
Assert.AreEqual(dll.Tail.Value, 10);
Assert.AreEqual(dll.Tail.Previous.Value, 20);
}
public void Add()
{
var list = new DoublyLinkedList<int>(2);
list.AddFirst(1);
list.AddLast(3);
list.AddFirst(0);
list.AddLast(4);
for (var i = 0; i < 5; i++)
{
Assert.AreEqual(i, list[i].Value);
}
}
public void InitializeListFromIEnumeraable()
{
var list = new DoublyLinkedList <int>();
int itemCount = 1000;
for (int i = 0; i < itemCount; i++)
{
list.AddFirst(i);
}
var list2 = new DoublyLinkedList <int>(list);
if (list.Count != list2.Count)
{
Assert.Fail();
}
foreach (var item in list)
{
if (item != list2.First.Value)
{
Assert.Fail();
}
list2.RemoveFirst();
}
Assert.IsTrue(list.Count == itemCount &&
list2.Count == 0);
}
public void AddFirstForAllElementsAndCheckForOrder()
{
var list = new DoublyLinkedList <int>();
int itemCount = 1000;
for (int i = 0; i < itemCount; i++)
{
list.AddFirst(i);
}
int previous = itemCount;
int numberOfElementsInList = 0;
foreach (var item in list)
{
if (previous < item)
{
Assert.Fail();
}
previous = item;
numberOfElementsInList++;
}
Assert.IsTrue(list.Count == itemCount &&
numberOfElementsInList == list.Count);
}
void AddList(IReadOnlyList <int> collection, IReadOnlyList <int> items, bool reversed, bool isMutated, IReadOnlyList <int> expected)
{
// Arrange
var left = new DoublyLinkedList <int>(collection);
var version = left.Version;
var right = new DoublyLinkedList <int>(items);
// Act
left.AddFirst(right, reversed);
// Assert
if (isMutated)
{
left.Version.Must().BeNotEqualTo(version);
}
else
{
left.Version.Must().BeEqualTo(version);
}
left.EnumerateForward().Must()
.BeEnumerableOf <int>()
.BeEqualTo(expected);
left.EnumerateReversed().Must()
.BeEnumerableOf <int>()
.BeEqualTo(expected.Reverse());
}
public void AddFirstTest(int val, int[] expected)
{
list = new DoublyLinkedList(new int[] { 0, 1, 2, 3 });
list.AddFirst(val);
int[] actual = list.ToArray();
Assert.AreEqual(expected, actual);
}
public void AddFirst_WhenCalled_ShouldAddNodeWithGivenValueToHeadOfLinkedList(int range, int value)
{
// Arrange
for (var i = 0; i < range; i++)
{
_list.Add(i);
}
var prevSize = _list.Size;
var next = _list.Size == 0 ? null : _list.Get(0);
// Act
_list.AddFirst(value);
// Assert
var result = _list.Get(0);
Assert.That(
result,
Is.Not.Null
.And.Property(nameof(DoublyLinkedList <int> .Node.Value)).EqualTo(value));
Assert.That(result.Prev, Is.Null);
Assert.That(result.Next, Is.EqualTo(next));
Assert.That(next?.Prev, Is.EqualTo(_list.Size == 1 ? null : result));
Assert.That(_list.Size, Is.EqualTo(prevSize + 1));
Assert.That(_list.Head, Is.EqualTo(result));
}
public void AddFirstArrayTest(int[] original, int[] values, int[] expected)
{
DoublyLinkedList sList = new DoublyLinkedList(original);
sList.AddFirst(values);
Assert.AreEqual(expected, sList.ToArray());
}
public void AddFirstPUT([PexAssumeUnderTest] IList <int> values, int toAddValue)
{
DoublyLinkedList <int> dll = new DoublyLinkedList <int>(values);
dll.AddFirst(toAddValue);
PexAssert.AreEqual(toAddValue, dll.Head.Value);
}
public static void Main(string[] args)
{
DoublyLinkedList <int> doublyLinkedList = new DoublyLinkedList <int>();
SinglyLinkedList <int> singlyLinkedList = new SinglyLinkedList <int>();
Console.WriteLine($"DoublyLinkedList.IsEmpty() == {doublyLinkedList.IsEmpty()}");
doublyLinkedList.AddFirst(5);
doublyLinkedList.AddFirst(20);
doublyLinkedList.AddLast(25);
doublyLinkedList.AddLast(41);
Console.WriteLine($"DoublyLinkedList.First() == {doublyLinkedList.First()}");
Console.WriteLine($"DoublyLinkedList.Last() == {doublyLinkedList.Last()}");
Console.WriteLine($"DoublyLinkedList.Size() == {doublyLinkedList.Size()}");
Console.WriteLine($"DoublyLinkedList.IsEmpty() == {doublyLinkedList.IsEmpty()}");
// Output
// ----------------
// True
// 20
// 41
// 4
// False
Console.WriteLine("");
Console.WriteLine($"SinglyLinkedList.IsEmpty() == {singlyLinkedList.IsEmpty()}");
singlyLinkedList.Add(2);
singlyLinkedList.Add(9);
singlyLinkedList.AddLast(21);
singlyLinkedList.AddLast(35);
Console.WriteLine($"SinglyLinkedList.First() == {singlyLinkedList.First()}");
Console.WriteLine($"SinglyLinkedList.Last() == {singlyLinkedList.Last()}");
Console.WriteLine($"SinglyLinkedList.Size() == {singlyLinkedList.Size()}");
Console.WriteLine($"SinglyLinkedList.IsEmpty() == {singlyLinkedList.IsEmpty()}");
// Output
// ----------------
// True
// 9
// 35
// 4
// False
}
public void AddFirst_SeveralElements()
{
var list = new DoublyLinkedList <int>();
list.AddFirst(10);
list.AddFirst(5);
list.AddFirst(3);
Assert.AreEqual(3, list.Count);
var items = new List <int>();
list.ForEach(items.Add);
CollectionAssert.AreEqual(items, new List <int> {
3, 5, 10
});
}
static void Main()
{
var list = new DoublyLinkedList <int>();
list.AddFirst(10);
list.AddFirst(30);
list.AddLast(50);
list.AddLast(70);
list.RemoveFirst();
foreach (var el in list)
{
Console.WriteLine(el);
}
list.RemoveFirst();
}
public void CanAddFirst()
{
DoublyLinkedList <int> doublyLinkedList = new DoublyLinkedList <int>(5);
doublyLinkedList.AddFirst(7);
Assert.AreEqual(7, doublyLinkedList.First.Value);
}
public void InsertAfter()
{
IDoublyLinkedList <int> list = new DoublyLinkedList <int>();
list.AddFirst(new DoublyLinkedListNode <int>(22));
list.AddAfter(22, new DoublyLinkedListNode <int>(1));
Assert.AreEqual(list.FindLastNode().Value, 1);
}
public void AddFirstTest()
{
var list = new DoublyLinkedList <int>();
list.AddFirst(1);
Assert.IsTrue(list.First == list.Last, "Incorrectly added node");
}
public void AddFirst_SeveralElements_ShouldAddElementsCorrectly()
{
// Arrange
var list = new DoublyLinkedList<int>();
// Act
list.AddFirst(10);
list.AddFirst(5);
list.AddFirst(3);
// Assert
Assert.AreEqual(3, list.Count);
var items = new List<int>();
list.ForEach(items.Add);
CollectionAssert.AreEqual(items, new List<int>() { 3, 5, 10 });
}
public void AddFirst_SeveralElements_ShouldAddElementsCorrectly()
{
// Arrange
var list = new DoublyLinkedList<int>();
// Act
list.AddFirst(10);
list.AddFirst(5);
list.AddFirst(3);
// Assert
Assert.AreEqual(3, list.Count);
var items = new List<int>();
list.ForEach(items.Add);
CollectionAssert.AreEqual(items, new List<int>() { 3, 5, 10 });
}
public void AddFirst_ShouldWork()
{
list.AddFirst(3);
Assert.Equal(1, list.Size());
list.AddFirst(5);
Assert.Equal(2, list.Size());
}
public void RemoveHeadTail()
{
DoublyLinkedList <int> dll = new DoublyLinkedList <int>();
dll.AddFirst(new DoublyLinkedListNode <int>(10));
dll.AddFirst(new DoublyLinkedListNode <int>(20));
//20 <-> 10 Head 20, Tail 10
dll.Remove(10); // 20 <-> 30 <-> 40 : Head 10, Tail 40
Assert.AreEqual(dll.Head.Value, 20);
dll.Remove(20);
Assert.AreEqual(dll.Count, 0);
}
public void RemoveFirst()
{
DoublyLinkedList <int> dll = new DoublyLinkedList <int>();
dll.AddFirst(new DoublyLinkedListNode <int>(10));
dll.AddFirst(new DoublyLinkedListNode <int>(20));
dll.AddLast(new DoublyLinkedListNode <int>(30));
dll.AddLast(new DoublyLinkedListNode <int>(40));
//20 <-> 10 <-> 30 <-> 40 : Head 20, Tail 40
dll.RemoveFirst(); // 10 <-> 30 <-> 40 : Head 10, Tail 40
Assert.AreEqual(dll.Head.Value, 10);
Assert.AreEqual(dll.Head.Next.Value, 30);
Assert.AreEqual(dll.Tail.Value, 40);
Assert.AreEqual(dll.Tail.Previous.Value, 30);
}
public void Contains()
{
DoublyLinkedList <int> dll = new DoublyLinkedList <int>();
dll.AddFirst(new DoublyLinkedListNode <int>(10));
dll.AddFirst(new DoublyLinkedListNode <int>(20));
dll.AddLast(new DoublyLinkedListNode <int>(30));
dll.AddLast(new DoublyLinkedListNode <int>(40));
//20 <-> 10 <-> 30 <-> 40 : Head 20, Tail 40
Assert.AreEqual(dll.Contains(10), true);
Assert.AreEqual(dll.Contains(20), true);
Assert.AreEqual(dll.Contains(30), true);
Assert.AreEqual(dll.Contains(40), true);
Assert.AreEqual(dll.Contains(100), false);
}
public void Add_First_Item_Test()
{
int expectedCount = 6;
DoublyLinkedList <int> list = InitLinkedList();
list.AddFirst(0);
Assert.IsTrue(list.Count == expectedCount);
Assert.IsTrue(list.Head.Value == 0);
}
public void AddAfterTest()
{
var list = new DoublyLinkedList <int>();
var node = list.AddFirst(1);
node = list.AddAfter(node, 2);
node = list.AddAfter(node, 3);
Assert.IsTrue(list.Last.Value == 3, "Incorrectly added node");
}
public void FindFirstTest()
{
var list = new DoublyLinkedList <int>();
var node = list.AddFirst(1);
node = list.AddAfter(node, 2);
node = list.FindFirst(2);
Assert.IsTrue(node != null, "Node find incorrect");
}
static void Main(string[] args)
{
try
{
DoublyLinkedList<Person> list = new DoublyLinkedList<Person>();
list.AddFirst(new Person("Nikita Vasilyev", 24));
list.AddFirst(new Person("Bill Gates", 59));
list.AddFirst(new Person("Muhhamed Ali", 76));
list.AddLast(new Person("Lennox Lewis", 46));
list.InsertAt(new Person("Steve Jobs", 54), 2);
list.Show();
list.RemoveAt(4);
Console.WriteLine(list[2]);
Person p = new Person("Nikita Vasilyev", 24);
Console.WriteLine(list.Find(p));
list.FindLast(p).FullName = "Nikita V. Vasilyev";
list.ShowReverse();
list.Show();
}
catch (IndexOutOfRangeException ex)
{
Console.WriteLine("Message:\t" + ex.Message);
Console.WriteLine("Method:\t\t" + ex.TargetSite);
}
catch (ArgumentNullException ex)
{
Console.WriteLine("Message:\t" + ex.Message);
Console.WriteLine("Method:\t\t" + ex.TargetSite);
}
catch (InvalidOperationException ex)
{
Console.WriteLine("Message:\t" + ex.Message);
Console.WriteLine("Method:\t\t" + ex.TargetSite);
}
catch (Exception ex)
{
Console.WriteLine("Message:\t" + ex.Message);
Console.WriteLine("Method:\t\t" + ex.TargetSite);
}
}
public void AddFirst_EmptyList_ShouldAddElement()
{
// Arrange
var list = new DoublyLinkedList<int>();
// Act
list.AddFirst(5);
// Assert
Assert.AreEqual(1, list.Count);
var items = new List<int>();
list.ForEach(items.Add);
CollectionAssert.AreEqual(items, new List<int>(){ 5 });
}
public void RemoveLast_OneElement_ShouldMakeListEmpty()
{
// Arrange
var list = new DoublyLinkedList<int>();
list.AddFirst(5);
// Act
var element = list.RemoveLast();
// Assert
Assert.AreEqual(5, element);
Assert.AreEqual(0, list.Count);
var items = new List<int>();
list.ForEach(items.Add);
CollectionAssert.AreEqual(items, new List<int>() { });
}
public void AddFirstTest()
{
DoublyLinkedList<int> dll = new DoublyLinkedList<int>();
dll.AddFirst(10);
dll.AddFirst(20);
Assert.AreEqual(20, dll.Head.Value);
}
public void Traverse()
{
var list = new DoublyLinkedList<int>(new[] { 1, 2, 3 });
// Perform various operations
list.AddFirst(0);
list.RemoveFirst();
list.AddLast(0);
list.RemoveLast();
list.Insert(1, 0);
list.RemoveAt(1);
var current = list.First;
while (current.Next != null)
{
current = current.Next;
}
Assert.AreEqual(list.Last, current);
while (current.Previous != null)
{
current = current.Previous;
}
Assert.AreEqual(list.First, current);
}
public void RemoveLast_SeveralElements_ShouldRemoveElementsCorrectly()
{
// Arrange
var list = new DoublyLinkedList<int>();
list.AddFirst(10);
list.AddFirst(9);
list.AddFirst(8);
// Act
var element = list.RemoveLast();
// Assert
Assert.AreEqual(10, element);
Assert.AreEqual(2, list.Count);
var items = new List<int>();
list.ForEach(items.Add);
CollectionAssert.AreEqual(items, new List<int>() { 8, 9 });
}
public void AddFirstPUT([PexAssumeUnderTest]IList<int> values, int toAddValue)
{
DoublyLinkedList<int> dll = new DoublyLinkedList<int>(values);
dll.AddFirst(toAddValue);
PexAssert.AreEqual(toAddValue, dll.Head.Value);
}