Example #1
0
        public void values_can_be_triggered_by_time_or_count()
        {
            var scheduler = new TestScheduler();

            var source = scheduler.CreateColdObservable(
                // start #1 (@0)
                new Recorded <Notification <int> >(10, OnNext(1)),
                new Recorded <Notification <int> >(12, OnNext(2)),
                new Recorded <Notification <int> >(14, OnNext(3)),
                // start #2 (@ 15)
                new Recorded <Notification <int> >(16, OnNext(4)),
                new Recorded <Notification <int> >(20, OnNext(5)),
                new Recorded <Notification <int> >(24, OnNext(6)),
                new Recorded <Notification <int> >(28, OnNext(7)),
                // start #3 (@ 28)
                // start #4 (@ 43)
                new Recorded <Notification <int> >(50, OnNext(8)),
                new Recorded <Notification <int> >(51, OnCompleted())
                );

            var stats = new StatsObserver <IList <int> >();

            source.BufferWithTimeOrCount(new TimeSpan(15), 4, scheduler)
            .Subscribe(stats);

            scheduler.Run();

            Assert.AreEqual(4, stats.NextCount);
            Assert.AreEqual(3, stats.NextValues[0].Count);
            Assert.AreEqual(4, stats.NextValues[1].Count);
            Assert.AreEqual(0, stats.NextValues[2].Count);
            Assert.AreEqual(1, stats.NextValues[3].Count);
        }
Example #2
0
        public void SetUp()
        {
            source = new Subject<int>();
            windows = new List<StatsSubject<Unit>>();
            windowsStats = new List<StatsObserver<int>>();
            overallStats = new StatsObserver<int>();

            subscription = source.Window(() =>
                {
                    StatsSubject<Unit> window = new StatsSubject<Unit>();

                    windows.Add(window);

                    return window;
                })
                .Subscribe(o =>
                {
                    var stats = new StatsObserver<int>();
                    windowsStats.Add(stats);

                    o.Subscribe(stats);
                },
                overallStats.OnError,
                overallStats.OnCompleted);
        }
Example #3
0
        public void values_cannot_be_replayed_out_of_order()
        {
            ManualScheduler scheduler = new ManualScheduler();

            ReplaySubject <int> subject = new ReplaySubject <int>(scheduler);

            StatsObserver <int> stats = new StatsObserver <int>();

            subject.OnNext(1);
            subject.OnNext(2);

            subject.Subscribe(stats);

            Assert.IsFalse(stats.NextCalled);

            scheduler.RunNext();
            Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 1 }));

            subject.OnNext(3);

            scheduler.RunNext();
            Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 1, 2 }));

            scheduler.RunNext();
            Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 1, 2, 3 }));

            subject.OnCompleted();

            scheduler.RunNext();
            Assert.IsTrue(stats.CompletedCalled);
        }
Example #4
0
        public void finally_action_is_executed_if_disposition_source_subscription_throws_exception()
        {
            StatsObserver<int> stats = new StatsObserver<int>();

            bool finallyCalled = true;

            try
            {
                Observable.CreateWithDisposable<int>(obs =>
                    {
                        return Disposable.Create(() =>
                        {
                            throw new ApplicationException();
                        });
                    })
                    .Finally(() =>
                    {
                        finallyCalled = true;
                    })
                    .Subscribe(stats)
                    .Dispose();
            }
            finally
            {
                Assert.IsTrue(finallyCalled);
            }
        }
Example #5
0
        public void last_value_is_received_after_completed_if_any_connection_is_disposed()
        {
            Subject<int> subject = new Subject<int>();

            var stats = new StatsObserver<int>();

            var obs = subject.Prune();
            var connectionA = obs.Connect();
            var connectionB = obs.Connect();

            subject.OnNext(1);
            subject.OnNext(2);
            subject.OnNext(3);

            connectionA.Dispose();

            subject.OnCompleted();

            connectionB.Dispose();

            obs.Subscribe(stats);

            Assert.IsFalse(stats.NextCalled);
            Assert.IsFalse(stats.CompletedCalled);
        }
Example #6
0
        public void window_includes_onerror()
        {
            ManualScheduler scheduler = new ManualScheduler();

            ReplaySubject <int> subject =
                new ReplaySubject <int>(TimeSpan.FromMilliseconds(10), scheduler);

            StatsObserver <int> stats = new StatsObserver <int>();

            DateTime start = DateTime.UtcNow;

            scheduler.Now = start;
            subject.OnNext(1);

            scheduler.Now = start.AddMilliseconds(5);
            subject.OnNext(2);

            scheduler.Now = start.AddMilliseconds(10);
            subject.OnError(new Exception());

            scheduler.Now = start.AddMilliseconds(11);
            subject.Subscribe(stats);

            scheduler.RunAll();

            Assert.AreEqual(1, stats.NextCount);
            Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 2 }));
            Assert.IsTrue(stats.ErrorCalled);
        }
