Пример #1
0
        public void TestLeave()
        {
            var values       = new[] { 0, 1, 2, 3, 4 };
            var readervalues = new[] { 0, 0, 1, 1, 2, 2, 3, 3, 4, 4 };
            var c            = ChannelManager.CreateChannel <int>(broadcast: true);
            var counter      = new CounterShim();
            var readercount  = 10;

            ((IJoinAbleChannel)c).Join(true);

            var writer1 = RunWriter(c, values);
            var writer2 = RunWriter(c, values);

            var readers = Enumerable.Range(0, readercount).Select(x => RunReader(c, readervalues, counter)).ToArray();

            System.Threading.Thread.Sleep(TimeSpan.FromSeconds(2));
            if (counter.Count != 0)
            {
                throw new Exception("Broadcast has progressed even when there are not enough readers");
            }

            ((IJoinAbleChannel)c).Leave(true);

            Task.WhenAll(readers.Union(new[] { writer1, writer2 })).WaitForTaskOrThrow();
            if (counter.Count != readercount * readervalues.Length)
            {
                throw new Exception(string.Format("The counter said {0} values were read, but {1} was expected", counter.Count, readercount * readervalues.Length));
            }
        }
Пример #2
0
        public void TestSimple()
        {
            var values      = new[] { 0, 1, 2, 3, 4 };
            var c           = ChannelManager.CreateChannel <int>(broadcast: true);;
            var counter     = new CounterShim();
            var readercount = 10;

            var readers = Enumerable.Range(0, readercount).Select(x => RunReader(c, values, counter)).ToArray();
            var writer  = RunWriter(c, values);

            Task.WhenAll(readers.Union(new[] { writer })).WaitForTaskOrThrow();
            if (counter.Count != readercount * values.Length)
            {
                throw new Exception(string.Format("The counter said {0} values were read, but {1} was expected", counter.Count, readercount * values.Length));
            }
        }
Пример #3
0
        public void TestAttributes()
        {
            var values      = new[] { 0, 1, 2, 3, 4 };
            var counter     = new CounterShim();
            var readercount = 10;
            var name        = "bcast";

            using (new IsolatedChannelScope())
            {
                var writer = AutomationExtensions.RunTask(
                    new Writer(),
                    async self =>
                {
                    foreach (var v in values)
                    {
                        await self.chan.WriteAsync(v);
                    }
                }
                    );

                var readers = Enumerable.Range(0, readercount).Select(x => AutomationExtensions.RunTask(
                                                                          new { chan = ChannelMarker.ForRead <int>(name) },
                                                                          async self =>
                {
                    foreach (var v in values)
                    {
                        var r = await self.chan.ReadAsync();
                        counter.Increment();
                        if (Comparer <int> .Default.Compare(v, r) != 0)
                        {
                            throw new Exception(string.Format("Got {0} but expected {1}", r, v));
                        }
                    }
                }
                                                                          )).ToArray();

                Task.WhenAll(readers.Union(new[] { writer })).WaitForTaskOrThrow();
                if (counter.Count != readercount * values.Length)
                {
                    throw new Exception(string.Format("The counter said {0} values were read, but {1} was expected", counter.Count, readercount * values.Length));
                }
            }
        }
Пример #4
0
 public static Task RunReader <T>(IChannel <T> channel, IEnumerable <T> values, CounterShim counter)
 {
     return(AutomationExtensions.RunTask(
                new { chan = channel.AsReadOnly() },
                async self =>
     {
         foreach (var v in values)
         {
             var r = await self.chan.ReadAsync();
             counter.Increment();
             if (Comparer <T> .Default.Compare(v, r) != 0)
             {
                 throw new Exception(string.Format("Got {0} but expected {1}", r, v));
             }
         }
     }
                ));
 }