First of all, C# already has a generic LinkedList implementation, found in the System.Collections class. If you are looking for that class, the MSDN website provides a solid introduction.

After building a basic link list class in a previous post, I decided to extend it. To avoid cloning the C# System.Collections class completely I used the Java LinkedList specification instead to roll my own. That meant implementing an iterator and methods such as AddFirst, AddLast, Clear, ToArray etc. To be able to support this the internal working of my earlier class had to be reworked substantially. I have included the complete code for reference below.

My main purpose for writing this code was to experiment with using NUnit. NUnit is a testing framework which allows you to create unit tests for your code. As you implement a method you write a small test to ensure that it works correctly. Because you are adding functionality to the class as you write new code the underlying methods might change in unexpected ways. Unit tests help you catch bugs introduced this way.

In earlier posts I commented on how to use NUnit if you are coding in Visual Studio C# 2008 Express ; and how to use NUnit if you are building your applications with MonoDevelop so if you are having trouble setting this up please refer to these.

Creating new and interesting bugs

As a late optimization to my LinkedList class I added “Search Backwards” logic to the “Get(n)” method.

As you can guess, the “Get(n)” method returns the n^th item in the list. To find it the n^th element we need to step through the list from the start. If we work out that the item is closer the tail of the list we can save some time by stepping backwards through the list instead. Unit testing helped here as I had made a small bit significant error in how I calculated the distance from the tail. Several tests immediately failed as they now received unexpected results.

Creating the Unit Tests

The best place to put your tests is in a separate class file. As can be seen in the code snippet below the first thing we need to do is to include the NUnit.Framework in the code. The first thing to notice about this class is that it has a [TestFixture] attribute – this is how we indicate that the class contains test code. The class has to be public. As we can run NUnit tests independently of your programs main routine, NUnit will simply load your programs classes and use the [TestFixture] attribute to discover any and all tests classes.

Each method containing a valid test has a [Test] attribute associated with it. Again, NUnit will simply scan the [TestFixture] classes for any method labeled with a [Test] attribute.

In the example below I included a very simple test for the Add() method of my linked list. After adding 2 items to the LinkedList, the total number of items has to be 2. Testing is done through the Assert class, if the Assert test fails, NUnit will flag the test as failed. Some other common Assert methods are: AreEqual(a,b) / AreNotEquels(a,b) / Equals / IsTrue / IsFalse etc.

using System;
using System.Text;
using NUnit.Framework;

namespace LinkedListJavaStyle
{
    /// <summary>
    /// LinkedList_NUnit is a class implementing a set of unit tests for each of the methods supported by the LinkedList class
    /// </summary>

    [TestFixture]
    public class LinkedList_NUnit
    {

        [Test]
        public void TestLinkedList_add()
        {
            LinkedList<string> Test = new LinkedList<string>();
            Test.Add("Hello World");
            Test.Add("The world today");
            Assert.AreEqual(2, Test.Size());
        }
}

The complete LinkedListClass.cs and set of tests (LinkedList_NUnit.cs) are given below:

LinkedList.cs

using System;
using System.Text;
using NUnit.Framework;

namespace LinkedListJavaStyle
{
    /// <summary>
    /// LinkedList_NUnit is a class implementing a set of unit tests for each of the methods supported by the LinkedList class
    /// </summary>

    [TestFixture]
    public class LinkedList_NUnit
    {

        [Test]
        public void TestLinkedList_add()
        {
            LinkedList<string> Test = new LinkedList<string>();
            Test.Add("Hello World");
            Test.Add("The world today");
            Assert.AreEqual(2, Test.Size());
        }
}

The complete LinkedListClass and set of tests are given below:

// LinkedList.cs created with MonoDevelop
// User: martijn at 10:02 AM 12/30/2008

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;

namespace LinkedListJavaStyle
{

    /// <summary>
    /// LinkedListElement is the memory structure used by the LinkedList class for storing each list cell.
    /// Every element contains a pointer to the previous and next element and a copy of the data.
    /// </summary>
    /// <typeparam name="T">The same as for LinkedList</typeparam>

    class LinkedListNode<T>
    {
        public T Data;
        public LinkedListNode<T> Prev;
        public LinkedListNode<T> Next;

        public LinkedListNode(T Data)
        {
            this.Data = Data;
        }
    }