Example #7
0
        public void values_are_taken_from_each_selected_value()
        {
            var stats = new StatsObserver<int>();

            var source = new Subject<int>();
            var first = new Subject<int>();
            var second = new Subject<int>();

            var remaining = new Queue<IObservable<int>>();
            remaining.Enqueue(first);
            remaining.Enqueue(second);

            var manObs = source
                .SelectMany(x => remaining.Dequeue())
                .Subscribe(stats);

            source.OnNext(0);
            first.OnNext(1);

            source.OnNext(2);
            second.OnNext(3);
            first.OnNext(4);
            second.OnNext(5);

            Assert.AreEqual(4, stats.NextCount);
            Assert.AreEqual(1, stats.NextValues[0]);
            Assert.AreEqual(3, stats.NextValues[1]);
            Assert.AreEqual(4, stats.NextValues[2]);
            Assert.AreEqual(5, stats.NextValues[3]);
        }
Example #8
0
        public void finally_action_is_executed_if_disposition_source_subscription_throws_exception()
        {
            StatsObserver <int> stats = new StatsObserver <int>();

            bool finallyCalled = true;

            try
            {
                Observable.CreateWithDisposable <int>(obs =>
                {
                    return(Disposable.Create(() =>
                    {
                        throw new ApplicationException();
                    }));
                })
                .Finally(() =>
                {
                    finallyCalled = true;
                })
                .Subscribe(stats)
                .Dispose();
            }
            finally
            {
                Assert.IsTrue(finallyCalled);
            }
        }
Example #9
0
        public void SetUp()
        {
            stats = new StatsObserver <string>();

            left  = new StatsSubject <int>();
            right = new StatsSubject <int>();

            leftWindows  = new List <StatsSubject <Unit> >();
            rightWindows = new List <StatsSubject <Unit> >();

            leftValueAction = rightValueAction = () => { };

            combineAction = (l, r) => String.Format("{0},{1}", l, r);

            subscription = left.Join(right,
                                     leftVal =>
            {
                leftValueAction();
                var leftWindow = new StatsSubject <Unit>();
                leftWindows.Add(leftWindow);
                return(leftWindow);
            },
                                     rightVal =>
            {
                rightValueAction();
                var rightWindow = new StatsSubject <Unit>();
                rightWindows.Add(rightWindow);
                return(rightWindow);
            },
                                     (l, r) => combineAction(l, r)
                                     )
                           .Subscribe(stats);
        }
Example #10
0
        public void complete_does_not_unsubscribe_from_other_subjects()
        {
            var subjectA = new StatsSubject <int>();
            var subjectB = new StatsSubject <int>();
            var subjectC = new StatsSubject <int>();
            var subjectD = new StatsSubject <int>();

            var stats = new StatsObserver <string>();

            Observable.Join(
                subjectA.And(subjectB).Then((x, y) => x.ToString() + "," + y.ToString()),
                subjectC.And(subjectD).Then((x, y) => x.ToString() + "," + y.ToString())
                )
            .Subscribe(stats);

            Assert.AreEqual(1, subjectA.SubscriptionCount);
            Assert.AreEqual(1, subjectB.SubscriptionCount);
            Assert.AreEqual(1, subjectC.SubscriptionCount);
            Assert.AreEqual(1, subjectD.SubscriptionCount);

            subjectA.OnCompleted();

            Assert.AreEqual(0, subjectA.SubscriptionCount);
            Assert.AreEqual(1, subjectB.SubscriptionCount);
            Assert.AreEqual(1, subjectC.SubscriptionCount);
            Assert.AreEqual(1, subjectD.SubscriptionCount);
        }
