More testing

Tests/Realm.Tests/Database/RealmValueWithCollections.cs

@@ -280,6 +280,61 @@ public void List_AfterCreation_CanBeReassigned([Values(true, false)] bool isMana
             Assert.AreEqual(updatedList.AsList().Count, actual.Count);
         }
 
+        [Test]
+        public void List_AfterCreation_EmbeddedListCanBeReassigned([Values(true, false)] bool isManaged)
+        {
+            var embeddedList = new List<RealmValue>{ new List<RealmValue>{1, 2, 3}};
+            var rvo = new RealmValueObject { RealmValueProperty = new List<RealmValue>{ embeddedList} };
+
+            if (isManaged)
+            {
+                _realm.Write(() =>
+                {
+                    _realm.Add(rvo);
+                });
+            }
+
+            var actualEmbedded = rvo.RealmValueProperty.AsList()[0].AsList();
+            Assert.AreEqual(embeddedList.Count, actualEmbedded.Count);
+
+            var updatedList = (RealmValue)new List<RealmValue>{4, 5, 6};
+            _realm.Write(() =>
+            {
+                rvo.RealmValueProperty.AsList()[0] = updatedList;
+            });
+
+            actualEmbedded = rvo.RealmValueProperty.AsList()[0].AsList();
+            Assert.AreEqual(updatedList.AsList().Count, actualEmbedded.Count);
+        }
+
+        [Test]
+        public void List_AfterCreation_EmbeddedDictionaryCanBeReassigned([Values(true, false)] bool isManaged)
+        {
+            var embeddedDictionary = new Dictionary<string, RealmValue>{{ "key1", 1}};
+            var rvo = new RealmValueObject { RealmValueProperty = new List<RealmValue>{ embeddedDictionary} };
+
+            if (isManaged)
+            {
+                _realm.Write(() =>
+                {
+                    _realm.Add(rvo);
+                });
+            }
+
+            var actualEmbedded = rvo.RealmValueProperty.AsList()[0].AsDictionary();
+            Assert.AreEqual(embeddedDictionary.Count, actualEmbedded.Count);
+
+            var updatedDictionary = new Dictionary<string, RealmValue>{{ "key2", 2}};
+            _realm.Write(() =>
+            {
+                rvo.RealmValueProperty.AsList()[0] = updatedDictionary;
+            });
+
+            actualEmbedded = rvo.RealmValueProperty.AsList()[0].AsDictionary();
+            Assert.AreEqual(updatedDictionary.Count, actualEmbedded.Count);
+        }
+
+
         [Test]
         public void List_WhenManaged_CanBeModified()
         {
@@ -678,6 +733,88 @@ public void Dictionary_AfterCreation_CanBeAssigned([Values(true, false)] bool is
             Assert.That(rvo.RealmValueProperty == newStringVal);
         }
 
+        [Test]
+        public void Dictionary_AfterCreation_CanBeReassigned([Values(true, false)] bool isManaged)
+        {
+            var initialDictionary = (RealmValue) new Dictionary<string, RealmValue> { {"key1" , 1 } };
+            var rvo = new RealmValueObject { RealmValueProperty = initialDictionary };
+
+            if (isManaged)
+            {
+                _realm.Write(() =>
+                {
+                    _realm.Add(rvo);
+                });
+            }
+
+            var actual = rvo.RealmValueProperty.AsDictionary();
+            Assert.AreEqual(initialDictionary.AsDictionary().Count, actual.Count);
+
+            var updatedDictionary = (RealmValue) new Dictionary<string, RealmValue> { {"key2" , 2 } };
+            _realm.Write(() =>
+            {
+                rvo.RealmValueProperty = updatedDictionary;
+            });
+
+            actual = rvo.RealmValueProperty.AsDictionary();
+            Assert.AreEqual(updatedDictionary.AsDictionary().Count, actual.Count);
+        }
+
+        [Test]
+        public void Dictionary_AfterCreation_EmbeddedListCanBeReassigned([Values(true, false)] bool isManaged)
+        {
+            var embeddedList = new List<RealmValue>{ new List<RealmValue>{1, 2, 3}};
+            var rvo = new RealmValueObject { RealmValueProperty = new Dictionary<string, RealmValue>{ { "key", embeddedList}} };
+
+            if (isManaged)
+            {
+                _realm.Write(() =>
+                {
+                    _realm.Add(rvo);
+                });
+            }
+
+            var actualEmbedded = rvo.RealmValueProperty.AsDictionary()["key"].AsList();
+            Assert.AreEqual(embeddedList.Count, actualEmbedded.Count);
+
+            var updatedList = (RealmValue)new List<RealmValue>{4, 5, 6};
+            _realm.Write(() =>
+            {
+                rvo.RealmValueProperty.AsDictionary()["key"] = updatedList;
+            });
+
+            actualEmbedded = rvo.RealmValueProperty.AsDictionary()["key"].AsList();
+            Assert.AreEqual(updatedList.AsList().Count, actualEmbedded.Count);
+        }
+
+        [Test]
+        public void Dict_AfterCreation_EmbeddedDictionaryCanBeReassigned([Values(true, false)] bool isManaged)
+        {
+            var embeddedDictionary = new Dictionary<string, RealmValue>{{ "key1", 1}};
+            var rvo = new RealmValueObject { RealmValueProperty = new Dictionary<string, RealmValue>{ { "key", embeddedDictionary} } };
+
+            if (isManaged)
+            {
+                _realm.Write(() =>
+                {
+                    _realm.Add(rvo);
+                });
+            }
+
+            var actualEmbedded = rvo.RealmValueProperty.AsDictionary()["key"].AsDictionary();
+            Assert.AreEqual(embeddedDictionary.Count, actualEmbedded.Count);
+
+            var updatedDictionary = new Dictionary<string, RealmValue>{{ "key2", 2}};
+            _realm.Write(() =>
+            {
+                rvo.RealmValueProperty.AsDictionary()["key"] = updatedDictionary;
+            });
+
+            actualEmbedded = rvo.RealmValueProperty.AsDictionary()["key"].AsDictionary();
+            Assert.AreEqual(updatedDictionary.Count, actualEmbedded.Count);
+        }
+
+
         [Test]
         public void Dictionary_WhenManaged_CanBeModified()
         {
@@ -985,7 +1122,7 @@ public void IndexedRealmValue_WithCollection_BasicTest()
 
         #endregion
 
-        private class RealmValueComparer : IEqualityComparer<RealmValue>
+        internal class RealmValueComparer : IEqualityComparer<RealmValue>
         {
             public bool Equals(RealmValue x, RealmValue y)
             {