    /// <summary>
    /// Linked List implementation following the model layed out by the Java LinkedList Class. Implements all list operations and permits
    /// all elements (including null). Operations that need to enter the list will travel through the list from beginning to end until
    /// the required offset is found (or from the tail if the distance is shorter).
    ///
    /// The class is implemented as a double linked list.
    /// </summary>
    /// <typeparam name="T">This class accepts any type you would like to use for the generic.</typeparam>

    class LinkedList<T>
    {

        LinkedListNode<T> Head;
        LinkedListNode<T> Tail;
        int LinkedList_Size;

        /// ---------------------------------------------------------------------------------------
        /// <summary>
        /// Constructor
        /// </summary>

        public LinkedList()
        {
            Head = null;
            Tail = null;
            LinkedList_Size = 0;
        }

        /// <summary>
        /// Constructs a list containing the elements of the specified collection, in the order that they are
        /// returned by the collections itterator.
        /// </summary>
        /// <param name="collection">An array of type T containing the elements to be added to the list</param>

        public LinkedList(T[] collection)
        {
            Head = null;
            Tail = null;
            LinkedList_Size = 0;
            AddAll_Internal(Tail, collection);
        }

        /// <summary>
        /// Private function which inserts a T element before the offset given in the list
        /// </summary>
        /// <param name="offset">A LinkedListElement before which the new elements needs to be inserted</param>
        /// <param name="element">The element to be inserted</param>
        /// <returns>A reference to the newly created LinkedListElement</returns>

        private LinkedListNode<T> Add_Internal_Before(LinkedListNode<T> offset, T element)
        {
            if (offset == null)
                throw new Exception("Add_Internal: null is not a valid argument");

            LinkedListNode<T> Listelement = new LinkedListNode<T>(element);

            Listelement.Prev = offset.Prev;
            Listelement.Next = offset;

            if (offset.Prev != null) offset.Prev.Next = Listelement;
            offset.Prev = Listelement;

            if (offset == Head)
                Head = Listelement;

            LinkedList_Size++;

            return Listelement;
        }

        /// <summary>
        /// Private function which inserts a T element after the offset given in the list
        /// </summary>
        /// <param name="offset">The LinkedListElement after which we need to insert the new element</param>
        /// <param name="element">The element to be inserted</param>
        /// <returns>A reference to the newly created LinkListElement</returns>

        private LinkedListNode<T> Add_Internal_After(LinkedListNode<T> offset, T element)
        {
            if (offset == null)
                throw new Exception("Add_Internal: null is not a valid argument");

            LinkedListNode<T> Listelement = new LinkedListNode<T>(element);

            Listelement.Prev = offset;
            Listelement.Next = offset.Next;
            if (offset.Next != null) offset.Next.Prev = Listelement;
            offset.Next = Listelement;

            if (offset == Tail)
                Tail = Listelement;

            LinkedList_Size++;

            return Listelement;
        }

        /// <summary>
        /// Adds the specified element at the specified position in the list
        /// </summary>
        /// <param name="Index">The index at which to insert the element</param>
        /// <param name="element">The element of T to insert</param>
        /// <returns>True as per Java implementation</returns>

        public bool Add(int Index, T element)
        {
            if ((Index == 0) && (Head == null))
                AddFirst(element);
            else
                Add_Internal_Before(Get_Internal(Index), element);
            return true;
        }

        /// <summary>
        /// Adds the element to the end of the list
        /// </summary>
        /// <param name="element">The element of type T to insert</param>

        public void Add(T element)
        {
            if (Head == null)
                AddFirst(element);
            else
                Add_Internal_After(Tail, element);
        }

        /// <summary>
        /// Adds the element at the beginning of the list
        /// </summary>
        /// <param name="element">The element to add to the list</param>

        public void AddFirst(T element)
        {
            LinkedListNode<T> ListElement = new LinkedListNode<T>(element);
            if (Tail == null)
            {
                Tail = ListElement;
            }
            else
            {
                ListElement.Next = Head;
                Head.Prev = ListElement;
            }
            Head = ListElement;
            LinkedList_Size++;
        }

        /// <summary>
        /// Adds the given element to the end of the list
        /// </summary>
        /// <param name="element">Element to add to the list</param>

        public void AddLast(T element)
        {
            LinkedListNode<T> Listelement = new LinkedListNode<T>(element);
            if (Head == null)
            {
                Head = Listelement;
            }
            else
            {
                Listelement.Prev = Tail;
                Tail.Next = Listelement;
            }
            Tail = Listelement;
            LinkedList_Size++;
        }