Example #11
0
        public void merges_multiple_joins_that_share_sources()
        {
            var subjectA = new Subject <int>();
            var subjectB = new Subject <int>();
            var subjectC = new Subject <int>();

            var stats = new StatsObserver <string>();

            Observable.Join(
                subjectA.And(subjectB).Then((x, y) => String.Concat(x.ToString(), ",", y.ToString())),
                subjectA.And(subjectC).Then((x, y) => String.Concat(x.ToString(), "x", y.ToString()))
                )
            .Subscribe(stats);

            subjectA.OnNext(0);
            subjectC.OnNext(2);

            subjectA.OnNext(0);
            subjectB.OnNext(1);


            Assert.AreEqual(2, stats.NextCount);
            Assert.AreEqual("0x2", stats.NextValues[0]);
            Assert.AreEqual("0,1", stats.NextValues[1]);
        }
        public void live_values_are_sent_through_scheduler()
        {
            ManualScheduler scheduler = new ManualScheduler();

            BehaviorSubject<int> subject = new BehaviorSubject<int>(0, scheduler);

            StatsObserver<int> stats = new StatsObserver<int>();

            subject.Subscribe(stats);

            subject.OnNext(1);
            subject.OnNext(2);
            subject.OnCompleted();

            Assert.IsFalse(stats.NextCalled);

            scheduler.RunNext();
            Assert.AreEqual(1, stats.NextCount);
            Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 0 }));
            Assert.IsFalse(stats.CompletedCalled);

            scheduler.RunNext();
            Assert.AreEqual(2, stats.NextCount);
            Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 0, 1 }));
            Assert.IsFalse(stats.CompletedCalled);

            scheduler.RunNext();
            Assert.AreEqual(3, stats.NextCount);
            Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 0, 1, 2 }));
            Assert.IsFalse(stats.CompletedCalled);

            scheduler.RunNext();
            Assert.IsTrue(stats.CompletedCalled);
        }
Example #13
0
 public void Unsubscribe(StatsObserver observer)
 {
     if (observers.Contains(observer))
     {
         observers.Remove(observer);
     }
 }
Example #14
0
        public void complete_does_not_unsubscribe_from_other_subjects()
        {
            var subjectA = new StatsSubject<int>();
            var subjectB = new StatsSubject<int>();
            var subjectC = new StatsSubject<int>();
            var subjectD = new StatsSubject<int>();

            var stats = new StatsObserver<string>();

            Observable.Join(
                    subjectA.And(subjectB).Then((x,y) => x.ToString() + "," + y.ToString()),
                    subjectC.And(subjectD).Then((x,y) => x.ToString() + "," + y.ToString())
                )
                .Subscribe(stats);

            Assert.AreEqual(1, subjectA.SubscriptionCount);
            Assert.AreEqual(1, subjectB.SubscriptionCount);
            Assert.AreEqual(1, subjectC.SubscriptionCount);
            Assert.AreEqual(1, subjectD.SubscriptionCount);

            subjectA.OnCompleted();

            Assert.AreEqual(0, subjectA.SubscriptionCount);
            Assert.AreEqual(1, subjectB.SubscriptionCount);
            Assert.AreEqual(1, subjectC.SubscriptionCount);
            Assert.AreEqual(1, subjectD.SubscriptionCount);
        }
        public void values_can_be_triggered_by_time_or_count()
        {
            var scheduler = new TestScheduler();

            var source = scheduler.CreateColdObservable(
                // start #1 (@0)
                new Recorded<Notification<int>>(10, OnNext(1)),
                new Recorded<Notification<int>>(12, OnNext(2)),
                new Recorded<Notification<int>>(14, OnNext(3)),
                // start #2 (@ 15)
                new Recorded<Notification<int>>(16, OnNext(4)),
                new Recorded<Notification<int>>(20, OnNext(5)),
                new Recorded<Notification<int>>(24, OnNext(6)),
                new Recorded<Notification<int>>(28, OnNext(7)),
                // start #3 (@ 28)
                // start #4 (@ 43)
                new Recorded<Notification<int>>(50, OnNext(8)),
                new Recorded<Notification<int>>(51, OnCompleted())
            );

            var stats = new StatsObserver<IList<int>>();

            source.BufferWithTimeOrCount(new TimeSpan(15), 4, scheduler)
                .Subscribe(stats);

            scheduler.Run();

            Assert.AreEqual(4, stats.NextCount);
            Assert.AreEqual(3, stats.NextValues[0].Count);
            Assert.AreEqual(4, stats.NextValues[1].Count);
            Assert.AreEqual(0, stats.NextValues[2].Count);
            Assert.AreEqual(1, stats.NextValues[3].Count);
        }
Example #16
0
        public void each_subscriber_is_scheduled_individually()
        {
            ManualScheduler scheduler = new ManualScheduler();

            AsyncSubject<int> subject = new AsyncSubject<int>(scheduler);

            StatsObserver<int> statsA = new StatsObserver<int>();
            StatsObserver<int> statsB = new StatsObserver<int>();

            subject.OnNext(1);
            subject.OnNext(2);
            subject.OnNext(3);
            subject.OnCompleted();

            subject.Subscribe(statsA);
            subject.Subscribe(statsB);

            scheduler.RunNext();

            Assert.IsTrue(statsA.NextCalled);
            Assert.IsFalse(statsB.NextCalled);

            scheduler.RunNext();

            Assert.IsTrue(statsB.NextCalled);
        }
