Ejemplo n.º 1
0
        public void MainTest()
        {
            int threadsCount = 50;
            int processCount = 1000 * 1000;
            var woker        = new SingleThreadWorker(Do);

            // запускаем потоки
            var threads = new Thread[threadsCount];

            for (int i = 0; i < threadsCount; i++)
            {
                var thread = new Thread(() =>
                {
                    for (int j = 0; j < processCount; j++)
                    {
                        woker.TryStart();
                    }
                });
                thread.Start();
                threads[i] = thread;
            }

            // ждем выполнения всех потоков
            foreach (var thread in threads)
            {
                thread.Join();
            }
        }
Ejemplo n.º 2
0
        public void ExceptionInSingleThreadTest()
        {
            var routine = new DelegateRepetitiveRoutine(() => throw new ApplicationException());
            var worker  = new SingleThreadWorker(routine);

            Assert.Throws <ApplicationException>(worker.Run);
        }
        public void InvokeFromDifferentThreadShouldFail()
        {
            bool exceptionThrown = false;
            SingleThreadWorker testThread = null;

            try
            {
                var sw = Stopwatch.StartNew();
                testThread = new SingleThreadWorker();
                testThread.Invoke(new Action(() => { Trace.WriteLine("Test 'Invoke' from delegate"); Thread.Sleep(10000); }), null);
                sw.Stop();
                Trace.WriteLine(string.Format("Invoke took {0} msec", sw.ElapsedMilliseconds));
            }
            catch (Exception ex)
            {
                exceptionThrown = true;
                Trace.WriteLine(string.Format("Invoke threw an exception: {0} - {1}", ex.GetType().Name, ex.ToString()));
            }
            finally
            {
                if (testThread != null)
                {
                    testThread.Dispose();
                }
            }
            Assert.IsTrue(exceptionThrown, "Invoke from different thread should throw an exception");
        }
 public void RunTest()
 {
     SingleThreadWorker worker = new SingleThreadWorker("Test");
     string msg = null;
     worker.Run(() => msg = "Yo !");
     Assert.That(msg, Is.EqualTo("Yo !"));
     worker.Run(() => msg = "Yo !!!");
     Assert.That(msg, Is.EqualTo("Yo !!!"));
 }
Ejemplo n.º 5
0
 protected CacheStorageBaseT()
 {
     _maxCount              = 20 * 1000;
     BeginUnloadCount       = 10 * 1000;
     StopUnloadCount        = 5 * 1000;
     ComponentControl       = new FakeComponentControl("FakeCacheControl");
     _saveChangesLoopWorker = new SingleThreadWorker(SaveChangesLoop);
     _unloadDataLoopWorker  = new SingleThreadWorker(UnloadDataLoop);
 }
        public void RunTest()
        {
            SingleThreadWorker worker = new SingleThreadWorker("Test");
            string             msg    = null;

            worker.Run(() => msg = "Yo !");
            Assert.That(msg, Is.EqualTo("Yo !"));
            worker.Run(() => msg = "Yo !!!");
            Assert.That(msg, Is.EqualTo("Yo !!!"));
        }
        public void RunAsyncTest()
        {
            using (SingleThreadWorker worker = new SingleThreadWorker("Test"))
            {
                string msg = null;
                bool done = false;

                worker.RunAsync(() => { msg = "Yo !"; }, () => { done = true; });

                Thread.Sleep(100);

                Assert.That(msg, Is.EqualTo("Yo !"));
                Assert.That(done, Is.True);
            }
        }
        public void RunAsyncTest()
        {
            using (SingleThreadWorker worker = new SingleThreadWorker("Test"))
            {
                string msg  = null;
                bool   done = false;

                worker.RunAsync(() => { msg = "Yo !"; }, () => { done = true; });

                Thread.Sleep(100);

                Assert.That(msg, Is.EqualTo("Yo !"));
                Assert.That(done, Is.True);
            }
        }
        public void BeginAndEndInvokeShouldSucceed()
        {
            bool exceptionThrown = false;
            SingleThreadWorker testThread = null;

            try
            {
                var sw = Stopwatch.StartNew();
                var evt = new ManualResetEventSlim();
                testThread = new SingleThreadWorker();
                var ar = testThread.BeginInvoke(
                    new Action(() =>
                    {
                        Trace.WriteLine("Test 'BeginInvoke' from delegate");
                        testThread.Invoke(new Action(() => { Trace.WriteLine("Test 'Invoke' from inner delegate"); Thread.Sleep(1000); }), null);
                        Thread.Sleep(1000);
                        testThread.BeginInvoke(new Action(() => { Trace.WriteLine("Test 'BeginInvoke' from inner delegate"); Thread.Sleep(1000); }), null);
                        Thread.Sleep(1000);
                        testThread.Send(delegate { Trace.WriteLine("Test 'Send' from inner delegate"); Thread.Sleep(1000); }, null);
                        Thread.Sleep(1000);
                        testThread.Post(delegate { Trace.WriteLine("Test 'Post' from inner delegate"); Thread.Sleep(1000); evt.Set(); }, null);
                        Thread.Sleep(1000);
                    }), null);
                testThread.EndInvoke(ar);
                evt.Wait();
                sw.Stop();
                Trace.WriteLine(string.Format("BeginInvoke/EndInvoke took {0} msec", sw.ElapsedMilliseconds));
            }
            catch (Exception ex)
            {
                exceptionThrown = true;
                Trace.WriteLine(string.Format("BeginInvoke/EndInvoke threw an exception: {0} - {1}", ex.GetType().Name, ex.ToString()));
            }
            finally
            {
                if (testThread != null)
                {
                    testThread.Dispose();
                }
            }
            Assert.IsFalse(exceptionThrown, "BeginInvoke/EndInvoke from same thread should succeed");
        }