        /// <summary>
        /// Private function which adds all the elements in the given collection to the list
        /// </summary>
        /// <param name="start">A LinkedListElement giving the starting point in the list</param>
        /// <param name="collection">Elements to add to the list</param>

        private void AddAll_Internal(LinkedListNode<T> start, T[] collection)
        {
            // The set of elements is inserted before start, but then needs to follow the
            // newly inserted first element.
            bool First = true;
            foreach (T element in collection)
            {
                if (Head == null)
                {
                    AddFirst(element);
                    start = Head;
                    First = false;
                }
                else
                {
                    if (First)
                    {
                        start = Add_Internal_Before(start, element);
                        First = false;
                    }
                    else
                        start = Add_Internal_After(start, element);
                }
            }
        }

        /// <summary>
        /// Adds all the elements in the collection to the end of the list
        /// </summary>
        /// <param name="collection">An array of T with all the elements to add</param>

        public void AddAll(T[] collection)
        {
            // Obtain the element at the given offset
            AddAll_Internal(Tail, collection);
        }

        /// <summary>
        /// Adds all the elements in the collection to the list from the end
        /// </summary>
        /// <param name="collection">An array of T with all the elements to add</param>

        public void AddAll(int index, T[] collection)
        {
            AddAll_Internal(Get_Internal(index), collection);
        }

        /// <summary>
        /// Empties the list by unlinking all elements.
        /// </summary>

        public void Clear()
        {
            LinkedListNode<T> Temp;

            while (Head != null)
            {
                Temp = Head;
                Head = Head.Next;

                Temp.Prev = null;
                Temp.Next = null;
            }

            Tail = null;
            LinkedList_Size = 0;
        }

        /// <summary>
        /// Returns a copy of the LinkedList containing all the elements.
        /// </summary>
        /// <returns>A LinkedList of the same type</returns>

        public LinkedList<T> Clone()
        {
            LinkedList<T> ClonedCopy = new LinkedList<T>();

            LinkedListNode<T> Iterator = Head;
            while (Iterator != null)
            {
                ClonedCopy.AddLast(Iterator.Data);
                Iterator = Iterator.Next;
            }
            return ClonedCopy;
        }

        // Contains
        // Returns true if the list contains the specified element

        public bool Contains(T needle)
        {
            LinkedListNode<T> Iterator = Head;
            while (Iterator != null)
            {
                // Check for null in the needle
                if ((needle == null)&&(Iterator.Data == null))
                  return true;

                // Check for null in the list
                if (Iterator.Data != null)
                    if (Iterator.Data.Equals(needle))
                        return true;

                // Not found, continue to the next entry
                Iterator = Iterator.Next;
            }
            return false;
        }

        /// <summary>
        /// Returns the number of elements in this list
        /// </summary>
        /// <returns>the number of elements in the list</returns>

        public int Size()
        {
            return LinkedList_Size;
        }

        /// <summary>
        /// An internal function which travels the list to find the specified index.
        /// The function travels forward/backward depending on whether the head or
        /// tail is closer to the specified index.
        /// </summary>
        /// <param name="Index">The position in the list to find.</param>
        /// <returns></returns>

        private LinkedListNode<T> Get_Internal(int Index)
        {
            if ((LinkedList_Size == 0) || (Index < 0) || (Index >= LinkedList_Size))
                throw new IndexOutOfRangeException("LinkedList<T> Invalid Index");

            LinkedListNode<T> iterator;
            int DistanceFromHead = Index;
            int DistanceFromTail = LinkedList_Size - Index -1;  

            if (DistanceFromHead < DistanceFromTail)
            {
                // We travel forward if the index is closer to the beginning
                iterator = Head;
                while (iterator != null && DistanceFromHead-- > 0)
                    iterator = iterator.Next;
            }
            else
            {
                // We travel backward if the index is closer to the end
                iterator = Tail;
                while (iterator != null && DistanceFromTail-- > 0)
                    iterator = iterator.Prev;
            }

            return iterator;
        }

        /// <summary>
        /// Returns the value of the specified element in the list
        /// </summary>
        /// <param name="index">The index item to return</param>
        /// <returns>The value of the element specified </returns>
        /// <throws>IndexOutOfBoundsException if the index is out of range (smaller than 0 or index >= size()</throws>

