Added multi-threaded tests.

Author: Andy Adamczak

PureMVC/Tests/Core/ControllerTest.cs

@@ -4,6 +4,8 @@
  Your reuse is governed by the Creative Commons Attribution 3.0 License 
 */
 using System;
+using System.Threading;
+using System.Collections.Generic;
 
 using NUnitLite;
 using NUnit.Framework;
@@ -43,6 +45,7 @@ public static ITest Suite
                 ts.AddTest(new ControllerTest("TestRegisterAndRemoveCommand"));
 				ts.AddTest(new ControllerTest("TestHasCommand"));
 				ts.AddTest(new ControllerTest("TestReregisterAndExecuteCommand"));
+				ts.AddTest(new ControllerTest("TestMultiThreadedOperations"));
 
                 return ts;
             }
@@ -81,11 +84,12 @@ public void TestRegisterAndExecuteCommand()
         {
    			// Create the controller, register the ControllerTestCommand to handle 'ControllerTest' notes
    			IController controller = Controller.Instance;
-   			controller.RegisterCommand("ControllerTest", typeof(ControllerTestCommand));
+			string name = "ControllerTest" + Thread.CurrentThread.Name;
+   			controller.RegisterCommand(name, typeof(ControllerTestCommand));
 
    			// Create a 'ControllerTest' note
             ControllerTestVO vo = new ControllerTestVO(12);
-   			INotification note = new Notification("ControllerTest", vo);
+   			INotification note = new Notification(name, vo);
 
 			// Tell the controller to execute the Command associated with the note
 			// the ControllerTestCommand invoked will multiply the vo.input value
@@ -108,11 +112,12 @@ public void TestRegisterAndRemoveCommand()
 
    			// Create the controller, register the ControllerTestCommand to handle 'ControllerTest' notes
    			IController controller = Controller.Instance;
-   			controller.RegisterCommand("ControllerRemoveTest", typeof(ControllerTestCommand));
+			string name = "ControllerRemoveTest" + Thread.CurrentThread.Name;
+			controller.RegisterCommand(name, typeof(ControllerTestCommand));
 
    			// Create a 'ControllerTest' note
             ControllerTestVO vo = new ControllerTestVO(12);
-   			INotification note = new Notification("ControllerRemoveTest", vo);
+   			INotification note = new Notification(name, vo);
 
 			// Tell the controller to execute the Command associated with the note
 			// the ControllerTestCommand invoked will multiply the vo.input value
@@ -126,7 +131,7 @@ public void TestRegisterAndRemoveCommand()
    			vo.result = 0;
 
    			// Remove the Command from the Controller
-   			controller.RemoveCommand("ControllerRemoveTest");
+   			controller.RemoveCommand(name);
 
 			// Tell the controller to execute the Command associated with the
 			// note. This time, it should not be registered, and our vo result
@@ -144,16 +149,17 @@ public void TestRegisterAndRemoveCommand()
   		public void TestHasCommand() {
    			// register the ControllerTestCommand to handle 'hasCommandTest' notes
    			IController controller = Controller.Instance;
-   			controller.RegisterCommand("hasCommandTest", typeof(ControllerTestCommand));
+			string name = "HasCommandTest" + Thread.CurrentThread.Name;
+			controller.RegisterCommand(name, typeof(ControllerTestCommand));
 
    			// test that hasCommand returns true for hasCommandTest notifications 
-			Assert.True(controller.HasCommand("hasCommandTest") == true, "Expecting controller.HasCommand('hasCommandTest') == true");
+			Assert.True(controller.HasCommand(name) == true, "Expecting controller.HasCommand(name) == true");
 
    			// Remove the Command from the Controller
-   			controller.RemoveCommand("hasCommandTest");
+			controller.RemoveCommand(name);
 
    			// test that hasCommand returns false for hasCommandTest notifications 
-			Assert.True(controller.HasCommand("hasCommandTest") == false, "Expecting controller.HasCommand('hasCommandTest') == false");
+			Assert.True(controller.HasCommand(name) == false, "Expecting controller.HasCommand(name) == false");
    		}
 
  		/**
@@ -172,17 +178,18 @@ public void TestReregisterAndExecuteCommand() {
 
    			// Fetch the controller, register the ControllerTestCommand2 to handle 'ControllerTest2' notes
    			IController controller = Controller.Instance;
-   			controller.RegisterCommand("ControllerTest2", typeof(ControllerTestCommand2));
+			string name = "ControllerTest2" + Thread.CurrentThread.Name;
+			controller.RegisterCommand(name, typeof(ControllerTestCommand2));
 
    			// Remove the Command from the Controller
-   			controller.RemoveCommand("ControllerTest2");
+			controller.RemoveCommand(name);
 
    			// Re-register the Command with the Controller
-   			controller.RegisterCommand("ControllerTest2", typeof(ControllerTestCommand2));
+			controller.RegisterCommand(name, typeof(ControllerTestCommand2));
 
    			// Create a 'ControllerTest2' note
 			ControllerTestVO vo = new ControllerTestVO(12);
-   			Notification note = new Notification( "ControllerTest2", vo );
+			Notification note = new Notification(name, vo);
 
 			// retrieve a reference to the View.
    			IView view = View.Instance;
@@ -199,7 +206,50 @@ public void TestReregisterAndExecuteCommand() {
 
 			// if the command is executed twice the value will be 48
 			Assert.True(vo.result == 48, "Expecting vo.result == 48");
-   			
    		}
-    }
+
+		/// <summary>
+		/// Test all of the function above using many threads at once.
+		/// </summary>
+		public void TestMultiThreadedOperations()
+		{
+			count = 20;
+			IList<Thread> threads = new List<Thread>();
+
+			for (int i = 0; i < count; i++) {
+				Thread t = new Thread(new ThreadStart(MultiThreadedTestFunction));
+				t.Name = "ControllerTest" + i;
+				threads.Add(t);
+			}
+
+			foreach (Thread t in threads)
+			{
+				t.Start();
+			}
+
+			while (true)
+			{
+				if (count <= 0) break;
+				Thread.Sleep(100);
+			}
+		}
+
+		private int count = 0;
+
+		private int threadIterationCount = 10000;
+
+		private void MultiThreadedTestFunction()
+		{
+			for (int i = 0; i < threadIterationCount; i++)
+			{
+				// All we need to do is test the registration and removal of commands.
+				TestRegisterAndExecuteCommand();
+				TestRegisterAndRemoveCommand();
+				TestHasCommand();
+				TestReregisterAndExecuteCommand();
+			}
+
+			count--;
+		}
+	}
 }

PureMVC/Tests/Core/ModelTest.cs

@@ -5,6 +5,7 @@ Your reuse is governed by the Creative Commons Attribution 3.0 License
 */
 using System;
 using System.Collections.Generic;
+using System.Threading;
 
 using NUnitLite;
 using NUnit.Framework;
@@ -44,6 +45,7 @@ public static ITest Suite
                 ts.AddTest(new ModelTest("TestRegisterAndRemoveProxy"));
 				ts.AddTest(new ModelTest("TestHasProxy"));
 				ts.AddTest(new ModelTest("TestOnRegisterAndOnRemove"));
+				ts.AddTest(new ModelTest("TestMultiThreadedOperations"));
 
 				return ts;
             }