Example #17
0
        public void live_values_are_sent_through_scheduler()
        {
            ManualScheduler scheduler = new ManualScheduler();

            BehaviorSubject <int> subject = new BehaviorSubject <int>(0, scheduler);

            StatsObserver <int> stats = new StatsObserver <int>();

            subject.Subscribe(stats);

            subject.OnNext(1);
            subject.OnNext(2);
            subject.OnCompleted();

            Assert.IsFalse(stats.NextCalled);

            scheduler.RunNext();
            Assert.AreEqual(1, stats.NextCount);
            Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 0 }));
            Assert.IsFalse(stats.CompletedCalled);

            scheduler.RunNext();
            Assert.AreEqual(2, stats.NextCount);
            Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 0, 1 }));
            Assert.IsFalse(stats.CompletedCalled);

            scheduler.RunNext();
            Assert.AreEqual(3, stats.NextCount);
            Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 0, 1, 2 }));
            Assert.IsFalse(stats.CompletedCalled);

            scheduler.RunNext();
            Assert.IsTrue(stats.CompletedCalled);
        }
Example #18
0
        public void values_are_taken_from_each_selected_value()
        {
            var stats = new StatsObserver <int>();

            var source = new Subject <int>();
            var first  = new Subject <int>();
            var second = new Subject <int>();

            var remaining = new Queue <IObservable <int> >();

            remaining.Enqueue(first);
            remaining.Enqueue(second);

            var manObs = source
                         .SelectMany(x => remaining.Dequeue())
                         .Subscribe(stats);

            source.OnNext(0);
            first.OnNext(1);

            source.OnNext(2);
            second.OnNext(3);
            first.OnNext(4);
            second.OnNext(5);

            Assert.AreEqual(4, stats.NextCount);
            Assert.AreEqual(1, stats.NextValues[0]);
            Assert.AreEqual(3, stats.NextValues[1]);
            Assert.AreEqual(4, stats.NextValues[2]);
            Assert.AreEqual(5, stats.NextValues[3]);
        }
Example #19
0
        public void matches_values_in_order_when_sent_out_of_order()
        {
            var subjectA = new Subject <int>();
            var subjectB = new Subject <int>();

            var stats = new StatsObserver <string>();

            Observable.Join(
                subjectA.And(subjectB).Then((x, y) => String.Concat(x.ToString(), ",", y.ToString()))
                )
            .Subscribe(stats);

            subjectA.OnNext(0);
            subjectA.OnNext(1);
            subjectA.OnCompleted();

            subjectB.OnNext(10);
            subjectB.OnNext(11);
            subjectB.OnCompleted();

            Assert.AreEqual(2, stats.NextCount);
            Assert.AreEqual("0,10", stats.NextValues[0]);
            Assert.AreEqual("1,11", stats.NextValues[1]);
            Assert.IsTrue(stats.CompletedCalled);
        }
Example #20
0
        public void honours_window_for_replays_with_priority_to_most_recent()
        {
            ManualScheduler scheduler = new ManualScheduler();

            ReplaySubject <int> subject =
                new ReplaySubject <int>(TimeSpan.FromMilliseconds(10), scheduler);

            StatsObserver <int> stats = new StatsObserver <int>();

            DateTime start = DateTime.UtcNow;

            scheduler.Now = start;
            subject.OnNext(1);

            scheduler.Now = start.AddMilliseconds(5);
            subject.OnNext(2);

            scheduler.Now = start.AddMilliseconds(10);
            subject.OnNext(3);

            scheduler.Now = start.AddMilliseconds(11);
            subject.Subscribe(stats);

            scheduler.RunAll();

            Assert.AreEqual(2, stats.NextCount);
            Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 2, 3 }));
            Assert.IsFalse(stats.CompletedCalled);
        }
Example #21
0
        static void Main(string[] args)
        {
            var config = new ConfigurationBuilder()
                         .AddEnvironmentVariables()
                         .AddJsonFile("appsettings.json", true)
                         .Build();

            var deviceConnectionString = config["AzureIotHub:AccessKey"];
            var deviceId = config["AzureIotHub:DeviceId"];

            TelemetryConfiguration.Active.InstrumentationKey = config["ApplicationInsights:InstrumentationKey"];

            var ip   = config["Device:IP"];
            var port = int.Parse(config["Device:Port"]);

            if (args.Any())
            {
                ip = args[0];
                if (args.Length > 1)
                {
                    port = int.Parse(args[1]);
                }
            }
            Console.WriteLine($"Connecting to {ip}:{port}...");
            Console.WriteLine($"Creating IoT Hub client for {deviceId}");

            var tc        = new TelemetryClient();
            var logger    = new AiLog(tc);
            var iotClient = DeviceClient.CreateFromConnectionString(deviceConnectionString, TransportType.Amqp);
            var iotOb     = new IotHubObserver(iotClient, logger);
            var consoleOb = new StatsObserver();
            var c         = new Connector(ip, port, logger, iotOb, consoleOb);
        }
