Example #1
0
        public void Reactive()
        {
            var source1     = new Source();
            var source2     = new Source();
            var user        = new SimpleSink(source1);
            var counter     = 0;
            var expectation = 1;

            user.BoopReactive.Subscribe(getValue => ReactiveManagerTest.Const(getValue, () => counter++));

            Assert.AreEqual(expectation, counter);
            Assert.AreEqual(false, user.Boop);

            source1.Woop = true;
            Assert.AreEqual(++expectation, counter);
            Assert.AreEqual(true, user.Boop);

            source2.Woop = true;
            Assert.AreEqual(expectation, counter);
            Assert.AreEqual(true, user.Boop);

            source1.Woop = false;
            Assert.AreEqual(++expectation, counter);
            Assert.AreEqual(false, user.Boop);

            user.Source = source2;
            Assert.AreEqual(++expectation, counter);
            Assert.AreEqual(true, user.Boop);

            source2.Woop = false;
            Assert.AreEqual(++expectation, counter);
            Assert.AreEqual(false, user.Boop);
        }
Example #2
0
        public void Reactive()
        {
            var source1 = new Source();
            var source2 = new Source();
            var user    = new SimpleSink(source1);
            var counter = 0;

            ObservableUtility.FromProperty(() => user.Boop).Skip(1).Subscribe(value => counter++);

            Assert.AreEqual(0, counter);
            Assert.AreEqual(false, user.Boop);

            source1.Woop = true;
            Assert.AreEqual(1, counter);
            Assert.AreEqual(true, user.Boop);

            source2.Woop = true;
            Assert.AreEqual(1, counter);
            Assert.AreEqual(true, user.Boop);

            source1.Woop = false;
            Assert.AreEqual(2, counter);
            Assert.AreEqual(false, user.Boop);

            user.Source = source2;
            Assert.AreEqual(3, counter);
            Assert.AreEqual(true, user.Boop);

            source2.Woop = false;
            Assert.AreEqual(4, counter);
            Assert.AreEqual(false, user.Boop);
        }
Example #3
0
        public void TestEventWithoutPropertyAccess()
        {
            var source = new Source();
            var sink   = new SimpleSink(source);

            var counter     = 0;
            var expectation = 1;

            new ReactiveExpression <bool>(() => sink.Boop).Subscribe(value => counter++);
            Assert.AreEqual(expectation, counter);
            source.FlipWoop();
            Assert.AreEqual(expectation += WorksWithoutInitialPropertyAccess, counter);
        }
Example #4
0
        public void TestEventWithoutPropertyAccess()
        {
            var source = new Source();
            var sink   = new SimpleSink(source);

            var counter     = 0;
            var expectation = 0;

            ObservableUtility.FromProperty(() => sink.Boop, false).Subscribe(value => { counter++; });
            Assert.AreEqual(expectation, counter);
            source.FlipWoop();
            Assert.AreEqual(expectation += WorksWithoutInitialPropertyAccess, counter);
        }
Example #5
0
        public void ActiveAfterUsage()
        {
            var source  = new Source();
            var user    = new SimpleSink(source);
            var counter = 0;

            user.PropertyChanged += (sender, args) => counter++;

            Assert.AreEqual(0, counter);
            source.FlipWoop();
            Assert.AreEqual(0, counter);

            Assert.AreEqual(user.Boop, user.Boop);
            source.FlipWoop();
            Assert.AreEqual(1, counter);
        }
Example #6
0
        public void ActiveAfterUsage()
        {
            var source      = new Source();
            var user        = new SimpleSink(source);
            var counter     = 0;
            var expectation = 0;

            user.BoopReactive.Skip(1).Subscribe(getValue => counter++);

            Assert.AreEqual(expectation, counter);
            source.FlipWoop();
            Assert.AreEqual(expectation, counter);

            Assert.AreEqual(user.Boop, user.Boop);
            source.FlipWoop();
            Assert.AreEqual(++expectation, counter);
        }