@@ -75,8 +77,9 @@ public void TestRegisterAndRetrieveProxy()
         {
    			// register a proxy and retrieve it.
    			IModel model = Model.Instance;
-			model.RegisterProxy(new Proxy("colors", new List<string>(new string[] { "red", "green", "blue" })));
-			IProxy proxy = model.RetrieveProxy("colors");
+			string name = "colors" + Thread.CurrentThread.Name;
+			model.RegisterProxy(new Proxy(name, new List<string>(new string[] { "red", "green", "blue" })));
+			IProxy proxy = model.RetrieveProxy(name);
 			List<string> data = (List<string>) proxy.Data;
 
 			// test assertions
@@ -95,13 +98,14 @@ public void TestRegisterAndRemoveProxy()
         {
    			// register a proxy, remove it, then try to retrieve it
    			IModel model = Model.Instance;
-			model.RegisterProxy(new Proxy("sizes", new List<int>(new int[] { 7, 13, 21 })));
-			
-            IProxy removedProxy = model.RemoveProxy("sizes");
+			string name = "sizes" + Thread.CurrentThread.Name;
+			model.RegisterProxy(new Proxy(name, new List<int>(new int[] { 7, 13, 21 })));
+
+			IProxy removedProxy = model.RemoveProxy(name);
 
-            Assert.True(removedProxy.ProxyName == "sizes", "Expecting removedProxy.ProxyName == 'sizes'");
+			Assert.True(removedProxy.ProxyName == name, "Expecting removedProxy.ProxyName == name");
 
-			IProxy proxy = model.RetrieveProxy("sizes");
+			IProxy proxy = model.RetrieveProxy(name);
 
 			// test assertions
    			Assert.Null(proxy, "Expecting proxy is null");
@@ -114,19 +118,20 @@ public void TestHasProxy() {
 
    			// register a proxy
    			IModel model = Model.Instance;
-			IProxy proxy = new Proxy("aces", new List<string>(new string[] { "clubs", "spades", "hearts", "diamonds" }));
+			string name = "aces" + Thread.CurrentThread.Name;
+			IProxy proxy = new Proxy(name, new List<string>(new string[] { "clubs", "spades", "hearts", "diamonds" }));
 			model.RegisterProxy(proxy);
 
    			// assert that the model.hasProxy method returns true
    			// for that proxy name
-   			Assert.True(model.HasProxy("aces") == true, "Expecting model.hasProxy('aces') == true");
+			Assert.True(model.HasProxy(name) == true, "Expecting model.hasProxy(name) == true");
 
 			// remove the proxy
-			model.RemoveProxy("aces");
+			model.RemoveProxy(name);
 
    			// assert that the model.hasProxy method returns false
    			// for that proxy name
-   			Assert.True(model.HasProxy("aces") == false, "Expecting model.hasProxy('aces') == false");
+			Assert.True(model.HasProxy(name) == false, "Expecting model.hasProxy(name) == false");
    		}
 
 		/**
@@ -150,5 +155,49 @@ public void TestOnRegisterAndOnRemove() {
 			// assert that onRemove was called, and the proxy responded by setting its data accordingly
    			Assert.True(proxy.Data.ToString() == ModelTestProxy.ON_REMOVE_CALLED, "Expecting proxy.Data.ToString() == ModelTestProxy.ON_REMOVE_CALLED");
 		}
-    }
+
+		/// <summary>
+		/// Test all of the function above using many threads at once.
+		/// </summary>
+		public void TestMultiThreadedOperations()
+		{
+			count = 20;
+			IList<Thread> threads = new List<Thread>();
+
+			for (int i = 0; i < count; i++)
+			{
+				Thread t = new Thread(new ThreadStart(MultiThreadedTestFunction));
+				t.Name = "ControllerTest" + i;
+				threads.Add(t);
+			}
+
+			foreach (Thread t in threads)
+			{
+				t.Start();
+			}
+
+			while (true)
+			{
+				if (count <= 0) break;
+				Thread.Sleep(100);
+			}
+		}
+
+		private int count = 0;
+
+		private int threadIterationCount = 10000;
+
+		private void MultiThreadedTestFunction()
+		{
+			for (int i = 0; i < threadIterationCount; i++)
+			{
+				// All we need to do is test the registration and removal of proxies.
+				TestRegisterAndRetrieveProxy();
+				TestRegisterAndRemoveProxy();
+				TestHasProxy();
+			}
+
+			count--;
+		}
+	}
 }