        public T Get(int index)
        {
            return Get_Internal(index).Data;
        }

        /// <summary>
        /// Returns the value stored at the head of the list
        /// </summary>
        /// <returns>The value stored at the head of the list</returns>

        public T GetFirst()
        {
            if (LinkedList_Size == 0)
                throw new IndexOutOfRangeException("LinkedList<T> Invalid Index");
            return Head.Data;
        }

        /// <summary>
        /// Returns the value stored at the tail of the list
        /// </summary>
        /// <returns>The value stored at the tail of the list</returns>

        public T GetLast()
        {
            if (LinkedList_Size == 0)
                throw new IndexOutOfRangeException("LinkedList<T> Invalid Index");
            return Tail.Data;
        }

        /// <summary>
        /// Search for the given element in the list and return the LinkedListNode
        /// </summary>
        /// <param name="element">Element to search for</param>
        /// <returns></returns>

        private LinkedListNode<T> IndexOf_Internal(T element)
        {
            int Index = 0;
            LinkedListNode<T> Iterator = Head;
            while (Iterator != null)
            {
                // Check for null in the needle
                if ((element == null) && (Iterator.Data == null))
                    return Iterator;

                // Check for null in the list
                if (Iterator.Data != null)
                    if (Iterator.Data.Equals(element))
                        return Iterator;

                Index++;
                Iterator = Iterator.Next;
            }
            return null;
        }

        /// <summary>
        /// This routine searches the linked list for the first occurance of the specified element
        /// </summary>
        /// <param name="element">The value to look for, null is also possible</param>
        /// <returns>The index of the item searched, or -1 if not found</returns>

        public int IndexOf(T element)
        {
            int Index = 0;
            LinkedListNode<T> Iterator = Head;
            while (Iterator != null)
            {
                // Check for null in the needle
                if ((element == null) && (Iterator.Data == null))
                    return Index;

                // Check for null in the list
                if (Iterator.Data != null)
                    if (Iterator.Data.Equals(element))
                        return Index;

                Index++;
                Iterator = Iterator.Next;
            }
            return -1;
        }

        /// <summary>
        /// Returns the last occurance of the specified element in the list
        /// </summary>
        /// <param name="element">The value to search for</param>
        /// <returns>The index of the element, or -1 if not found</returns>

        public int LastIndexOf(T element)
        {
            int Index = LinkedList_Size;
            LinkedListNode<T> Iterator = Tail;
            while (Iterator != null)
            {
                Index--;

                // Check for null in the element
                if ((element == null) && (Iterator.Data == null))
                    return Index;

                // Check for null in the list before checking the content
                if (Iterator.Data != null)
                    if (Iterator.Data.Equals(element))
                        return Index;

                Iterator = Iterator.Prev;
            }
            return -1;
        }

        /// <summary>
        /// An internal function which unlinks a specified link in the list chain.
        /// </summary>
        /// <param name="element">A reference to the list item to unlink</param>

        public void Remove_Internal(LinkedListNode<T> element)
        {
            if (element == null)
                throw new Exception("LinkedListNode<T> null is not a valid argument");

            if (element == Head)
                Head = element.Next;

            if (element == Tail)
                Tail = element.Prev;

            if (element.Prev != null)
                element.Prev.Next = element.Next;

            if (element.Next != null)
                element.Next.Prev = element.Prev;

            LinkedList_Size--;
        }

        /// <summary>
        /// This function removes the specified index item from the list
        /// </summary>
        /// <param name="Index"></param>
        /// <throws>IndexOutOfRangeException if an invalid index is given</throws>
        /// <returns></returns>

        public T Remove(int Index)
        {
            LinkedListNode<T> Element = Get_Internal(Index);

            T Data = Element.Data;

            Remove_Internal(Element);

            return Data;
        }

        /// <summary>
        /// Searches the list for the first occurance of the specified element, and removes it.
        /// </summary>
        /// <param name="element">Element to remove</param>
        /// <returns>True if the element was found and removed, False if not found</returns>

        public bool Remove(T element)
        {
            LinkedListNode<T> Node = IndexOf_Internal(element);

            // Find the element offset
            if (Node != null)
            {
                // This is bad -- we walk the list twice -- need to optimize
                Remove_Internal(Node);
                return true;
            }

            return false;
        }

        /// <summary>
        /// This routine removes the first element from the list
        /// </summary>
        /// <returns>The value of the element removed</returns>
        /// <throws>IndexOutofRangException if the list is empty</throws>