Example #22
0
        public void with_both_window_and_buffer_size_values_can_be_ignored_by_window()
        {
            ManualScheduler scheduler = new ManualScheduler();

            ReplaySubject <int> subject =
                new ReplaySubject <int>(3, TimeSpan.FromMilliseconds(10), scheduler);

            StatsObserver <int> stats = new StatsObserver <int>();

            DateTime start = DateTime.UtcNow;

            scheduler.Now = start; // ignored by window
            subject.OnNext(1);

            scheduler.Now = start.AddMilliseconds(5);
            subject.OnNext(2);

            scheduler.Now = start.AddMilliseconds(8);
            subject.OnCompleted();

            scheduler.Now = start.AddMilliseconds(11);
            subject.Subscribe(stats);

            scheduler.RunAll();

            Assert.AreEqual(1, stats.NextCount);
            Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 2 }));
            Assert.IsTrue(stats.CompletedCalled);
        }
        public void time_offset_excludes_values_of_exact_offset()
        {
            var stats = new StatsObserver<IList<int>>();

            var valueScheduler = new ManualScheduler();
            var bufferScheduler = new ManualScheduler();

            DateTimeOffset startTime = DateTimeOffset.UtcNow;

            Observable.Range(0, 5, valueScheduler)
                .BufferWithTime(TimeSpan.FromMilliseconds(30), TimeSpan.FromMilliseconds(20), bufferScheduler)
                .Subscribe(stats);

            Assert.IsFalse(stats.NextCalled);

            bufferScheduler.Now = startTime.AddMilliseconds(10);
            valueScheduler.RunNext();

            bufferScheduler.Now = startTime.AddMilliseconds(20); // exact offset value
            valueScheduler.RunNext();

            bufferScheduler.Now = startTime.AddMilliseconds(30);
            valueScheduler.RunNext();

            bufferScheduler.RunNext();
            bufferScheduler.RunNext();

            Assert.AreEqual(2, stats.NextCount);
            Assert.AreEqual(1, stats.NextValues[1].Count);
        }
Example #24
0
        public void each_subscriber_is_scheduled_individually()
        {
            ManualScheduler scheduler = new ManualScheduler();

            AsyncSubject <int> subject = new AsyncSubject <int>(scheduler);

            StatsObserver <int> statsA = new StatsObserver <int>();
            StatsObserver <int> statsB = new StatsObserver <int>();

            subject.OnNext(1);
            subject.OnNext(2);
            subject.OnNext(3);
            subject.OnCompleted();

            subject.Subscribe(statsA);
            subject.Subscribe(statsB);


            scheduler.RunNext();

            Assert.IsTrue(statsA.NextCalled);
            Assert.IsFalse(statsB.NextCalled);

            scheduler.RunNext();

            Assert.IsTrue(statsB.NextCalled);
        }
Example #25
0
        public void unsubscribes_from_other_after_value()
        {
            var stats = new StatsObserver <int>();

            Observable.Range(0, 5).SkipUntil(Observable.Return(1).Concat(Observable.Throw <int>(new ApplicationException())))
            .Subscribe(stats);
        }
Example #26
0
        public void values_are_skipped_when_not_connected()
        {
            Subject <int> subject = new Subject <int>();

            var stats = new StatsObserver <int>();

            var obs         = subject.Prune();
            var connectionA = obs.Connect();

            subject.OnNext(1);
            subject.OnNext(2); // last connected value

            connectionA.Dispose();

            subject.OnNext(3); // not connected here

            var connectionB = obs.Connect();

            subject.OnCompleted();

            connectionB.Dispose();

            obs.Subscribe(stats);

            Assert.IsTrue(stats.NextCalled);
            Assert.AreEqual(2, stats.NextValues[0]);
            Assert.IsTrue(stats.CompletedCalled);
        }
Example #27
0
        public void SetUp()
        {
            source       = new Subject <int>();
            windows      = new List <StatsSubject <Unit> >();
            windowsStats = new List <StatsObserver <int> >();
            overallStats = new StatsObserver <int>();

            subscription = source.Window(() =>
            {
                StatsSubject <Unit> window = new StatsSubject <Unit>();

                windows.Add(window);

                return(window);
            })
                           .Subscribe(o =>
            {
                var stats = new StatsObserver <int>();
                windowsStats.Add(stats);

                o.Subscribe(stats);
            },
                                      overallStats.OnError,
                                      overallStats.OnCompleted);
        }
