How to unit test Thread Safe Generic List in C# using NUnit?

I asked a question about building custom Thread Safe Generic List now I am trying to unit test it and I absolutely have no idea how to do that. Since the lock happens inside the ThreadSafeList class I am not sure how to make the list to lock for a period of time while I am try to mimic the multiple add call. Thanks.

Can_add_one_item_at_a_time

[Test]
public void Can_add_one_item_at_a_time() //this test won't pass
{
    //I am not sure how to do this test...
    var list = new ThreadSafeList<string>();

    //some how need to call lock and sleep inside list instance
    //say somehow list locks for 1 sec

    var ta = new Thread(x => list.Add("a"));
    ta.Start(); //does it need to aboard say before 1 sec if locked

    var tb = new Thread(x => list.Add("b"));
    tb.Start(); //does it need to aboard say before 1 sec if locked

    //it involves using GetSnapshot()
    //which is bad idea for unit testing I think
    var snapshot = list.GetSnapshot(); 
    Assert.IsFalse(snapshot.Contains("a"), "Should not contain a.");
    Assert.IsFalse(snapshot.Contains("b"), "Should not contain b.");
}

Snapshot_should_be_point_of_time_only

[Test]
public void Snapshot_should_be_point_of_time_only()
{
    var list = new ThreadSafeList<string>();
    var ta = new Thread(x => list.Add("a"));
    ta.Start();

    ta.Join();
    var snapshot = list.GetSnapshot();

    var tb = new Thread(x => list.Add("b"));
    tb.Start();

    var tc = new Thread(x => list.Add("c"));
    tc.Start();

    tb.Join();
    tc.Join();

    Assert.IsTrue(snapshot.Count == 1, "Snapshot should only contain 1 item.");
    Assert.IsFalse(snapshot.Contains("b"), "Should not contain a.");
    Assert.IsFalse(snapshot.Contains开发者_JS百科("c"), "Should not contain b.");
}

Instance method

public ThreadSafeList<T> Instance<T>()
{
    return new ThreadSafeList<T>();
}

---

Let's look at your first test, Can_add_one_item_at_a_time.

First of all, your exit conditions don't make sense. Both items should be added, just one at a time. So of course your test will fail.

You also don't need to make a snapshot; remember, this is a test, nothing else is going to be touching the list while your test is running.

Last but not least, you need to make sure that you aren't trying to evaluate your exit conditions until all of the threads have actually finished. Simplest way is to use a counter and a wait event. Here's an example:

[Test]
public void Can_add_from_multiple_threads()
{
    const int MaxWorkers = 10;

    var list = new ThreadSafeList<int>(MaxWorkers);
    int remainingWorkers = MaxWorkers;
    var workCompletedEvent = new ManualResetEvent(false);
    for (int i = 0; i < MaxWorkers; i++)
    {
        int workerNum = i;  // Make a copy of local variable for next thread
        ThreadPool.QueueUserWorkItem(s =>
        {
            list.Add(workerNum);
            if (Interlocked.Decrement(ref remainingWorkers) == 0)
                workCompletedEvent.Set();
        });
    }
    workCompletedEvent.WaitOne();
    workCompletedEvent.Close();
    for (int i = 0; i < MaxWorkers; i++)
    {
        Assert.IsTrue(list.Contains(i), "Element was not added");
    }
    Assert.AreEqual(MaxWorkers, list.Count,
        "List count does not match worker count.");
}

Now this does carry the possibility that the Add happens so quickly that no two threads will ever attempt to do it at the same time. No Refunds No Returns partially explained how to insert a conditional delay. I would actually define a special testing flag, instead of DEBUG. In your build configuration, add a flag called TEST, then add this to your ThreadSafeList class:

public class ThreadSafeList<T>
{
    // snip fields

    public void Add(T item)
    {
        lock (sync)
        {
            TestUtil.WaitStandardThreadDelay();
            innerList.Add(item);
        }
    }

    // snip other methods/properties
}

static class TestUtil
{
    [Conditional("TEST")]
    public static void WaitStandardThreadDelay()
    {
        Thread.Sleep(1000);
    }
}

This will cause the Add method to wait 1 second before actually adding the item as long as the build configuration defines the TEST flag. The entire test should take at least 10 seconds; if it finishes any faster than that, something's wrong.

With that in mind, I'll leave the second test up to you. It's similar.

---

You will need to insert some TESTONLY code that adds a delay in your lock. You can create a function like this:

 [Conditional("DEBUG")]
 void SleepForABit(int delay) { thread.current.sleep(delay); }

and then call it in your class. The Conditional attribute ensure it is only called in DEBUG builds and you can leave it in your compiled code.

Write something which consistently delays 100Ms or so and something that never waits and let'em slug it out.

---

You might want to take a look at Chess. It's a program specifically designed to find race conditions in multi-threaded code.