        public T RemoveFirst()
        {
            if (LinkedList_Size == 0)
                throw new IndexOutOfRangeException("LinkedList<T> Empty List");

            T Data = Head.Data;

            Remove_Internal(Head);

            return Data;
        }

        /// <summary>
        /// Remove the last element of the list
        /// </summary>
        /// <returns>The value of the element removed</returns>
        /// <throws>IndexOutofRangException if the list is empty</throws>

        public T RemoveLast()
        {
            if (LinkedList_Size == 0)
                throw new IndexOutOfRangeException("LinkedList<T> Empty List");

            T Data = Tail.Data;

            Remove_Internal(Tail);

            return Data;
        }

        /// <summary>
        /// This routine inserts the given element at the given index
        /// </summary>
        /// <param name="Index">The index to insert the element at</param>
        /// <param name="element">The element to insert</param>
        /// <returns></returns>

        public T Set(int Index, T element)
        {
            LinkedListNode<T> OldListEntry = Get_Internal(Index);

            // Keep a pointer to the old data object
            T Temp = OldListEntry.Data;

            // Swap it with the new data object
            OldListEntry.Data = element;

            // And return the old one
            return Temp;
        }

        /// <summary>
        /// Returns an array containing all the elements in the list in the head-tail order
        /// </summary>
        /// <returns>An array of T[] containing all the elements in the list</returns>

        public T[] ToArray()
        {
            LinkedListNode<T> iterator = Head;
            T[] DataArray = new T[LinkedList_Size];
            int Index = 0;

            while (iterator != null)
            {
                DataArray[Index++] = iterator.Data;
                iterator = iterator.Next;
            }

            return DataArray;
        }

        /// <summary>
        /// Returns a list iterator of the elements in this list implementing the IENumerator interface.
        /// </summary>
        /// <returns>IENumerator </returns>

        public IEnumerator<T> GetEnumerator()
        {
            return new LinkedListEnumerator(this);
        }

        /// <summary>
        /// The LinkedListEnumerator is an nested class implementing the IENumerator interface. Making it
        /// possible to call foreach() on the list.
        /// </summary>

        class LinkedListEnumerator : IEnumerator<T>
        {
            LinkedListNode<T> start;
            LinkedListNode<T> current;

            public LinkedListEnumerator(LinkedList<T> list)
            {
                start = list.Head;
                current = null;
            }
            public bool MoveNext()
            {
                if (current == null) current = start;
                else current = current.Next;
                return (current != null);
            }

            public T Current
            {
                get
                {
                    if (current == null)
                        throw new InvalidOperationException();
                    return current.Data;
                }
            }

            object IEnumerator.Current
            {
                get
                {
                    if (current == null)
                        throw new InvalidOperationException();
                    return current.Data;
                }
            }

            public void Dispose() { }
            public void Reset() { current = null; }
        }

    }

}

LinkedList_NUnit.cs

using System;
using System.Text;
using NUnit.Framework;

namespace LinkedListJavaStyle
{
    /// <summary>
    /// LinkedList_NUnit is a class implementing a set of unit tests for each of the methods supported by the LinkedList class
    /// </summary>

    [TestFixture]
    public class LinkedList_NUnit
    {

        [TestX]
        public void TestLinkedList_add()
        {
            LinkedList<string> Test = new LinkedList<string>();
            Test.Add("Hello World");
            Test.Add("The world today");
            Assert.AreEqual(2, Test.Size());
        }

        [Test]
        public void TestLinkedList_Add_AtIndex()
        {
            LinkedList<string> Test = new LinkedList<string>();
            Test.Add("Hello World");
            Test.Add("The world today");
            Test.Add("Boom Boom");
            Test.Add(2, "Much Wiser");
            Assert.AreEqual(4, Test.Size());
            string Value = Test.Get(2);
            Assert.AreEqual("Much Wiser", Value);
        }

        [Test]
        public void TestLinkedList_Add_AtFirst()
        {
            LinkedList<string> Test = new LinkedList<string>();
            Test.Add("Hello World");
            Test.Add("The world today");
            Test.AddFirst("Much Wiser");
            Assert.AreEqual(3, Test.Size());
            string Value = Test.Get(0);
            Assert.AreEqual("Much Wiser", Value);
        }

