public void SimpleSubject_Checks()
        {
            var s = new SimpleSubject <int>();

            var o1 = s.CreateObserver();
            var o2 = s.CreateObserver();

            Assert.AreSame(o1, o2);

            Assert.ThrowsException <ArgumentNullException>(() => s.Subscribe(null));
        }
        public void SimpleSubject_Basics_OnNext()
        {
            var s = new SimpleSubject <int>();

            var o1 = s.CreateObserver();

            o1.OnNext(42);

            var s1 = new List <int>();
            var d1 = s.Subscribe(x => s1.Add(x));

            o1.OnNext(43);

            var s2 = new List <int>();
            var d2 = s.Subscribe(x => s2.Add(x));

            o1.OnNext(44);

            var s3 = new List <int>();
            var d3 = s.Subscribe(x => s3.Add(x));

            o1.OnNext(45);

            d1.Dispose();

            o1.OnNext(46);

            d3.Dispose();

            o1.OnNext(47);

            var s4 = new List <int>();
            var d4 = s.Subscribe(x => s4.Add(x));

            o1.OnNext(48);

            d2.Dispose();
            d4.Dispose();

            o1.OnNext(49);

            var s5 = new List <int>();
            var d5 = s.Subscribe(x => s5.Add(x));

            o1.OnNext(50);

            Assert.IsTrue(new[] { 43, 44, 45 }.SequenceEqual(s1));
            Assert.IsTrue(new[] { 44, 45, 46, 47, 48 }.SequenceEqual(s2));
            Assert.IsTrue(new[] { 45, 46 }.SequenceEqual(s3));
            Assert.IsTrue(new[] { 48 }.SequenceEqual(s4));
            Assert.IsTrue(new[] { 50 }.SequenceEqual(s5));
        }
        public void SimpleSubject_Basics_DoubleDisposeIsFine()
        {
            var s = new SimpleSubject <int>();

            var o1 = s.CreateObserver();

            var d = s.Subscribe(_ => { Assert.Fail(); });

            d.Dispose();

            o1.OnNext(42);

            d.Dispose();

            o1.OnNext(42);
        }
Exemple #4
0
        public void SubscriptionStateVisitor_Basics()
        {
            var state         = new MockOperatorStateContainer();
            var writerFactory = state.CreateWriter();
            var readerFactory = state.CreateReader();

            var xs = new SimpleSubject <int>();
            var o  = xs.CreateObserver();

            var ys = new Take <int>(xs, 5);

            {
                var s1 = ys.Subscribe(Observer.Create <int>(_ => { }, _ => { }, () => { }));
                var v  = new SubscriptionInitializeVisitor(s1);
                v.Subscribe();
                v.Start();

                o.OnNext(42);
                o.OnNext(43);

                var sv = new SubscriptionStateVisitor(s1);

                Assert.IsTrue(sv.HasStateChanged());

                sv.SaveState(writerFactory);

                Assert.IsTrue(sv.HasStateChanged());

                sv.OnStateSaved();

                Assert.IsFalse(sv.HasStateChanged());

                o.OnNext(44);
                o.OnNext(45);

                Assert.IsTrue(sv.HasStateChanged());
            }

            {
                var done = false;

                var s2 = ys.Subscribe(Observer.Create <int>(_ => { }, _ => { }, () => { done = true; }));

                var sv = new SubscriptionStateVisitor(s2);

                sv.LoadState(readerFactory);

                var v = new SubscriptionInitializeVisitor(s2);
                v.Subscribe();
                v.Start();

                o.OnNext(46);
                Assert.IsFalse(done);

                o.OnNext(47);
                Assert.IsFalse(done);

                o.OnNext(48);
                Assert.IsTrue(done);
            }
        }