public void CountTest()
        {
            var d = new DynamicPageDataDictionary <dynamic>(new PageDataDictionary <dynamic>());

            d.Add("x", 1);
            Assert.AreEqual(1, d.Count);
            d.Add("y", 2);
            Assert.AreEqual(2, d.Count);
        }
        public void ItemTest()
        {
            var d = new DynamicPageDataDictionary <dynamic>(new PageDataDictionary <dynamic>());

            d.Add("x", 1);
            d.Add("y", 2);
            Assert.AreEqual(1, d["x"]);
            Assert.AreEqual(2, d["y"]);
        }
        public void ValuesTest()
        {
            var d = new DynamicPageDataDictionary <dynamic>(new PageDataDictionary <dynamic>());

            d.Add("x", 1);
            d.Add("y", 2);
            Assert.IsTrue(d.Values.Contains(1));
            Assert.IsTrue(d.Values.Contains(2));
            Assert.AreEqual(2, d.Values.Count);
        }
        public void CountTest()
        {
            var     d   = new DynamicPageDataDictionary <dynamic>(new PageDataDictionary <dynamic>());
            dynamic dyn = d;

            Assert.IsType <int>(dyn.Count);
            d.Add("x", 1);
            Assert.Equal(1, d.Count);
            d.Add("y", 2);
            Assert.Equal(2, d.Count);
            dyn.Count = "foo";
            Assert.Equal("foo", d["Count"]);
            Assert.Equal(3, d.Count);
        }
        public void ValuesTest()
        {
            var     d   = new DynamicPageDataDictionary <dynamic>(new PageDataDictionary <dynamic>());
            dynamic dyn = d;

            Assert.IsAssignableFrom <ICollection <dynamic> >(dyn.Values);
            d.Add("x", 1);
            d.Add("y", 2);
            Assert.True(d.Values.Contains(1));
            Assert.True(d.Values.Contains(2));
            Assert.Equal(2, d.Values.Count);
            dyn.Values = "foo";
            Assert.Equal("foo", dyn["Values"]);
            Assert.Equal(3, d.Count);
        }
        public void KeysTest()
        {
            var     d   = new DynamicPageDataDictionary <dynamic>(new PageDataDictionary <dynamic>());
            dynamic dyn = d;

            Assert.IsAssignableFrom <ICollection <object> >(dyn.Keys);
            d.Add("x", 1);
            d.Add("y", 2);
            Assert.True(d.Keys.Contains("x"));
            Assert.True(d.Keys.Contains("y"));
            Assert.Equal(2, d.Keys.Count);
            dyn.Keys = "foo";
            Assert.Equal("foo", dyn["Keys"]);
            Assert.Equal(3, d.Count);
        }
 public void GetEnumeratorTest() {
     var d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
     d.Add("x", 1);
     var e = d.GetEnumerator();
     e.MoveNext();
     Assert.AreEqual(new KeyValuePair<object, object>("x", 1), e.Current);
 }
 public void CopyToTest() {
     var d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
     KeyValuePair<object, object>[] array = new KeyValuePair<object, object>[1];
     d.Add("x", 1);
     d.CopyTo(array, 0);
     Assert.AreEqual(new KeyValuePair<object, object>("x", 1), array[0]);
 }
 public void ContainsKeyTest() {
     var d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
     object key = "x";
     Assert.IsFalse(d.ContainsKey(key));
     d.Add(key, 1);
     Assert.IsTrue(d.ContainsKey(key));
     Assert.IsTrue(d.ContainsKey("x"));
 }
 public void ContainsTest() {
     var d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
     var item = new KeyValuePair<object, object>("x", 1);
     d.Add(item);
     Assert.IsTrue(d.Contains(item));
     var item2 = new KeyValuePair<object, object>("y", 2);
     Assert.IsFalse(d.Contains(item2));
 }
 public void AddTest() {
     dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
     var item = new KeyValuePair<object, object>("x", 2);
     d.Add(item);
     Assert.IsTrue(d.Contains(item));
     Assert.AreEqual(2, d.x);
     Assert.AreEqual(2, d["x"]);
 }
 public void AddTest1() {
     dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
     object key = "x";
     object value = 1;
     d.Add(key, value);
     Assert.IsTrue(d.ContainsKey(key));
     Assert.AreEqual(1, d[key]);
     Assert.AreEqual(1, d.x);
 }
        public void RemoveTest()
        {
            var d   = new DynamicPageDataDictionary <dynamic>(new PageDataDictionary <dynamic>());
            var key = "x";

            d.Add(key, 1);
            d.Remove(key);
            Assert.IsFalse(d.ContainsKey(key));
        }
        public void CopyToTest()
        {
            var d = new DynamicPageDataDictionary <dynamic>(new PageDataDictionary <dynamic>());

            KeyValuePair <object, object>[] array = new KeyValuePair <object, object> [1];
            d.Add("x", 1);
            d.CopyTo(array, 0);
            Assert.AreEqual(new KeyValuePair <object, object>("x", 1), array[0]);
        }
        public void GetEnumeratorTest()
        {
            var d = new DynamicPageDataDictionary <dynamic>(new PageDataDictionary <dynamic>());

            d.Add("x", 1);
            var e = d.GetEnumerator();

            e.MoveNext();
            Assert.AreEqual(new KeyValuePair <object, object>("x", 1), e.Current);
        }
        public void RemoveTest1()
        {
            var d    = new DynamicPageDataDictionary <dynamic>(new PageDataDictionary <dynamic>());
            var item = new KeyValuePair <object, object>("x", 2);

            d.Add(item);
            Assert.IsTrue(d.Contains(item));
            d.Remove(item);
            Assert.IsFalse(d.Contains(item));
        }
        public void ContainsKeyTest()
        {
            var    d   = new DynamicPageDataDictionary <dynamic>(new PageDataDictionary <dynamic>());
            object key = "x";

            Assert.IsFalse(d.ContainsKey(key));
            d.Add(key, 1);
            Assert.IsTrue(d.ContainsKey(key));
            Assert.IsTrue(d.ContainsKey("x"));
        }
        public void AddTest()
        {
            dynamic d    = new DynamicPageDataDictionary <dynamic>(new PageDataDictionary <dynamic>());
            var     item = new KeyValuePair <object, object>("x", 2);

            d.Add(item);
            Assert.IsTrue(d.Contains(item));
            Assert.AreEqual(2, d.x);
            Assert.AreEqual(2, d["x"]);
        }
        public void AddTest1()
        {
            dynamic d     = new DynamicPageDataDictionary <dynamic>(new PageDataDictionary <dynamic>());
            object  key   = "x";
            object  value = 1;

            d.Add(key, value);
            Assert.IsTrue(d.ContainsKey(key));
            Assert.AreEqual(1, d[key]);
            Assert.AreEqual(1, d.x);
        }
        public void TryGetValueTest()
        {
            var    d   = new DynamicPageDataDictionary <dynamic>(new PageDataDictionary <dynamic>());
            object key = "x";

            d.Add(key, 1);
            object value = null;

            Assert.IsTrue(d.TryGetValue(key, out value));
            Assert.AreEqual(1, value);
        }
        public void ContainsTest()
        {
            dynamic d    = new DynamicPageDataDictionary <dynamic>(new PageDataDictionary <dynamic>());
            var     item = new KeyValuePair <object, object>("x", 1);

            d.Add(item);
            Assert.True(d.Contains(item));
            var item2 = new KeyValuePair <object, object>("y", 2);

            Assert.False(d.Contains(item2));
        }
 public void RemoveTest1()
 {
     dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
     var item = new KeyValuePair<object, object>("x", 2);
     d.Add(item);
     Assert.True(d.Contains(item));
     d.Remove(item);
     Assert.False(d.Contains(item));
 }
 public void KeysTest()
 {
     var d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
     dynamic dyn = d;
     Assert.IsAssignableFrom<ICollection<object>>(dyn.Keys);
     d.Add("x", 1);
     d.Add("y", 2);
     Assert.True(d.Keys.Contains("x"));
     Assert.True(d.Keys.Contains("y"));
     Assert.Equal(2, d.Keys.Count);
     dyn.Keys = "foo";
     Assert.Equal("foo", dyn["Keys"]);
     Assert.Equal(3, d.Count);
 }
 public void ValuesTest()
 {
     var d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
     dynamic dyn = d;
     Assert.IsAssignableFrom<ICollection<dynamic>>(dyn.Values);
     d.Add("x", 1);
     d.Add("y", 2);
     Assert.True(d.Values.Contains(1));
     Assert.True(d.Values.Contains(2));
     Assert.Equal(2, d.Values.Count);
     dyn.Values = "foo";
     Assert.Equal("foo", dyn["Values"]);
     Assert.Equal(3, d.Count);
 }
 public void TryGetValueTest() {
     var d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
     object key = "x";
     d.Add(key, 1);
     object value = null;
     Assert.IsTrue(d.TryGetValue(key, out value));
     Assert.AreEqual(1, value);
 }
 public void CountTest() {
     var d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
     d.Add("x", 1);
     Assert.AreEqual(1, d.Count);
     d.Add("y", 2);
     Assert.AreEqual(2, d.Count);
 }
 public void ItemTest() {
     var d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
     d.Add("x", 1);
     d.Add("y", 2);
     Assert.AreEqual(1, d["x"]);
     Assert.AreEqual(2, d["y"]);
 }
 public void ValuesTest() {
     var d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
     d.Add("x", 1);
     d.Add("y", 2);
     Assert.IsTrue(d.Values.Contains(1));
     Assert.IsTrue(d.Values.Contains(2));
     Assert.AreEqual(2, d.Values.Count);
 }
 public void RemoveTest() {
     var d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
     var key = "x";
     d.Add(key, 1);
     d.Remove(key);
     Assert.IsFalse(d.ContainsKey(key));
 }
 public void CountTest()
 {
     var d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
     dynamic dyn = d;
     Assert.IsType<int>(dyn.Count);
     d.Add("x", 1);
     Assert.Equal(1, d.Count);
     d.Add("y", 2);
     Assert.Equal(2, d.Count);
     dyn.Count = "foo";
     Assert.Equal("foo", d["Count"]);
     Assert.Equal(3, d.Count);
 }