public void TestList2()
        {
            var sourcesList = new ClassWithList();
            var property    = new ReactiveExpression <int>(() => sourcesList.Sources.Count);

            property.Evaluate();
            var counter     = 0;
            var expectation = 1;

            property.Subscribe(s => ReactiveManagerTest.Const(s, () => counter++));

            Assert.AreEqual(expectation, counter);
            var source1 = new Source();

            sourcesList.Sources.Add(source1);
            Assert.AreEqual(++expectation, counter);

            Assert.AreEqual(1, property.Evaluate());
            var source2 = new Source();

            sourcesList.Sources.Add(source2);
            Assert.AreEqual(++expectation, counter);

            source1.Woop = true;
            Assert.AreEqual(expectation, counter);
        }
        public void When_Item_Has_PropertyNamedTestList_Then_Serialize_Returns_CamelCasePropertyName()
        {
            // set up
            var subject = new JsonSerializer();
            var item    = new ClassWithList()
            {
                TestList = new List <int> {
                    1, 2, 3
                }
            };

            // execute
            var actual = subject.Serialize(item);

            // verify
            Assert.Contains("\"testList\"", actual);
        }
        public void When_Item_Has_List_Then_Serialize_Returns_JsonArray()
        {
            // set up
            var subject = new JsonSerializer();
            var item    = new ClassWithList()
            {
                TestList = new List <int> {
                    1, 2, 3
                }
            };

            // execute
            var actual = subject.Serialize(item);

            // verify
            Assert.Equal("{\"testList\":[1,2,3]}", actual);
        }
Beispiel #4
0
    public void Should_compare_null_to_empty()
    {
        ClassWithList one = new ClassWithList {
            Id = "ten", Items = null, Nested = new List <ClassWithList> {
                new ClassWithList {
                    Id = "a"
                }
            }
        };
        ClassWithList two = new ClassWithList {
            Id = "ten", Items = new List <string>(), Nested = new List <ClassWithList> {
                new ClassWithList {
                    Id = "a", Items = new List <string>(), Nested = new List <ClassWithList> {
                    }
                }
            }
        };

        two.ShouldBeEquivalentTo(one, opt => opt
                                 .Using <IEnumerable>(CheckList)
                                 .When(info => typeof(IEnumerable).IsAssignableFrom(info.CompileTimeType)));
    }
        public void TestList()
        {
            var source1     = new Source();
            var source2     = new Source();
            var source3     = new Source();
            var sourcesList = new ClassWithList();

            sourcesList.Sources.Add(source1);
            sourcesList.Sources.Add(source2);

            var counter     = 0;
            var expectation = 1;
            var property    = new ReactiveExpression <bool>(() => sourcesList.Sources[1].Woop);

            property.Evaluate();
            property.Subscribe(s => ReactiveManagerTest.Const(s, () => counter++));

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

            source2.Woop = true;
            Assert.AreEqual(true, property.Evaluate());
            Assert.AreEqual(++expectation, counter);

            source1.Woop = false;
            sourcesList.Sources.Insert(0, source3);
            Assert.AreEqual(false, property.Evaluate());
            Assert.AreEqual(++expectation, counter);

            source2.Woop = false;
            source3.Woop = true;
            Assert.AreEqual(expectation, counter);
            source1.Woop = true;
            Assert.AreEqual(true, property.Evaluate());
            Assert.AreEqual(++expectation, counter);
        }