public void TestClose()
        {
            var       testResults = new TestResults();
            const int mailboxSize = 64;
            var       dispatcher  = new RingBufferDispatcher(mailboxSize, 2, 4);

            dispatcher.Start();
            var mailbox = dispatcher.Mailbox;
            var actor   = new CountTakerActor(testResults);

            testResults.Until = Until(mailboxSize);

            for (var count = 1; count <= mailboxSize; ++count)
            {
                var countParam = count;
                Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
                mailbox.Send(actor, consumer, null, "Take(int)");
            }

            testResults.Until.Completes();
            dispatcher.Close();

            const int neverReceived = mailboxSize * 2;

            for (var count = mailboxSize + 1; count <= neverReceived; ++count)
            {
                var countParam = count;
                Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
                mailbox.Send(actor, consumer, null, "Take(int)");
            }

            Until(0).Completes();

            Assert.Equal(mailboxSize, testResults.Highest.Get());
        }
        public void TestExecute()
        {
            var testResults = new TestResults();

            testResults.Log.Set(true);
            var mailbox = new TestMailbox(testResults);
            var actor   = new CountTakerActor(testResults);

            testResults.Until = Until(Total);

            for (var count = 0; count < Total; ++count)
            {
                var countParam = count;
                Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
                var message = new LocalMessage <ICountTaker>(actor, consumer, "Take(int)");
                mailbox.Send(message);
                dispatcher.Execute(mailbox);
            }
            testResults.Until.Completes();

            for (var idx = 0; idx < testResults.Counts.Count; ++idx)
            {
                Assert.Contains(idx, testResults.Counts);
            }
        }
Пример #3
0
        public void TestNotifyOnSendDispatch()
        {
            var mailboxSize = 64;
            var testResults = new TestResults(mailboxSize);

            var dispatcher = new RingBufferDispatcher(mailboxSize, 1000, true, 4);

            dispatcher.Start();

            var mailbox = dispatcher.Mailbox;

            var actor = new CountTakerActor(testResults);

            for (var count = 1; count <= mailboxSize; ++count)
            {
                var countParam = count;
                Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);

                // notify if in back off
                mailbox.Send(actor, consumer, null, "take(int)");

                // every third message give time for dispatcher to back off
                if (count % 3 == 0)
                {
                    Thread.Sleep(50);
                }
            }

            Assert.Equal(mailboxSize, testResults.GetHighest());
        }
        public void TestClose()
        {
            var testResults = new TestResults(3, false);
            var mailbox     = new TestMailbox(testResults, World.DefaultLogger);
            var actor       = new CountTakerActor(testResults, World.DefaultLogger);

            for (var count = 0; count < 3; ++count)
            {
                var countParam = count;
                Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
                var message = new LocalMessage <ICountTaker>(actor, consumer, "Take(int)");
                mailbox.Send(message);
                dispatcher.Execute(mailbox);
            }

            dispatcher.Close();

            Action <ICountTaker> consumer2 = consumerActor => consumerActor.Take(10);
            var message2 = new LocalMessage <ICountTaker>(actor, consumer2, "Take(int)");

            mailbox.Send(message2);
            dispatcher.Execute(mailbox);

            var counts = testResults.GetCounts();

            Assert.Equal(3, counts.Count);
            for (var idx = 0; idx < counts.Count; ++idx)
            {
                Assert.Contains(idx, counts);
            }
        }
Пример #5
0
        public void TestClose()
        {
            var dispatcher = new ManyToOneConcurrentArrayQueueDispatcher(MailboxSize, 2, 4, 10);

            dispatcher.Start();
            var mailbox = dispatcher.Mailbox;
            var actor   = new CountTakerActor();

            actor.Until = Until(MailboxSize);
            for (var i = 1; i <= MailboxSize; ++i)
            {
                var countParam = i;
                Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
                var message = new LocalMessage <ICountTaker>(actor, consumer, "Take(int)");
                mailbox.Send(message);
            }

            actor.Until.Completes();
            dispatcher.Close();

            const int neverReceived = MailboxSize * 2;

            for (var count = MailboxSize + 1; count <= neverReceived; ++count)
            {
                var countParam = count;
                Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
                var message = new LocalMessage <ICountTaker>(actor, consumer, "Take(int)");
                mailbox.Send(message);
            }

            Assert.Equal(MailboxSize, actor.Highest.Get());
        }
        public void TestMailboxSendReceive()
        {
            var testResults = new TestResults(Total);
            var actor       = new CountTakerActor(testResults);

            for (var i = 0; i < Total; ++i)
            {
                var countParam = i;
                Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
                var message = new LocalMessage <ICountTaker>(actor, consumer, "Take(int)");
                mailbox.Send(message);
            }

            for (var i = 0; i < Total; ++i)
            {
                Assert.Equal(i, actor.TestResults.GetCounts(i));
            }
        }
Пример #7
0
        public void TestBasicDispatch()
        {
            const int mailboxSize = 64;
            var       testResults = new TestResults(mailboxSize);
            var       dispatcher  = new RingBufferDispatcher(mailboxSize, 2, false, 4);

            dispatcher.Start();
            var mailbox = dispatcher.Mailbox;
            var actor   = new CountTakerActor(testResults);

            for (var count = 1; count <= mailboxSize; ++count)
            {
                var countParam = count;
                Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
                mailbox.Send(actor, consumer, null, "Take(int)");
            }

            Assert.Equal(mailboxSize, testResults.GetHighest());
        }
Пример #8
0
        public void TestBasicDispatch()
        {
            var testResult = new TestResults(MailboxSize);
            var dispatcher = new ManyToOneConcurrentArrayQueueDispatcher(MailboxSize, 2, false, 4, 10);

            dispatcher.Start();
            var mailbox = dispatcher.Mailbox;
            var actor   = new CountTakerActor(testResult);

            for (var count = 1; count <= MailboxSize; ++count)
            {
                var countParam = count;
                Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
                var message = new LocalMessage <ICountTaker>(actor, consumer, "Take(int)");
                mailbox.Send(message);
            }

            Assert.Equal(MailboxSize, testResult.GetHighest());
        }
        public void TestSuspendedDelivery()
        {
            const string Paused      = "paused#";
            const string Exceptional = "exceptional#";

            var dispatcher = new ExecutorDispatcher(1, 1.0f);
            var mailbox    = new ConcurrentQueueMailbox(dispatcher, 1);

            var testResults = new TestResults();
            var actor       = new CountTakerActor(testResults);

            mailbox.SuspendExceptFor(Paused, typeof(CountTakerActor));

            mailbox.SuspendExceptFor(Exceptional, typeof(CountTakerActor));

            mailbox.Resume(Exceptional);

            mailbox.Resume(Paused);

            Assert.False(mailbox.IsSuspended);
        }
        public void TestOverflowDispatch()
        {
            var       testResults  = new TestResults();
            const int mailboxSize  = 64;
            const int overflowSize = mailboxSize * 2;
            var       dispatcher   = new RingBufferDispatcher(mailboxSize, 2, 4);
            var       mailbox      = dispatcher.Mailbox;
            var       actor        = new CountTakerActor(testResults);

            testResults.Until = Until(overflowSize);

            for (var count = 1; count <= overflowSize; ++count)
            {
                var countParam = count;
                Action <ICountTaker> consumer = consumerActor => consumerActor.Take(countParam);
                var message = new LocalMessage <ICountTaker>(actor, consumer, "Take(int)");
                mailbox.Send(message);
            }

            dispatcher.Start();
            testResults.Until.Completes();

            Assert.Equal(overflowSize, testResults.Highest.Get());
        }