Example #28
0
        public void time_offset_excludes_values_of_exact_offset()
        {
            var stats = new StatsObserver <IList <int> >();

            var valueScheduler  = new ManualScheduler();
            var bufferScheduler = new ManualScheduler();

            DateTimeOffset startTime = DateTimeOffset.UtcNow;

            Observable.Range(0, 5, valueScheduler)
            .BufferWithTime(TimeSpan.FromMilliseconds(30), TimeSpan.FromMilliseconds(20), bufferScheduler)
            .Subscribe(stats);

            Assert.IsFalse(stats.NextCalled);

            bufferScheduler.Now = startTime.AddMilliseconds(10);
            valueScheduler.RunNext();

            bufferScheduler.Now = startTime.AddMilliseconds(20); // exact offset value
            valueScheduler.RunNext();

            bufferScheduler.Now = startTime.AddMilliseconds(30);
            valueScheduler.RunNext();

            bufferScheduler.RunNext();
            bufferScheduler.RunNext();

            Assert.AreEqual(2, stats.NextCount);
            Assert.AreEqual(1, stats.NextValues[1].Count);
        }
Example #29
0
        public void last_value_is_received_after_completed_if_any_connection_is_disposed()
        {
            Subject <int> subject = new Subject <int>();

            var stats = new StatsObserver <int>();

            var obs         = subject.Prune();
            var connectionA = obs.Connect();
            var connectionB = obs.Connect();

            subject.OnNext(1);
            subject.OnNext(2);
            subject.OnNext(3);

            connectionA.Dispose();

            subject.OnCompleted();

            connectionB.Dispose();

            obs.Subscribe(stats);

            Assert.IsFalse(stats.NextCalled);
            Assert.IsFalse(stats.CompletedCalled);
        }
Example #30
0
        public void values_are_buffered_in_specified_time()
        {
            var scheduler = new TestScheduler();

            var source = scheduler.CreateColdObservable(
                // start #1 (@0)
                new Recorded <Notification <int> >(10, OnNext(1)),
                new Recorded <Notification <int> >(12, OnNext(2)),
                // start #2 (@ 15)
                // start #3 (@ 30)
                new Recorded <Notification <int> >(40, OnNext(3)),
                // start #4 (@ 45)
                new Recorded <Notification <int> >(50, OnNext(4)),
                new Recorded <Notification <int> >(51, OnCompleted())
                );

            var stats = new StatsObserver <IList <int> >();

            source.BufferWithTime(new TimeSpan(15), scheduler)
            .Subscribe(stats);

            scheduler.Run();

            Assert.AreEqual(4, stats.NextCount);
            Assert.AreEqual(2, stats.NextValues[0].Count);
            Assert.AreEqual(0, stats.NextValues[1].Count);
            Assert.AreEqual(1, stats.NextValues[2].Count);
            Assert.AreEqual(1, stats.NextValues[3].Count);
        }
        public void values_are_buffered_in_specified_time()
        {
            var scheduler = new TestScheduler();

            var source = scheduler.CreateColdObservable(
                                                                // start #1 (@0)
                new Recorded<Notification<int>>(10, OnNext(1)),
                new Recorded<Notification<int>>(12, OnNext(2)),
                                                                // start #2 (@ 15)
                                                                // start #3 (@ 30)
                new Recorded<Notification<int>>(40, OnNext(3)),
                                                                // start #4 (@ 45)
                new Recorded<Notification<int>>(50, OnNext(4)),
                new Recorded<Notification<int>>(51, OnCompleted())
            );

            var stats = new StatsObserver<IList<int>>();

            source.BufferWithTime(new TimeSpan(15), scheduler)
                .Subscribe(stats);

            scheduler.Run();

            Assert.AreEqual(4, stats.NextCount);
            Assert.AreEqual(2, stats.NextValues[0].Count);
            Assert.AreEqual(0, stats.NextValues[1].Count);
            Assert.AreEqual(1, stats.NextValues[2].Count);
            Assert.AreEqual(1, stats.NextValues[3].Count);
        }
Example #32
0
        public void exception_thrown_in_error_action_is_bubbled()
        {
            StatsObserver <int> stats = new StatsObserver <int>();

            Observable.Throw <int>(new Exception())
            .Do(x => { }, e => { throw new ApplicationException(); })
            .Subscribe(stats);
        }
Example #33
0
        public void exception_thrown_in_next_action_bubbles_when_complete_action_is_specifid()
        {
            StatsObserver <int> stats = new StatsObserver <int>();

            Observable.Range(0, 2)
            .Do(x => { throw new ApplicationException(); }, e => { }, () => { })
            .Subscribe(stats);
        }