        [Test]
        public void TestLinkedList_Add_AtLast()
        {
            LinkedList<string> Test = new LinkedList<string>();
            Test.Add("Hello World");
            Test.Add("The world today");
            Test.AddLast("Much Wiser");
            Assert.AreEqual(3, Test.Size());
            string Value = Test.Get(2);
            Assert.AreEqual("Much Wiser", Value);
        }

        [Test]
        public void TestLinkedList_Add_All()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Much Wiser" };
            Test.AddAll(Input);
            Assert.AreEqual(3, Test.Size());
            string Value = Test.Get(1);
            Assert.AreEqual("The World Today", Value);
        }

        [Test]
        public void TestLinkedList_Add_AllFromIndex()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Much Wiser" };
            string[] Input2 = { "Monty Python", "Flying Circus" };
            Test.AddAll(Input);
            Assert.AreEqual(3, Test.Size());
            Test.AddAll(1, Input2);
            string Value = Test.Get(2);
            Assert.AreEqual("Flying Circus", Value);
        }

        [Test]
        public void TestLinkedList_Clear()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Much Wiser" };
            Test.AddAll(Input);
            Test.Clear();
            Assert.AreEqual(0, Test.Size());
        }

        [Test]
        public void TestLinkedList_Clone()
        {
            LinkedList<string> Test = new LinkedList<string>();
            LinkedList<string> Test2;
            string[] Input = { "Hello World", "The World Today", "Much Wiser" };
            Test.AddAll(Input);
            Test2 = Test.Clone();
            Test.Clear();
            Assert.AreEqual(3, Test2.Size());
            string Value = Test2.Get(1);
            Assert.AreEqual("The World Today", Value);
        }

        [Test]
        public void TestLinkedList_Contains()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", null, "Much Wiser" };
            Test.AddAll(Input);
            Assert.IsTrue(Test.Contains("Hello World"));
            Assert.IsFalse(Test.Contains("Botany Bay"));
            Assert.IsTrue(Test.Contains(null));
        }

        [Test]
        public void TestLinkedList_Get()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Much Wiser" };
            Test.AddAll(Input);
            string Value = Test.Get(2);
            Assert.AreEqual("Much Wiser", Value);
            Assert.
        }

        [Test]
        public void TestLinkedList_GetFirst()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Much Wiser" };
            Test.AddAll(Input);
            string Value = Test.GetFirst();
            Assert.AreEqual("Hello World", Value);
        }

        [Test]
        public void TestLinkedList_GetLast()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Much Wiser" };
            Test.AddAll(Input);
            string Value = Test.GetLast();
            Assert.AreEqual("Much Wiser", Value);
        }

        [Test]
        public void TestLinkedList_IndexOf()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", null, "Much Wiser" };
            Test.AddAll(Input);
            int IndexValue = Test.IndexOf("The World Today");
            Assert.AreEqual(1, IndexValue);
            int IndexValue2 = Test.IndexOf("My Day In the Sun");
            Assert.AreEqual(-1, IndexValue2);
            int IndexValue3 = Test.IndexOf(null);
            Assert.AreEqual(2, IndexValue3);
        }

        [Test]
        public void TestLinkedList_LastIndexOf()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", null, "Hello World", null };
            Test.AddAll(Input);
            int IndexValue = Test.LastIndexOf("Hello World");
            Assert.AreEqual(3, IndexValue);
            int IndexValue2 = Test.LastIndexOf("My Day In the Sun");
            Assert.AreEqual(-1, IndexValue2);
            int IndexValue3 = Test.LastIndexOf(null);
            Assert.AreEqual(4, IndexValue3);
        }

        [Test]
        public void TestLinkedList_listIterator()
        {
            LinkedList<string> Test = new LinkedList<string>();
            // The array is empty, and we should never enter this part
            foreach (string token in Test)
                Assert.Fail("Entered empty iterator");

            string[] Input = { "Hello World", "The World Today", "Hello World" };

            Test.AddAll(Input);

            // Match the contents against the string[]
            int offset = 0;
            foreach (string token in Test)
                Assert.AreEqual(token, Input[offset++]);
        }

        [Test]
        public void TestLinkedList_remove()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Its going to be a fine day" };
            Test.AddAll(Input);
            Test.Remove(1);
            // There are only 2 elements left
            Assert.AreEqual(Test.Size(), 2);
            // Before the removal this was Position 2
            int IndexValue1 = Test.IndexOf("Its going to be a fine day");
            Assert.AreEqual(IndexValue1, 1);
        }

        [Test]
        public void TestLinkedList_RemoveObject()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Its going to be a fine day" };
            Test.AddAll(Input);
            Assert.AreEqual(Test.Remove("Its going to be a fine day"), true);
            // There are only 2 elements left
            Assert.AreEqual(Test.Size(), 2);
            // We should not be able to find this element
            Assert.AreEqual(Test.IndexOf("Its going to be a fine day"), -1);
        }

        [Test]
        public void TestLinkedList_removeFirst()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Its going to be a fine day" };
            Test.AddAll(Input);
            Test.RemoveFirst();
            // There are only 2 elements left
            Assert.AreEqual(Test.Size(), 2);
            // Before the removal this was Position 1
            int IndexValue1 = Test.IndexOf("The World Today");
            Assert.AreEqual(IndexValue1, 0);
        }

        [Test]
        public void TestLinkedList_removeLast()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Its going to be a fine day" };
            Test.AddAll(Input);

            // We should not be able to find this now
            int IndexValue1 = Test.IndexOf("Its going to be a fine day");
            Assert.AreEqual(IndexValue1, 2);

            // Remove the last entry
            Test.RemoveLast();

            // There are only 2 elements left
            Assert.AreEqual(Test.Size(), 2);

            // We should not be able to find this now
            int IndexValue2 = Test.IndexOf("Its going to be a fine day");
            Assert.AreEqual(IndexValue2, -1);
        }

        [Test]
        public void TestLinkedList_Set()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Its going to be a fine day" };
            Test.AddAll(Input);

            // Replace position #1 with a new object
            string OldValue = Test.Set(1, "Sunday Sports");
            Assert.AreEqual(OldValue, "The World Today");

            int IndexValue2 = Test.IndexOf("Sunday Sports");
            Assert.AreEqual(IndexValue2, 1);
        }

        [Test]
        public void TestLinkedList_ToArray()
        {
            LinkedList<string> Test = new LinkedList<string>();
            string[] Input = { "Hello World", "The World Today", "Its going to be a fine day", null };
            Test.AddAll(Input);

            string[] Copy = Test.ToArray();

            int Index = 0;
            foreach (string element in Input)
                Assert.AreEqual(element, Copy[Index++]);
        }

    }

}

