public void SingleThreadForSpecifiedTimeStrategy()
        {
            Counter c = new Counter();
            ThreadManager tt = new ThreadManager();
            tt.AddThreadAction(
                delegate
                    {
                        c.Increment();
                    });

            tt.RunBehavior = ThreadRunBehavior.RunForSpecificTime;
            tt.StartAllThreads(500);
            Assert.IsTrue(tt.LastRunTime >499,"runtime was "+ tt.LastRunTime);
        }
        public void SingleThread()
        {
            Counter c = new Counter();
            ThreadManager tt = new ThreadManager();
            tt.AddThreadAction(
                delegate
                    {
                        c.Increment();
                    });

            tt.RunBehavior=ThreadRunBehavior.RunUntilAllThreadsFinish;
            tt.StartAllThreads(500);
            Assert.IsTrue(tt.LastRunTime<tt.TimeOut);
        }
        public void HundredThreads()
        {
            Counter c = new Counter();
            ThreadManager tt = new ThreadManager();
            for (int i = 0; i < 100; i++)
            {
                tt.AddThreadAction(delegate
                                       {
                                           for (int j = 0; j < 10; j++)
                                           {
                                               c.Increment();
                                               Thread.Sleep(new Random(j+1).Next(100,300));
                                           }
                                       });
            }

            //this test will run for 22.5 seconds
            tt.RunBehavior=ThreadRunBehavior.RunForSpecificTime;
            tt.StartAllThreads(22500);
        }
        public void StartAllThreads_exceptionsInThreads_FoundInExceptionsProperty()
        {
            ThreadManager tt = new ThreadManager();
            tt.AddThreadAction(delegate
                                   {
                                       throw  new Exception("forced exception 1");
                                   });
            tt.AddThreadAction(delegate
                                   {
                                       throw  new Exception("forced exception 2");
                                   });
            tt.AddThreadAction(delegate
                                   {
                                       throw  new Exception("forced exception 3");
                                   });

            tt.StartAllThreads(1000);
            Assert.AreEqual(3,ThreadManager.exceptions.Count);
        }
        public void Singlton_MultiThreaded_SameInstance()
        {
            ThreadManager tt = new ThreadManager();
            Guid guid1 = Guid.Empty,
                guid2 = Guid.Empty;

            tt.AddThreadAction(delegate
                                   {
                                       guid1 = Singlton.Instance.guid;
                                   });
            tt.AddThreadAction(delegate
                                   {
                                       guid2 = Singlton.Instance.guid;
                                   });

            tt.StartAllThreads(1000);
            Assert.AreEqual(guid1.ToString(),guid2.ToString());
        }
        public void TryToCreateARaceCondition()
        {
            Counter c = new Counter();
            ThreadManager tt = new ThreadManager();
            for (int i = 0; i < 100; i++)
            {
                tt.AddThreadAction(
                    delegate
                        {
            //                            Console.WriteLine(Thread.CurrentThread.Name);
                            for (int j = 0; j < 100000; j++)
                            {
                                c.Increment();
                            }
                        });
            }

            tt.StartAllThreads(5000);
            Assert.AreEqual(1000000,c.Count);
        }
        public void StopWhenTrue_StopAfterCountReaches1000()
        {
            Counter c = new Counter();
            ThreadManager tt = new ThreadManager();
            tt.RunBehavior=ThreadRunBehavior.RunForSpecificTime;
            tt.AddThreadAction(delegate
                                       {
                                           for (int j = 0; j < 103; j++)
                                           {
                                               c.Increment();
                                           }
                                           Thread.Sleep(50);
                                       });

            tt.StopWhenTrue(delegate
                                {
                                    Console.WriteLine("currently at " + c.Count);
                                    return c.Count > 1000;
                                },100);

            tt.StartAllThreads(10000);
            Assert.Greater(c.Count,1000);
            Assert.Less(c.Count,1050);
        }