Example #34
0
        public void repeat_with_no_arguments_repeats_forever()
        {
            var stats = new StatsObserver <int>();

            Observable.Repeat(1).Take(100).Subscribe(stats);

            Assert.AreEqual(100, stats.NextCount);
        }
Example #35
0
        public void repeatCount_includes_initial_subscription()
        {
            var stats = new StatsObserver <int>();

            Observable.Repeat(1, 2).Subscribe(stats);

            Assert.AreEqual(2, stats.NextCount);
        }
Example #36
0
        public void exception_thrown_in_next_action_bubbles_when_complete_action_is_specifid()
        {
            StatsObserver<int> stats = new StatsObserver<int>();

            Observable.Range(0, 2)
                .Do(x => { throw new ApplicationException(); }, e => { }, () => { })
                .Subscribe(stats);
        }
Example #37
0
        public void exception_thrown_in_error_action_is_bubbled()
        {
            StatsObserver<int> stats = new StatsObserver<int>();

            Observable.Throw<int>(new Exception())
                .Do(x => { }, e => { throw new ApplicationException(); })
                .Subscribe(stats);
        }
Example #38
0
        public void supports_null_cancelable_value()
        {
            StatsObserver <int> stats = new StatsObserver <int>();

            Observable.CreateWithDisposable <int>(x => null)
            .Subscribe(stats)
            .Dispose();
        }
Example #39
0
        public void repeatCount_includes_initial_subscription()
        {
            var stats = new StatsObserver<int>();

            Observable.Return(1).Repeat(2).Subscribe(stats);

            Assert.AreEqual(2, stats.NextCount);
        }
Example #40
0
        public void error_thrown_by_keyselector_sent_to_onerror()
        {
            var stats = new StatsObserver <IGroupedObservable <int, int> >();

            source.ToObservable().GroupByUntil(x => { throw new Exception(); return(x.Key); }, x => x.Value, g => Observable.Never <int>())
            .Subscribe(stats);

            Assert.IsTrue(stats.ErrorCalled);
        }
Example #41
0
        public void error_thrown_by_keycomparer_sent_to_onerror()
        {
            var stats = new StatsObserver <IGroupedObservable <int, int> >();

            source.ToObservable().GroupBy(x => x.Key, x => x.Value, new AnonymousComparer <int>((x, y) => { throw new Exception(); }))
            .Subscribe(stats);

            Assert.IsTrue(stats.ErrorCalled);
        }
Example #42
0
        public void error_thrown_by_elementselector_sent_to_onerror()
        {
            var stats = new StatsObserver <IGroupedObservable <int, int> >();

            source.ToObservable().GroupBy(x => x.Key, x => { throw new Exception(); return(x.Key); })
            .Subscribe(stats);

            Assert.IsTrue(stats.ErrorCalled);
        }
Example #43
0
        public void throws_argument_error_when_return_value_is_null()
        {
            StatsObserver <int> stats = new StatsObserver <int>();

            Observable.Create <int>(x => null)
            .Subscribe(stats);

            Assert.IsTrue(stats.ErrorCalled);
        }
Example #44
0
        public void empty_sequence_returns_true()
        {
            var stats = new StatsObserver<bool>();

            Observable.Empty<int>().All(x => x > 2).Subscribe(stats);

            Assert.IsTrue(stats.CompletedCalled);
            Assert.IsTrue(stats.NextCalled);
            Assert.IsTrue(stats.NextValues[0]);
        }
        public void no_values_are_emitted_if_one_source_is_empty()
        {
            var stats = new StatsObserver<String>();

            Observable.Empty<int>().ForkJoin(Observable.Return(1), selector)
                    .Subscribe(stats);

            Assert.AreEqual(0, stats.NextCount);
            Assert.IsTrue(stats.CompletedCalled);
        }
Example #46
0
        public void catch_with_observer_does_not_fire_onerror()
        {
            StatsObserver<int> observer = new StatsObserver<int>();

            Observable.Throw<int>(new ApplicationException())
                .Catch(Observable.Empty<int>())
                .Subscribe(observer);

            Assert.IsFalse(observer.ErrorCalled);
        }
Example #47
0
        public void exception_thrown_in_complete_action_is_bubbled()
        {
            StatsObserver<int> stats = new StatsObserver<int>();

            Observable.Range(0, 2)
                .Do(x => { }, () => { throw new ApplicationException(); })
                .Subscribe(stats);

            Assert.IsTrue(stats.ErrorCalled);
        }