This is a post from Martijn's C# Coding Blog.

Creating your first NUnit test

We need to create a new solution to test if this works and we need to add a reference to NUnit to be able to use the code. This is the only “difficult” bit, the MonoDevelop documentation is sparse at best on how to include external assemblies. A dedicated menu option would have been nice.

To be able to add an assembly or package to an existing project you need to right click the References item on the Solution panel and then click “Edit References”. Click the “NUnit.Core” and “NUnit.Framework” selections to include them into your solution.

Testing the NUnit Demo code

Below I have included a little bit of demo code that tests if this works properly. The code is mostly borrowed from the NUnit website demo, I have just for the sake of it included a class containing “Main” so that the code actually compiles and runs.

using System;
using NUnit.Framework;

namespace bank
{
    public class Account
    {
        private float balance;
        public void Deposit(float amount)
        {
            balance += amount;
        }

        public void Withdraw(float amount)
        {
            balance -= amount;
        }

        public void TransferFunds(Account destination, float amount)
        {
        }

        public float Balance
        {
            get { return balance; }
        }
    }
}

namespace bank
{
    [TestFixture]
    public class AccountTest
    {
        [Test]
        public void TransferFunds()
        {
            Account source = new Account();
            source.Deposit(200.00F);
            Account destination = new Account();
            destination.Deposit(150.00F);

            source.TransferFunds(destination, 100.00F);
            Assert.AreEqual(250.00F, destination.Balance);
            Assert.AreEqual(100.00F, source.Balance);

        }

        [Test]
        public void DepositFunds()
        {
            Account source = new Account();
            source.Deposit(200.00F);
            Assert.AreEqual(200.00F, source.Balance);
        }

    }
}

namespace UnitTestDemo
{
    public class MyAccountingSoftware
    {

        public static void Main()
        {
            bank.Account DemoAccount = new bank.Account();
            DemoAccount.Deposit(1000.00F);
            DemoAccount.Withdraw(500.50F);
            Console.WriteLine("Our account balance is {0}", DemoAccount.Balance);
        }

    }
}

