Testing Concurrency with Nunit

Nunit is really nice for unit testing. One thing I wanted to do in my unit test is simulate multiple users using the system. Normally it would be nice to have a set of tests for single user scenario. Once those tests pass, it is nice to be able to run them in a "multi-user" environment. I didn't really want to re-code my tests to simulate a multi-user environment, and I didn't really want to create complex threading system to do it. So to solve the problem I used the .NET built-in thread pool, and I leverage the existing tests I have. Here is an example
Suppose we have 2 simple unit tests, one to test a customer request, and the other to test updating a customer record. The implementation is not needed for this sample.

      
      [TestFixture]
      public class TestCustmoerUserCase
      {
         [Test]
         public void TestProcessCustmerRequest()
         {
            // processing to handle a custmer request
         }
         [Test]
         public void TestUpdateCustomer()
         {
            // processing to update a custmer
         }
      }

Suppose I would like to test these two scenarios in a multi-user environment. Here is one possible solution:

      
      [TestFixture]
      public class TestCustmerUserCaseAsync
      {
         private delegate void AsyncDelegate();
         [Test]
         public void TestAsync()
         {
            TestCustmoerUserCase custTest = new TestCustmoerUserCase();
            // you can also run initalization code here, before starting the threads...
            AsyncDelegate asyncOperation = delegate
            {
               custTest.TestProcessCustmerRequest();
               custTest.TestUpdateCustomer();
            };
            Console.WriteLine("Running thread 1");
            IAsyncResult r1 = asyncOperation.BeginInvoke(null, null);
            Console.WriteLine("Running thread 2");
            IAsyncResult r2 = asyncOperation.BeginInvoke(null, null);
            Console.WriteLine("Running thread 3");
            IAsyncResult r3 = asyncOperation.BeginInvoke(null, null);
            Console.WriteLine("Waiting for threads to finish");
            asyncOperation.EndInvoke(r1);
            Console.WriteLine("Finished thread 1");
            asyncOperation.EndInvoke(r2);
            Console.WriteLine("Finished thread 2");
            asyncOperation.EndInvoke(r3);
            Console.WriteLine("Finished thread 3");
         }
      }
   }

Lets make a few notes about the example above

• I have created a delegate using .NET C# 2.0 anonymous methods. This allows me to place a method within a method and give it a delegate name. In this case my delegate is called asyncOperation.
• Within the body of asyncOperation are the unit tests calls (which we normally call from a single thread). Note that declaring the delegate does not execute it.
• Right after declaring my delegate I ask .NET to invoke it 3 times on the thread pool. I do this with the BeginInvoke method, which each .NET delegate support.
• I pass null for callback, and null for state. That's because in this case I don't need them
• Each time a BeginInvoke is called, I get a "token" for the threaded execution called IAsyncResult. Its important to keep all 3 references I get from BeginInvoke. (in this example they are saved as r1, r2 and r3
• After launching the 3 threads. I need to wait for them to finish. Calling EndInvoke waits for the execution to finish, but which one? this is where the IAsyncResult plays an important role.
• EndInvoke(r1) will wait for the first thread to finish, EndInvoke(r2) waits for the second thread ... as so on.
• I could of used a loop and an array to store the IAsyncResults, but that would of made the example more complex. For production use, you should use a loop and array for running the threads.

So there you have it. You ran a set of unit tests that you already have without too much work. But, remember multi-threading requires a few things:

• Your unit tests need to be thread safe! its best that they don't share memory, or the small amount of memory they do share is protected between threads.
• For more on Nunit go see http://www.nunit.org/

Happy .Netting everyone.