Example #48
0
        public void no_values_are_emitted_on_empty_sequence()
        {
            var stats = new StatsObserver<int>();

            Observable.Empty<int>()
                .TakeLast(3)
                .Subscribe(stats);

            Assert.AreEqual(0, stats.NextCount);
        }
Example #49
0
        public void exception_thrown_in_next_action_bubbles_when_all_actions_are_specifid()
        {
            StatsObserver<int> stats = new StatsObserver<int>();

            Observable.Range(0, 2)
                .Do(x => { throw new ApplicationException(); }, e => { }, () => { })
                .Subscribe(stats);

            Assert.IsTrue(stats.ErrorCalled);
        }
Example #50
0
        public void empty_sequence()
        {
            var stats = new StatsObserver<bool>();

            Observable.Empty<int>()
                .All(x => true)
                .Subscribe(stats);

            Assert.IsTrue(stats.NextValues[0]);
        }
Example #51
0
        public void value_equals_number_of_values()
        {
            StatsObserver<int> stats = new StatsObserver<int>();

            Observable.Range(5, 3).Count().Subscribe(stats);

            Assert.AreEqual(1, stats.NextCount);
            Assert.AreEqual(3, stats.NextValues[0]);
            Assert.IsTrue(stats.CompletedCalled);
        }
Example #52
0
        public void finally_action_is_executed_after_complete()
        {
            StatsObserver<int> stats = new StatsObserver<int>();

            Observable.Empty<int>()
                .Finally(() =>
                {
                    Assert.IsTrue(stats.CompletedCalled);
                })
                .Subscribe(stats);
        }
Example #53
0
        public void finally_action_is_executed_after_error()
        {
            StatsObserver<int> stats = new StatsObserver<int>();

            Observable.Throw<int>(new ApplicationException())
                .Finally(() =>
                {
                    Assert.IsTrue(stats.ErrorCalled);
                })
                .Subscribe(stats);
        }
Example #54
0
        public void catch_with_action_fires_original_error_if_error_is_not_of_specified_type()
        {
            StatsObserver<int> observer = new StatsObserver<int>();

            Observable.Throw<int>(new OverflowException())
                .Catch<int, ApplicationException>(e => { Assert.Fail("Unexpected call to defer action"); return null; })
                .Subscribe(observer);

            Assert.IsTrue(observer.ErrorCalled);
            Assert.IsInstanceOf<OverflowException>(observer.Error);
        }
Example #55
0
        public void outputs_one_value_after_completion()
        {
            StatsObserver<int> stats = new StatsObserver<int>();

            Observable.Range(0, 5)
                .Aggregate((x, y) => x + y)
                .Subscribe(stats);

            Assert.AreEqual(1, stats.NextCount);
            Assert.AreEqual(10, stats.NextValues[0]);
        }
Example #56
0
        public void raises_error_on_empty_source()
        {
            StatsObserver<int> stats = new StatsObserver<int>();

            Observable.Empty<int>()
                .Aggregate((x, y) => x + y)
                .Subscribe(stats);

            Assert.IsTrue(stats.ErrorCalled);
            Assert.IsFalse(stats.CompletedCalled);
        }
Example #57
0
        public void catch_with_action_raises_original_error_if_action_returns_null()
        {
            StatsObserver<int> observer = new StatsObserver<int>();

            Observable.Throw<int>(new OverflowException())
                .Catch<int, ApplicationException>(e => null)
                .Subscribe(observer);

            Assert.IsTrue(observer.ErrorCalled);
            Assert.IsInstanceOf<OverflowException>(observer.Error);
        }
Example #58
0
        public void catch_with_action_fires_error_if_last_observer_raises_error()
        {
            StatsObserver<int> observer = new StatsObserver<int>();

            Observable.Throw<int>(new Exception())
                .Catch<int, Exception>(e => Observable.Throw<int>(new ApplicationException()))
                .Subscribe(observer);

            Assert.IsTrue(observer.ErrorCalled);
            Assert.IsInstanceOf<ApplicationException>(observer.Error);
        }
        public void SetUp()
        {
            stats = new StatsObserver<IObservable<int>>();

            subject = new Subject<int>();

            timeSpan = TimeSpan.FromMilliseconds(50);
            timeShift = TimeSpan.FromMilliseconds(10);

            scheduler = new TestScheduler();
        }
Example #60
0
        public void does_not_call_accumulator_for_first_value_initial_value_not_supplied()
        {
            StatsObserver<int> stats = new StatsObserver<int>();

            List<int> accumulatorValues = new List<int>();

            Observable.Range(0, 5)
                .Aggregate((x, y) => { accumulatorValues.Add(y); return x + y; })
                .Subscribe(stats);

            Assert.AreEqual(1, accumulatorValues[0]);
        }