In the above code the actual unit testing is done by the “AccountTest” class, for simplicity we keep this in the same file but usually you would keep a separate directory with all of your unit tests, separate from the actual code.Note that because the “TransferFunds” function in the code above is poorly implemented (eg. its empty) the Unit test will hopefully (!!) fail. The second unit test in DepositFunds should succeed.

How to run NUnit tests from within MonoDevelop

MonoDevelop allows you to run the NUnit tests directly in the GUI environment. Select “View > Unit Tests” to see an overview of all the defined tests in the left panel. Right click on a test , or a group of tests and select “Run Test”. Click on “View > NUnit Test Results” to see which tests passed and which failed.

This is a post from Martijn's C# Coding Blog.

Unit testing helps you verify that each individual part of your code is working as expected and keeps doing that as you change your software. You do this by adding small bits of testing code and have the unit testing frame work execute them in order. I am currently writing some code that needs to have a basic unit testing framework and wanted to install the NUnit framework. This post is about how you can install NUnit, use it and run it with / install it for Visual Studio C# 2008 Express. I will leave the nuts and bolts of unit testing to a future post but this post should get you up and running.

Installing NUnit itself is straightforward and only requires a few steps:

• Download the NUnit framework from the NUnit website (download NUnit-2.4.8-net-2.0.msi)
• Install the software on your Windows XP / Vista machine

Creating your first NUnit test

Now we need to create a new project to test if this works, and we need to add a reference to NUnit to be able to use the code.

Click “Project > Add Reference…”

Select “Browse” and navigate to “C:\Program Files\NUnit 2.4.8\bin” and select the nunit.framework.dll.

This allows you to use NUnit.Framework in your programs.

Testing the NUnit Demo code

Below I have included a little bit of demo code that tests if this works properly. The code is mostly borrowed from the NUnit website demo, I have just for the sake of it included a class containing “Main” so that the code actually compiles and runs.

using System;
using NUnit.Framework;

namespace bank
{
    public class Account
    {
        private float balance;
        public void Deposit(float amount)
        {
            balance += amount;
        }

        public void Withdraw(float amount)
        {
            balance -= amount;
        }

        public void TransferFunds(Account destination, float amount)
        {
        }

        public float Balance
        {
            get { return balance; }
        }
    }
}

namespace bank
{
    [TestFixture]
    public class AccountTest
    {
        [Test]
        public void TransferFunds()
        {
            Account source = new Account();
            source.Deposit(200.00F);
            Account destination = new Account();
            destination.Deposit(150.00F);

            source.TransferFunds(destination, 100.00F);
            Assert.AreEqual(250.00F, destination.Balance);
            Assert.AreEqual(100.00F, source.Balance);

        }

        [Test]
        public void DepositFunds()
        {
            Account source = new Account();
            source.Deposit(200.00F);
            Assert.AreEqual(200.00F, source.Balance);
        }

    }
}

namespace UnitTestDemo
{
    public class MyAccountingSoftware
    {

        public static void Main()
        {
            bank.Account DemoAccount = new bank.Account();
            DemoAccount.Deposit(1000.00F);
            DemoAccount.Withdraw(500.50F);
            Console.WriteLine("Our account balance is {0}", DemoAccount.Balance);
        }

    }
}

In the above code the actual unit testing is done by the “AccountTest” class, for simplicity we keep this in the same file but usually you would keep a separate directory with all of your unit tests, separate from the actual code.

Note that because the “WithDraw” function in the code above is poorly implemented (eg. its empty) the Unit test will hopefully (!!) fail. The second unit test in DepositFunds should succeed.

How to run the NUnit GUI runner from within Visual Studio C# Express 2008

We can run NUnit from the Menu option it installed under [Start/Programs/NUnit] but it is more convenient to do so from Visual Studio Express itself.

Visual Studio C# Express allows you to define outside “Tools” which can be run from the menu. This is exactly what we would like to do with the NUnit GUI Runner. The GUI Runner is a tool which loads our program and executes all the unit tests it finds and reports the results in a seperate window.

Click on “Tools > External Tools…” to add NUnit’s GUI Runner.

The following definition allows us to run the tests in our current project:

To run the unit test, simply click “NUnit” from the Tools Menu.

[Click the picture for a larger image]

If everything went correctly you should see NUnit run 2 tests, one of which will fail.

This is a post from Martijn's C# Coding Blog.