Ejemplo n.º 10
0
        public Mutant(string name, bool nonBlock, bool selfThread)
        {
            this.Name     = name;
            this.NonBlock = nonBlock;
            this.Leak     = LeakChecker.Enter(LeakCounterKind.Mutant);

            try
            {
                Worker = new SingleThreadWorker($"Mutant - '{this.Name}'", selfThread);

                Worker.ExecAsync(p =>
                {
                    MutantBase = MutantBase.Create(name);
                }, 0)._GetResult();
            }
            catch
            {
                this._DisposeSafe();
                throw;
            }
        }
        public void ManualExitThreadShouldSucceedSTA()
        {
            bool exceptionThrown = false;
            SingleThreadWorker testThread = null;

            try
            {
                var sw = Stopwatch.StartNew();
                testThread = new SingleThreadWorker(ApartmentState.STA);
                var task = testThread.QueueFunc<string>(
                    () =>
                    {
                        Trace.WriteLine("Test for manual queue Func");
                        Thread.Sleep(1000);
                        testThread.Send(delegate { Trace.WriteLine("Test 'Send' from inner delegate"); Thread.Sleep(1000); }, null);
                        Thread.Sleep(1000);
                        return null;
                    });
                task.ContinueWith(_ => { testThread.RequestShutdown(); });
                bool success = testThread.Thread.Join(TimeSpan.FromSeconds(10.0));
                sw.Stop();
                Trace.WriteLine(string.Format("Operation took {0} msec", sw.ElapsedMilliseconds));
                Assert.IsTrue(success, "Thread join failed. RequestShutdown didn't work.");
                Assert.IsFalse(testThread.Thread.IsAlive, "Thread is still alive");
            }
            catch (Exception ex)
            {
                exceptionThrown = true;
                Trace.WriteLine(string.Format("Exception occurred: {0} - {1}", ex.GetType().Name, ex.ToString()));
            }
            finally
            {
                if (testThread != null)
                {
                    testThread.Dispose();
                }
            }
            Assert.IsFalse(exceptionThrown, "Manual 'QueueFunc' should succeed");
        }
        public void SendFromSameThreadShouldSucceedSTA()
        {
            bool exceptionThrown = false;
            SingleThreadWorker testThread = null;

            try
            {
                var sw = Stopwatch.StartNew();
                var evt = new ManualResetEventSlim();
                testThread = new SingleThreadWorker(ApartmentState.STA);
                testThread.Post(
                    delegate
                    {
                        Trace.WriteLine("Test 'Post' from delegate");
                        Thread.Sleep(1000);
                        testThread.Send(delegate { Trace.WriteLine("Test 'Send' from inner delegate"); Thread.Sleep(1000); }, null);
                        Thread.Sleep(1000);
                        testThread.Post(delegate { Trace.WriteLine("Test 'Post' from inner delegate"); Thread.Sleep(1000); evt.Set(); }, null);
                        Thread.Sleep(1000);
                        //evt.Set(); // Use event from the Post operation
                    }, null);
                evt.Wait();
                sw.Stop();
                Trace.WriteLine(string.Format("Send took {0} msec", sw.ElapsedMilliseconds));
            }
            catch (Exception ex)
            {
                exceptionThrown = true;
                Trace.WriteLine(string.Format("Send threw an exception: {0} - {1}", ex.GetType().Name, ex.ToString()));
            }
            finally
            {
                if (testThread != null)
                {
                    testThread.Dispose();
                }
            }
            Assert.IsFalse(exceptionThrown, "Send from same thread should succeed");
        }
 public void PostShouldDelayTenSeconds()
 {
     var sw = Stopwatch.StartNew();
     var evt = new ManualResetEventSlim();
     SingleThreadWorker testThread = new SingleThreadWorker();
     testThread.Post(delegate { Trace.WriteLine("Test 'Post' from delegate"); Thread.Sleep(10000); evt.Set(); }, null);
     evt.Wait();
     sw.Stop();
     Assert.IsTrue(sw.Elapsed >= TimeSpan.FromSeconds(10), "Post with delay should take at least 10 seconds");
     Trace.WriteLine(string.Format("Post took {0} msec", sw.ElapsedMilliseconds));
     testThread.Dispose();
 }