From 7aae3581fb071459ddd8c0c82c79f129ab172779 Mon Sep 17 00:00:00 2001 From: Ferdinando Papale <4850119+papafe@users.noreply.github.com> Date: Wed, 17 Apr 2024 12:11:01 +0200 Subject: [PATCH] Hide collections in mixed from public API (#3575) * Hide collections in mixed from public API * Hiding other methods --- CHANGELOG.md | 13 - Realm/Realm/DatabaseTypes/RealmValue.cs | 48 +- .../Database/RealmValueWithCollections.cs | 2260 ++++++++--------- .../Sync/DataTypeSynchronizationTests.cs | 816 +++--- 4 files changed, 1562 insertions(+), 1575 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index cac847264a..24e18e1887 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,19 +12,6 @@ * Opening realm with file format 23 or lower (Realm .NET versions earlier than 12.0.0) in read-only mode will crash. (Core 14.0.0) ### Enhancements -* Added support for list and dictionaries of `RealmValue` (`IList` and `IDictionary`) to be contained in a `RealmValue`. Lists and dictionaries can contain an arbitrary number of collections themselves. It is possible to convert an existing collection to a `RealmValue` using the new static methods `RealmValue.List` and `RealmValue.Dictionary` or using the implicit operators if converting from common types like `List`, `RealmValue[]` or `Dictionary`. Finally, it is possible to obtain the contained collections by using the new conversion method `AsList` and `AsDictionary`. For example: - - ```csharp - var list = new List { 1, true, "stringVal" }; - - var rvo = realm.Write(() => - { - return realm.Add(new RealmValueObject { RealmValueProperty = list}); - }); - - var retrievedList = rvo.RealmValueProperty.AsList(); - ``` - (PR [#3441](https://github.com/realm/realm-dotnet/pull/3441)) * Reduced memory usage of `RealmValue`. (PR [#3441](https://github.com/realm/realm-dotnet/pull/3441)) * Add support for passing a key paths collection (`KeyPathsCollection`) when using `IRealmCollection.SubscribeForNotifications`. Passing a `KeyPathsCollection` allows to specify which changes in properties should raise a notification. diff --git a/Realm/Realm/DatabaseTypes/RealmValue.cs b/Realm/Realm/DatabaseTypes/RealmValue.cs index f94deaefee..b4a5b2f1d1 100644 --- a/Realm/Realm/DatabaseTypes/RealmValue.cs +++ b/Realm/Realm/DatabaseTypes/RealmValue.cs @@ -217,7 +217,7 @@ private RealmValue(IDictionary dict) : this() /// A new RealmValue representing the input list. /// Once created, this RealmValue will just wrap the input collection. /// After the object containing this RealmValue gets managed this value will be a Realm list. - public static RealmValue List(IList value) => new(value); + internal static RealmValue List(IList value) => new(value); /// /// Gets a RealmValue representing a dictionary. @@ -226,7 +226,7 @@ private RealmValue(IDictionary dict) : this() /// A new RealmValue representing the input dictionary. /// Once created, this RealmValue will just wrap the input collection. /// After the object containing this RealmValue gets managed this value will be a Realm dictionary. - public static RealmValue Dictionary(IDictionary value) => new(value); + internal static RealmValue Dictionary(IDictionary value) => new(value); internal static RealmValue Create(T value, RealmValueType type) { @@ -510,7 +510,7 @@ public string AsString() /// /// Thrown if the underlying value is not of type . /// A list representing the value stored in the database. - public IList AsList() + internal IList AsList() { EnsureType("List", RealmValueType.List); return _listValue!; @@ -521,7 +521,7 @@ public IList AsList() /// /// Thrown if the underlying value is not of type . /// A dictionary representing the value stored in the database. - public IDictionary AsDictionary() + internal IDictionary AsDictionary() { EnsureType("Dictionary", RealmValueType.Dictionary); return _dictionaryValue!; @@ -1448,26 +1448,26 @@ public override int GetHashCode() /// A containing the supplied . public static implicit operator RealmValue(RealmObjectBase? val) => val == null ? Null : Object(val); - /// - /// Implicitly constructs a from List<RealmValue>?. - /// - /// The value to store in the . - /// A containing the supplied . - public static implicit operator RealmValue(List? val) => val == null ? Null : List(val); - - /// - /// Implicitly constructs a from RealmValue[]?. - /// - /// The value to store in the . - /// A containing the supplied . - public static implicit operator RealmValue(RealmValue[]? val) => val == null ? Null : List(val); - - /// - /// Implicitly constructs a from Dictionary<string, RealmValue>. - /// - /// The value to store in the . - /// A containing the supplied . - public static implicit operator RealmValue(Dictionary? val) => val == null ? Null : Dictionary(val); + ///// + ///// Implicitly constructs a from List<RealmValue>?. + ///// + ///// The value to store in the . + ///// A containing the supplied . + //public static implicit operator RealmValue(List? val) => val == null ? Null : List(val); + + ///// + ///// Implicitly constructs a from RealmValue[]?. + ///// + ///// The value to store in the . + ///// A containing the supplied . + //public static implicit operator RealmValue(RealmValue[]? val) => val == null ? Null : List(val); + + ///// + ///// Implicitly constructs a from Dictionary<string, RealmValue>. + ///// + ///// The value to store in the . + ///// A containing the supplied . + //public static implicit operator RealmValue(Dictionary? val) => val == null ? Null : Dictionary(val); private void EnsureType(string target, RealmValueType type) { diff --git a/Tests/Realm.Tests/Database/RealmValueWithCollections.cs b/Tests/Realm.Tests/Database/RealmValueWithCollections.cs index 436746b165..8f9381d289 100644 --- a/Tests/Realm.Tests/Database/RealmValueWithCollections.cs +++ b/Tests/Realm.Tests/Database/RealmValueWithCollections.cs @@ -24,1154 +24,1154 @@ namespace Realms.Tests.Database { - [TestFixture, Preserve(AllMembers = true)] + //[TestFixture, Preserve(AllMembers = true)] internal class RealmValueWithCollections : RealmInstanceTest { - private readonly RealmValueComparer _rvComparer = new(); +// private readonly RealmValueComparer _rvComparer = new(); + +// public static Func> ListGenerator = i => new List { $"inner{i}", i }; +// public static Func> DictGenerator = i => new Dictionary { { "s1", i }, { "s2", $"ah{i}" } }; + +// public static Func[] CollectionGenerators = new Func[] +// { +// i => (RealmValue)ListGenerator(i), +// i => (RealmValue)DictGenerator(i), +// }; + +// private RealmValueObject PersistAndFind(RealmValue rv) +// { +// _realm.Write(() => +// { +// _realm.Add(new RealmValueObject { RealmValueProperty = rv }); +// }); + +// return _realm.All().First(); +// } + +// #region List + +// [Test] +// public void List_WhenRetrieved_WorksWithAllTypes([Values(true, false)] bool isManaged) +// { +// var innerList = ListGenerator(1); +// var innerDict = DictGenerator(1); + +// var originalList = new List +// { +// RealmValue.Null, +// 1, +// true, +// "string", +// new byte[] { 0, 1, 2 }, +// new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero), +// 1f, +// 2d, +// 3m, +// new ObjectId("5f63e882536de46d71877979"), +// Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31"), +// new InternalObject { IntProperty = 10, StringProperty = "brown" }, +// innerList, +// innerDict, +// }; + +// RealmValue rv = originalList; + +// if (isManaged) +// { +// rv = PersistAndFind(rv).RealmValueProperty; +// } + +// Assert.That(rv.Type, Is.EqualTo(RealmValueType.List)); +// Assert.That(rv != RealmValue.Null); + +// Assert.That(rv.AsList(), Is.EqualTo(originalList).Using(_rvComparer)); +// Assert.That(rv.AsAny(), Is.EqualTo(originalList).Using(_rvComparer)); +// Assert.That(rv.As>(), Is.EqualTo(originalList).Using(_rvComparer)); +// } + +// [Test] +// public void List_InRealmValue_Equality([Values(true, false)] bool isManaged) +// { +// var innerList = ListGenerator(1); +// var innerDict = DictGenerator(1); + +// var originalList = new List +// { +// RealmValue.Null, +// 1, +// true, +// "string", +// new byte[] { 0, 1, 2 }, +// new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero), +// 1f, +// 2d, +// 3m, +// new ObjectId("5f63e882536de46d71877979"), +// Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31"), +// new InternalObject { IntProperty = 10, StringProperty = "brown" }, +// innerList, +// innerDict, +// }; + +// var copyOriginalList = new List +// { +// RealmValue.Null, +// 1, +// true, +// "string", +// new byte[] { 0, 1, 2 }, +// new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero), +// 1f, +// 2d, +// 3m, +// new ObjectId("5f63e882536de46d71877979"), +// Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31"), +// new InternalObject { IntProperty = 10, StringProperty = "brown" }, +// innerList, +// innerDict, +// }; + +// RealmValue rv = originalList; +// RealmValue rv2 = copyOriginalList; + +// if (isManaged) +// { +// rv = PersistAndFind(rv).RealmValueProperty; +// } + +//#pragma warning disable CS1718 // Comparison made to same variable +// Assert.That(rv == rv, Is.True); +//#pragma warning restore CS1718 // Comparison made to same variable +// Assert.That(rv.Equals(rv), Is.True); + +// // They contains the same values, but the collections do not point to the same object reference +// Assert.That(rv == rv2, Is.False); +// Assert.That(rv.Equals(rv2), Is.False); + +// // If the object is unmanaged, the RealmValue just wraps the collection +// Assert.That(rv == originalList, isManaged ? Is.False : Is.True); +// Assert.That(rv.Equals(originalList), isManaged ? Is.False : Is.True); +// } + +// [Test] +// public void List_WhenUsingIndexAccessWithCollections_WorkAsExpected([Values(true, false)] bool isManaged) +// { +// var innerList = ListGenerator(1); +// var innerDict = DictGenerator(1); + +// var originalList = new List +// { +// innerList, +// innerDict, +// }; + +// RealmValue rv = originalList; + +// if (isManaged) +// { +// rv = PersistAndFind(rv).RealmValueProperty; +// } + +// var retrievedList = rv.AsList()[0]; +// var retrievedDict = rv.AsList()[1]; + +// Assert.That(retrievedList.AsList(), Is.EqualTo(innerList)); +// Assert.That(retrievedDict.AsDictionary(), Is.EquivalentTo(innerDict)); +// } + +// [Test] +// public void List_CanBeCopiedFromManagedList([Values(true, false)] bool isManaged) +// { +// var originalList = ListGenerator(1); + +// RealmValue rv = originalList; + +// if (isManaged) +// { +// rv = PersistAndFind(originalList).RealmValueProperty; +// } + +// var newObj = new RealmValueObject { RealmValueProperty = rv }; + +// var rv2 = isManaged ? PersistAndFind(rv).RealmValueProperty : newObj.RealmValueProperty; + +// Assert.That(rv.AsList(), Is.EqualTo(rv2.AsList())); +// Assert.That(rv.AsList(), Is.EqualTo(originalList)); +// Assert.That(rv2.AsList(), Is.EqualTo(originalList)); +// } + +// [Test] +// public void List_BuiltWithConstructorMethodOrOperatorOrCreateOrArray_WorksTheSame([Values(true, false)] bool isManaged) +// { +// var originalList = ListGenerator(1); + +// RealmValue rvOperator = originalList; +// RealmValue rvConstructor = RealmValue.List(originalList); +// RealmValue rvCreate = RealmValue.Create(originalList, RealmValueType.List); +// RealmValue rvArray = originalList.ToArray(); + +// if (isManaged) +// { +// rvOperator = PersistAndFind(rvOperator).RealmValueProperty; +// rvConstructor = PersistAndFind(rvConstructor).RealmValueProperty; +// rvCreate = PersistAndFind(rvCreate).RealmValueProperty; +// rvArray = PersistAndFind(rvCreate).RealmValueProperty; +// } + +// Assert.That(rvOperator.AsList(), Is.EqualTo(originalList)); +// Assert.That(rvConstructor.AsList(), Is.EqualTo(originalList)); +// Assert.That(rvCreate.AsList(), Is.EqualTo(originalList)); +// Assert.That(rvArray.AsList(), Is.EqualTo(originalList)); +// } + +// [Test] +// public void List_WhenManaged_IsNotSameReferenceAsOriginalList() +// { +// var originalList = ListGenerator(1); + +// RealmValue rv = originalList; +// rv = PersistAndFind(rv).RealmValueProperty; +// var retrievedList = rv.AsList(); + +// Assert.That(ReferenceEquals(originalList, retrievedList), Is.False); +// } + +// [Test] +// public void List_WhenUnmanaged_IsSameReferenceAsOriginalList() +// { +// var originalList = ListGenerator(1); + +// RealmValue rv = originalList; +// var retrievedList = rv.AsList(); + +// Assert.That(ReferenceEquals(originalList, retrievedList), Is.True); +// } + +// [Test] +// public void List_AfterCreation_CanBeAssigned([Values(true, false)] bool isManaged) +// { +// var stringVal = "Mario"; +// var rvo = new RealmValueObject { RealmValueProperty = stringVal }; + +// if (isManaged) +// { +// _realm.Write(() => +// { +// _realm.Add(rvo); +// }); +// } + +// Assert.That(rvo.RealmValueProperty == stringVal); + +// var listVal = ListGenerator(1); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty = listVal; +// }); + +// Assert.That(rvo.RealmValueProperty.AsList(), Is.EqualTo(listVal)); + +// var newStringVal = "Luigi"; + +// _realm.Write(() => +// { +// rvo.RealmValueProperty = newStringVal; +// }); + +// Assert.That(rvo.RealmValueProperty == newStringVal); +// } + +// [Test] +// public void List_AfterCreation_CanBeReassigned([Values(true, false)] bool isManaged) +// { +// var initialList = (RealmValue)new List { 1, 2, 3 }; +// var rvo = new RealmValueObject { RealmValueProperty = initialList }; + +// if (isManaged) +// { +// _realm.Write(() => +// { +// _realm.Add(rvo); +// }); +// } + +// var actualList = rvo.RealmValueProperty; +// Assert.That(initialList, Is.EqualTo(actualList).Using(_rvComparer)); + +// var updatedList = (RealmValue)new List { 4, 5 }; +// _realm.Write(() => +// { +// rvo.RealmValueProperty = updatedList; +// }); + +// actualList = rvo.RealmValueProperty; +// Assert.That(updatedList, Is.EqualTo(actualList).Using(_rvComparer)); +// } + +// [Test] +// public void List_AfterCreation_EmbeddedListCanBeReassigned([Values(true, false)] bool isManaged) +// { +// var initialList = (RealmValue)new List { new List { 1, 2, 3 } }; +// var rvo = new RealmValueObject { RealmValueProperty = new List { initialList } }; + +// if (isManaged) +// { +// _realm.Write(() => +// { +// _realm.Add(rvo); +// }); +// } + +// var actualEmbeddedList = rvo.RealmValueProperty.AsList()[0]; +// Assert.That(initialList, Is.EqualTo(actualEmbeddedList).Using(_rvComparer)); + +// var updatedList = (RealmValue)new List { 4, 5, 6 }; +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsList()[0] = updatedList; +// }); + +// actualEmbeddedList = rvo.RealmValueProperty.AsList()[0]; +// Assert.That(updatedList, Is.EqualTo(actualEmbeddedList).Using(_rvComparer)); +// } + +// [Test] +// public void List_AfterCreation_EmbeddedDictionaryCanBeReassigned([Values(true, false)] bool isManaged) +// { +// var initialDictionary = (RealmValue)new Dictionary { { "key1", 1 } }; +// var rvo = new RealmValueObject { RealmValueProperty = new List { initialDictionary } }; + +// if (isManaged) +// { +// _realm.Write(() => +// { +// _realm.Add(rvo); +// }); +// } + +// var actualDictionary = rvo.RealmValueProperty.AsList()[0]; +// Assert.That(initialDictionary, Is.EqualTo(actualDictionary).Using(_rvComparer)); + +// var updatedDictionary = (RealmValue)new Dictionary { { "key2", 2 } }; +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsList()[0] = updatedDictionary; +// }); + +// actualDictionary = rvo.RealmValueProperty.AsList()[0]; +// Assert.That(updatedDictionary, Is.EqualTo(actualDictionary).Using(_rvComparer)); +// } + +// [Test] +// public void List_WhenManaged_CanBeModified() +// { +// var listVal = new List { 1, "string", true }; + +// var rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = listVal })); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsList()[1] = "Mario"; +// listVal[1] = "Mario"; // To keep both list updated +// }); + +// Assert.That(rvo.RealmValueProperty.AsList(), Is.EqualTo(listVal)); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsList().RemoveAt(2); +// listVal.RemoveAt(2); +// }); + +// Assert.That(rvo.RealmValueProperty.AsList(), Is.EqualTo(listVal)); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsList().Add("newVal"); +// listVal.Add("newVal"); +// }); + +// Assert.That(rvo.RealmValueProperty.AsList(), Is.EqualTo(listVal).Using(_rvComparer)); +// } + +// [TestCaseSource(nameof(CollectionGenerators))] +// public void List_AddSetInsertMoveRemoveCollection_WorksAsIntended(Func collectionGenerator) +// { +// var listVal = new List { 1, "string", true }; + +// var rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = listVal })); + +// // Indexer +// var c1 = collectionGenerator(1); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsList()[1] = c1; +// listVal[1] = c1; +// }); + +// Assert.That(rvo.RealmValueProperty.AsList(), Is.EqualTo(listVal).Using(_rvComparer)); + +// // Insert +// var c2 = collectionGenerator(2); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsList().Insert(1, c2); +// listVal.Insert(1, c2); +// }); + +// Assert.That(rvo.RealmValueProperty.AsList(), Is.EqualTo(listVal).Using(_rvComparer)); + +// // Add +// var c3 = collectionGenerator(3); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsList().Add(c3); +// listVal.Add(c3); +// }); + +// Assert.That(rvo.RealmValueProperty.AsList(), Is.EqualTo(listVal).Using(_rvComparer)); + +// // Move +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsList().Move(0, 1); +// listVal.Move(0, 1); +// }); + +// Assert.That(rvo.RealmValueProperty.AsList(), Is.EqualTo(listVal).Using(_rvComparer)); + +// // Remove +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsList().RemoveAt(2); +// listVal.RemoveAt(2); +// }); + +// Assert.That(rvo.RealmValueProperty.AsList(), Is.EqualTo(listVal).Using(_rvComparer)); +// } + +// [Test] +// public void List_RemoveWithCollectionArgument_ReturnsFalse() +// { +// var innerList = new List { "inner2", true, 2.0 }; +// var innerDict = new Dictionary +// { +// { "s1", 1 }, +// { "s2", "ah" }, +// { "s3", true }, +// }; - public static Func> ListGenerator = i => new List { $"inner{i}", i }; - public static Func> DictGenerator = i => new Dictionary { { "s1", i }, { "s2", $"ah{i}" } }; +// var listVal = new List { innerList, innerDict }; - public static Func[] CollectionGenerators = new Func[] - { - i => (RealmValue)ListGenerator(i), - i => (RealmValue)DictGenerator(i), - }; - - private RealmValueObject PersistAndFind(RealmValue rv) - { - _realm.Write(() => - { - _realm.Add(new RealmValueObject { RealmValueProperty = rv }); - }); - - return _realm.All().First(); - } - - #region List - - [Test] - public void List_WhenRetrieved_WorksWithAllTypes([Values(true, false)] bool isManaged) - { - var innerList = ListGenerator(1); - var innerDict = DictGenerator(1); - - var originalList = new List - { - RealmValue.Null, - 1, - true, - "string", - new byte[] { 0, 1, 2 }, - new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero), - 1f, - 2d, - 3m, - new ObjectId("5f63e882536de46d71877979"), - Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31"), - new InternalObject { IntProperty = 10, StringProperty = "brown" }, - innerList, - innerDict, - }; - - RealmValue rv = originalList; - - if (isManaged) - { - rv = PersistAndFind(rv).RealmValueProperty; - } - - Assert.That(rv.Type, Is.EqualTo(RealmValueType.List)); - Assert.That(rv != RealmValue.Null); - - Assert.That(rv.AsList(), Is.EqualTo(originalList).Using(_rvComparer)); - Assert.That(rv.AsAny(), Is.EqualTo(originalList).Using(_rvComparer)); - Assert.That(rv.As>(), Is.EqualTo(originalList).Using(_rvComparer)); - } - - [Test] - public void List_InRealmValue_Equality([Values(true, false)] bool isManaged) - { - var innerList = ListGenerator(1); - var innerDict = DictGenerator(1); - - var originalList = new List - { - RealmValue.Null, - 1, - true, - "string", - new byte[] { 0, 1, 2 }, - new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero), - 1f, - 2d, - 3m, - new ObjectId("5f63e882536de46d71877979"), - Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31"), - new InternalObject { IntProperty = 10, StringProperty = "brown" }, - innerList, - innerDict, - }; - - var copyOriginalList = new List - { - RealmValue.Null, - 1, - true, - "string", - new byte[] { 0, 1, 2 }, - new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero), - 1f, - 2d, - 3m, - new ObjectId("5f63e882536de46d71877979"), - Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31"), - new InternalObject { IntProperty = 10, StringProperty = "brown" }, - innerList, - innerDict, - }; - - RealmValue rv = originalList; - RealmValue rv2 = copyOriginalList; - - if (isManaged) - { - rv = PersistAndFind(rv).RealmValueProperty; - } - -#pragma warning disable CS1718 // Comparison made to same variable - Assert.That(rv == rv, Is.True); -#pragma warning restore CS1718 // Comparison made to same variable - Assert.That(rv.Equals(rv), Is.True); - - // They contains the same values, but the collections do not point to the same object reference - Assert.That(rv == rv2, Is.False); - Assert.That(rv.Equals(rv2), Is.False); - - // If the object is unmanaged, the RealmValue just wraps the collection - Assert.That(rv == originalList, isManaged ? Is.False : Is.True); - Assert.That(rv.Equals(originalList), isManaged ? Is.False : Is.True); - } - - [Test] - public void List_WhenUsingIndexAccessWithCollections_WorkAsExpected([Values(true, false)] bool isManaged) - { - var innerList = ListGenerator(1); - var innerDict = DictGenerator(1); - - var originalList = new List - { - innerList, - innerDict, - }; - - RealmValue rv = originalList; - - if (isManaged) - { - rv = PersistAndFind(rv).RealmValueProperty; - } - - var retrievedList = rv.AsList()[0]; - var retrievedDict = rv.AsList()[1]; - - Assert.That(retrievedList.AsList(), Is.EqualTo(innerList)); - Assert.That(retrievedDict.AsDictionary(), Is.EquivalentTo(innerDict)); - } - - [Test] - public void List_CanBeCopiedFromManagedList([Values(true, false)] bool isManaged) - { - var originalList = ListGenerator(1); - - RealmValue rv = originalList; - - if (isManaged) - { - rv = PersistAndFind(originalList).RealmValueProperty; - } - - var newObj = new RealmValueObject { RealmValueProperty = rv }; - - var rv2 = isManaged ? PersistAndFind(rv).RealmValueProperty : newObj.RealmValueProperty; - - Assert.That(rv.AsList(), Is.EqualTo(rv2.AsList())); - Assert.That(rv.AsList(), Is.EqualTo(originalList)); - Assert.That(rv2.AsList(), Is.EqualTo(originalList)); - } - - [Test] - public void List_BuiltWithConstructorMethodOrOperatorOrCreateOrArray_WorksTheSame([Values(true, false)] bool isManaged) - { - var originalList = ListGenerator(1); - - RealmValue rvOperator = originalList; - RealmValue rvConstructor = RealmValue.List(originalList); - RealmValue rvCreate = RealmValue.Create(originalList, RealmValueType.List); - RealmValue rvArray = originalList.ToArray(); - - if (isManaged) - { - rvOperator = PersistAndFind(rvOperator).RealmValueProperty; - rvConstructor = PersistAndFind(rvConstructor).RealmValueProperty; - rvCreate = PersistAndFind(rvCreate).RealmValueProperty; - rvArray = PersistAndFind(rvCreate).RealmValueProperty; - } - - Assert.That(rvOperator.AsList(), Is.EqualTo(originalList)); - Assert.That(rvConstructor.AsList(), Is.EqualTo(originalList)); - Assert.That(rvCreate.AsList(), Is.EqualTo(originalList)); - Assert.That(rvArray.AsList(), Is.EqualTo(originalList)); - } - - [Test] - public void List_WhenManaged_IsNotSameReferenceAsOriginalList() - { - var originalList = ListGenerator(1); - - RealmValue rv = originalList; - rv = PersistAndFind(rv).RealmValueProperty; - var retrievedList = rv.AsList(); - - Assert.That(ReferenceEquals(originalList, retrievedList), Is.False); - } - - [Test] - public void List_WhenUnmanaged_IsSameReferenceAsOriginalList() - { - var originalList = ListGenerator(1); - - RealmValue rv = originalList; - var retrievedList = rv.AsList(); - - Assert.That(ReferenceEquals(originalList, retrievedList), Is.True); - } - - [Test] - public void List_AfterCreation_CanBeAssigned([Values(true, false)] bool isManaged) - { - var stringVal = "Mario"; - var rvo = new RealmValueObject { RealmValueProperty = stringVal }; - - if (isManaged) - { - _realm.Write(() => - { - _realm.Add(rvo); - }); - } - - Assert.That(rvo.RealmValueProperty == stringVal); - - var listVal = ListGenerator(1); - - _realm.Write(() => - { - rvo.RealmValueProperty = listVal; - }); - - Assert.That(rvo.RealmValueProperty.AsList(), Is.EqualTo(listVal)); - - var newStringVal = "Luigi"; - - _realm.Write(() => - { - rvo.RealmValueProperty = newStringVal; - }); - - Assert.That(rvo.RealmValueProperty == newStringVal); - } - - [Test] - public void List_AfterCreation_CanBeReassigned([Values(true, false)] bool isManaged) - { - var initialList = (RealmValue)new List { 1, 2, 3 }; - var rvo = new RealmValueObject { RealmValueProperty = initialList }; - - if (isManaged) - { - _realm.Write(() => - { - _realm.Add(rvo); - }); - } - - var actualList = rvo.RealmValueProperty; - Assert.That(initialList, Is.EqualTo(actualList).Using(_rvComparer)); - - var updatedList = (RealmValue)new List { 4, 5 }; - _realm.Write(() => - { - rvo.RealmValueProperty = updatedList; - }); - - actualList = rvo.RealmValueProperty; - Assert.That(updatedList, Is.EqualTo(actualList).Using(_rvComparer)); - } - - [Test] - public void List_AfterCreation_EmbeddedListCanBeReassigned([Values(true, false)] bool isManaged) - { - var initialList = (RealmValue)new List { new List { 1, 2, 3 } }; - var rvo = new RealmValueObject { RealmValueProperty = new List { initialList } }; - - if (isManaged) - { - _realm.Write(() => - { - _realm.Add(rvo); - }); - } - - var actualEmbeddedList = rvo.RealmValueProperty.AsList()[0]; - Assert.That(initialList, Is.EqualTo(actualEmbeddedList).Using(_rvComparer)); +// var rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = listVal })); - var updatedList = (RealmValue)new List { 4, 5, 6 }; - _realm.Write(() => - { - rvo.RealmValueProperty.AsList()[0] = updatedList; - }); - - actualEmbeddedList = rvo.RealmValueProperty.AsList()[0]; - Assert.That(updatedList, Is.EqualTo(actualEmbeddedList).Using(_rvComparer)); - } - - [Test] - public void List_AfterCreation_EmbeddedDictionaryCanBeReassigned([Values(true, false)] bool isManaged) - { - var initialDictionary = (RealmValue)new Dictionary { { "key1", 1 } }; - var rvo = new RealmValueObject { RealmValueProperty = new List { initialDictionary } }; - - if (isManaged) - { - _realm.Write(() => - { - _realm.Add(rvo); - }); - } - - var actualDictionary = rvo.RealmValueProperty.AsList()[0]; - Assert.That(initialDictionary, Is.EqualTo(actualDictionary).Using(_rvComparer)); - - var updatedDictionary = (RealmValue)new Dictionary { { "key2", 2 } }; - _realm.Write(() => - { - rvo.RealmValueProperty.AsList()[0] = updatedDictionary; - }); - - actualDictionary = rvo.RealmValueProperty.AsList()[0]; - Assert.That(updatedDictionary, Is.EqualTo(actualDictionary).Using(_rvComparer)); - } - - [Test] - public void List_WhenManaged_CanBeModified() - { - var listVal = new List { 1, "string", true }; - - var rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = listVal })); - - _realm.Write(() => - { - rvo.RealmValueProperty.AsList()[1] = "Mario"; - listVal[1] = "Mario"; // To keep both list updated - }); - - Assert.That(rvo.RealmValueProperty.AsList(), Is.EqualTo(listVal)); - - _realm.Write(() => - { - rvo.RealmValueProperty.AsList().RemoveAt(2); - listVal.RemoveAt(2); - }); - - Assert.That(rvo.RealmValueProperty.AsList(), Is.EqualTo(listVal)); - - _realm.Write(() => - { - rvo.RealmValueProperty.AsList().Add("newVal"); - listVal.Add("newVal"); - }); - - Assert.That(rvo.RealmValueProperty.AsList(), Is.EqualTo(listVal).Using(_rvComparer)); - } - - [TestCaseSource(nameof(CollectionGenerators))] - public void List_AddSetInsertMoveRemoveCollection_WorksAsIntended(Func collectionGenerator) - { - var listVal = new List { 1, "string", true }; - - var rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = listVal })); - - // Indexer - var c1 = collectionGenerator(1); - - _realm.Write(() => - { - rvo.RealmValueProperty.AsList()[1] = c1; - listVal[1] = c1; - }); - - Assert.That(rvo.RealmValueProperty.AsList(), Is.EqualTo(listVal).Using(_rvComparer)); - - // Insert - var c2 = collectionGenerator(2); - - _realm.Write(() => - { - rvo.RealmValueProperty.AsList().Insert(1, c2); - listVal.Insert(1, c2); - }); - - Assert.That(rvo.RealmValueProperty.AsList(), Is.EqualTo(listVal).Using(_rvComparer)); - - // Add - var c3 = collectionGenerator(3); - - _realm.Write(() => - { - rvo.RealmValueProperty.AsList().Add(c3); - listVal.Add(c3); - }); - - Assert.That(rvo.RealmValueProperty.AsList(), Is.EqualTo(listVal).Using(_rvComparer)); - - // Move - _realm.Write(() => - { - rvo.RealmValueProperty.AsList().Move(0, 1); - listVal.Move(0, 1); - }); - - Assert.That(rvo.RealmValueProperty.AsList(), Is.EqualTo(listVal).Using(_rvComparer)); - - // Remove - _realm.Write(() => - { - rvo.RealmValueProperty.AsList().RemoveAt(2); - listVal.RemoveAt(2); - }); - - Assert.That(rvo.RealmValueProperty.AsList(), Is.EqualTo(listVal).Using(_rvComparer)); - } - - [Test] - public void List_RemoveWithCollectionArgument_ReturnsFalse() - { - var innerList = new List { "inner2", true, 2.0 }; - var innerDict = new Dictionary - { - { "s1", 1 }, - { "s2", "ah" }, - { "s3", true }, - }; - - var listVal = new List { innerList, innerDict }; - - var rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = listVal })); - - _realm.Write(() => - { - Assert.That(rvo.RealmValueProperty.AsList().Remove(innerList), Is.False); - Assert.That(rvo.RealmValueProperty.AsList().Remove(innerDict), Is.False); - }); - } - - [Test] - public void List_WhenManaged_WorksWithDynamicLikeApi() - { - var originalList = ListGenerator(1); - - var rvo = _realm.Write(() => _realm.Add(new RealmValueObject())); - - _realm.Write(() => - { - rvo.DynamicApi.Set(nameof(RealmValueObject.RealmValueProperty), originalList); - }); - - var rvp = rvo.DynamicApi.Get(nameof(RealmValueObject.RealmValueProperty)); - - Assert.That(rvp.AsList(), Is.EqualTo(originalList)); - } - -#if !UNITY - [Test] -#endif - public void List_WhenManaged_WorksWithDynamic() - { - var originalList = ListGenerator(1); - - dynamic rvo = _realm.Write(() => _realm.Add(new RealmValueObject())); - - _realm.Write(() => - { - rvo.RealmValueProperty = originalList; - }); - - var rvp = rvo.RealmValueProperty; - - Assert.That(rvp.AsList(), Is.EqualTo(originalList)); - } - - [Test] - public void List_WhenManaged_WorksWithNotifications() - { - var originalList = new List { 1, ListGenerator(1), DictGenerator(1) }; +// _realm.Write(() => +// { +// Assert.That(rvo.RealmValueProperty.AsList().Remove(innerList), Is.False); +// Assert.That(rvo.RealmValueProperty.AsList().Remove(innerDict), Is.False); +// }); +// } - var rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = originalList })); +// [Test] +// public void List_WhenManaged_WorksWithDynamicLikeApi() +// { +// var originalList = ListGenerator(1); + +// var rvo = _realm.Write(() => _realm.Add(new RealmValueObject())); + +// _realm.Write(() => +// { +// rvo.DynamicApi.Set(nameof(RealmValueObject.RealmValueProperty), originalList); +// }); + +// var rvp = rvo.DynamicApi.Get(nameof(RealmValueObject.RealmValueProperty)); + +// Assert.That(rvp.AsList(), Is.EqualTo(originalList)); +// } + +//#if !UNITY +// [Test] +//#endif +// public void List_WhenManaged_WorksWithDynamic() +// { +// var originalList = ListGenerator(1); + +// dynamic rvo = _realm.Write(() => _realm.Add(new RealmValueObject())); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty = originalList; +// }); + +// var rvp = rvo.RealmValueProperty; + +// Assert.That(rvp.AsList(), Is.EqualTo(originalList)); +// } + +// [Test] +// public void List_WhenManaged_WorksWithNotifications() +// { +// var originalList = new List { 1, ListGenerator(1), DictGenerator(1) }; + +// var rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = originalList })); + +// var callbacks = new List(); +// using var token = rvo.RealmValueProperty.AsList().SubscribeForNotifications((_, changes) => +// { +// if (changes != null) +// { +// callbacks.Add(changes); +// } +// }); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsList()[0] = "mario"; +// }); + +// _realm.Refresh(); +// Assert.That(callbacks.Count, Is.EqualTo(1)); +// Assert.That(callbacks[0].ModifiedIndices, Is.EqualTo(new[] { 0 })); + +// callbacks.Clear(); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsList()[1].AsList()[0] = "luigi"; +// }); + +// _realm.Refresh(); +// Assert.That(callbacks.Count, Is.EqualTo(1)); +// Assert.That(callbacks[0].ModifiedIndices, Is.EqualTo(new[] { 1 })); + +// callbacks.Clear(); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsList()[2].AsDictionary()["s1"] = "peach"; +// }); + +// _realm.Refresh(); +// Assert.That(callbacks.Count, Is.EqualTo(1)); +// Assert.That(callbacks[0].ModifiedIndices, Is.EqualTo(new[] { 2 })); + +// callbacks.Clear(); +// } + +// #endregion + +// #region Dictionary + +// [Test] +// public void Dictionary_WhenRetrieved_WorksWithAllTypes([Values(true, false)] bool isManaged) +// { +// var innerList = ListGenerator(1); +// var innerDict = DictGenerator(1); + +// var originalDict = new Dictionary +// { +// { "1", RealmValue.Null }, +// { "2", 1 }, +// { "3", true }, +// { "4", "string" }, +// { "5", new byte[] { 0, 1, 2 } }, +// { "6", new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero) }, +// { "7", 1f }, +// { "8", 2d }, +// { "9", 3m }, +// { "a", new ObjectId("5f63e882536de46d71877979") }, +// { "b", Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31") }, +// { "c", new InternalObject { IntProperty = 10, StringProperty = "brown" } }, +// { "d", innerList }, +// { "e", innerDict }, +// }; + +// RealmValue rv = originalDict; + +// if (isManaged) +// { +// rv = PersistAndFind(rv).RealmValueProperty; +// } + +// Assert.That(rv.Type, Is.EqualTo(RealmValueType.Dictionary)); +// Assert.That(rv != RealmValue.Null, "Different than null"); + +// Assert.That(rv.AsDictionary(), Is.EquivalentTo(originalDict).Using(_rvComparer)); +// Assert.That(rv.AsAny(), Is.EquivalentTo(originalDict).Using(_rvComparer)); +// Assert.That(rv.As>(), Is.EquivalentTo(originalDict).Using(_rvComparer)); +// } + +// [Test] +// public void Dictionary_InRealmValue_Equality([Values(true, false)] bool isManaged) +// { +// var innerList = ListGenerator(1); +// var innerDict = DictGenerator(1); + +// var originalDict = new Dictionary +// { +// { "c", new InternalObject { IntProperty = 10, StringProperty = "brown" } }, +// { "d", innerList }, +// { "e", innerDict }, +// }; + +// var copyOriginalDict = new Dictionary +// { +// { "c", new InternalObject { IntProperty = 10, StringProperty = "brown" } }, +// { "d", innerList }, +// { "e", innerDict }, +// }; + +// RealmValue rv = originalDict; +// RealmValue rv2 = copyOriginalDict; + +// if (isManaged) +// { +// rv = PersistAndFind(rv).RealmValueProperty; +// } + +//#pragma warning disable CS1718 // Comparison made to same variable +// Assert.That(rv == rv, Is.True); +//#pragma warning restore CS1718 // Comparison made to same variable +// Assert.That(rv.Equals(rv), Is.True); + +// // They contains the same values, but the collections do not point to the same object reference +// Assert.That(rv == rv2, Is.False); +// Assert.That(rv.Equals(rv2), Is.False); + +// // If the object is unmanaged, the RealmValue just wraps the collection +// Assert.That(rv == originalDict, isManaged ? Is.False : Is.True); +// Assert.That(rv.Equals(originalDict), isManaged ? Is.False : Is.True); +// } + +// [Test] +// public void Dictionary_WhenUsingIndexAccessWithCollections_WorkAsExpected([Values(true, false)] bool isManaged) +// { +// var innerList = ListGenerator(1); +// var innerDict = DictGenerator(1); + +// var originalDict = new Dictionary +// { +// { "0", innerList }, +// { "1", innerDict }, +// }; + +// RealmValue rv = originalDict; + +// if (isManaged) +// { +// rv = PersistAndFind(rv).RealmValueProperty; +// } + +// var retrievedList = rv.AsDictionary().ElementAt(0).Value; +// var retrievedDict = rv.AsDictionary().ElementAt(1).Value; + +// Assert.That(retrievedList.AsList(), Is.EqualTo(innerList)); +// Assert.That(retrievedDict.AsDictionary(), Is.EquivalentTo(innerDict)); + +// var retrievedList2 = rv.AsDictionary()["0"]; +// var retrievedDict2 = rv.AsDictionary()["1"]; + +// Assert.That(retrievedList2.AsList(), Is.EqualTo(innerList)); +// Assert.That(retrievedDict2.AsDictionary(), Is.EquivalentTo(innerDict)); +// } + +// [Test] +// public void Dictionary_CanBeCopiedFromManagedDictionary([Values(true, false)] bool isManaged) +// { +// var originalDict = DictGenerator(1); + +// RealmValue rv = originalDict; + +// if (isManaged) +// { +// rv = PersistAndFind(originalDict).RealmValueProperty; +// } + +// var newObj = new RealmValueObject { RealmValueProperty = rv }; + +// var rv2 = isManaged ? PersistAndFind(rv).RealmValueProperty : newObj.RealmValueProperty; + +// Assert.That(rv.AsDictionary(), Is.EqualTo(rv2.AsDictionary())); +// Assert.That(rv.AsDictionary(), Is.EqualTo(originalDict)); +// Assert.That(rv2.AsDictionary(), Is.EqualTo(originalDict)); +// } + +// [Test] +// public void Dictionary_BuiltWithConstructorMethodOrOperatorOrCreate_WorksTheSame([Values(true, false)] bool isManaged) +// { +// var originalDict = DictGenerator(1); + +// RealmValue rvOperator = originalDict; +// RealmValue rvConstructor = RealmValue.Dictionary(originalDict); +// RealmValue rvCreate = RealmValue.Create(originalDict, RealmValueType.Dictionary); + +// if (isManaged) +// { +// rvOperator = PersistAndFind(rvOperator).RealmValueProperty; +// rvConstructor = PersistAndFind(rvConstructor).RealmValueProperty; +// rvCreate = PersistAndFind(rvCreate).RealmValueProperty; +// } + +// Assert.That(rvOperator.AsDictionary(), Is.EqualTo(originalDict)); +// Assert.That(rvConstructor.AsDictionary(), Is.EqualTo(originalDict)); +// Assert.That(rvCreate.AsDictionary(), Is.EqualTo(originalDict)); +// } + +// [Test] +// public void Dictionary_WhenManaged_IsNotSameReferenceAsOriginalList() +// { +// var originalDict = DictGenerator(1); + +// RealmValue rv = originalDict; +// rv = PersistAndFind(rv).RealmValueProperty; +// var retrievedDict = rv.AsDictionary(); + +// Assert.That(ReferenceEquals(originalDict, retrievedDict), Is.False); +// } + +// [Test] +// public void Dictionary_WhenUnmanaged_IsSameReferenceAsOriginalList() +// { +// var originalDict = DictGenerator(1); + +// RealmValue rv = originalDict; +// var retrievedDict = rv.AsDictionary(); + +// Assert.That(ReferenceEquals(originalDict, retrievedDict), Is.True); +// } + +// [Test] +// public void Dictionary_AfterCreation_CanBeAssigned([Values(true, false)] bool isManaged) +// { +// var stringVal = "Mario"; +// var rvo = new RealmValueObject { RealmValueProperty = stringVal }; + +// if (isManaged) +// { +// _realm.Write(() => +// { +// _realm.Add(rvo); +// }); +// } + +// Assert.That(rvo.RealmValueProperty == stringVal); + +// var dictVal = DictGenerator(1); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty = dictVal; +// }); + +// Assert.That(rvo.RealmValueProperty.AsDictionary(), Is.EquivalentTo(dictVal)); + +// var newStringVal = "Luigi"; + +// _realm.Write(() => +// { +// rvo.RealmValueProperty = newStringVal; +// }); + +// Assert.That(rvo.RealmValueProperty == newStringVal); +// } + +// [Test] +// public void Dictionary_AfterCreation_CanBeReassigned([Values(true, false)] bool isManaged) +// { +// var initialDictionary = (RealmValue)new Dictionary { { "key1", 1 } }; +// var rvo = new RealmValueObject { RealmValueProperty = initialDictionary }; + +// if (isManaged) +// { +// _realm.Write(() => +// { +// _realm.Add(rvo); +// }); +// } + +// var actualDictionary = rvo.RealmValueProperty; +// Assert.That(initialDictionary, Is.EqualTo(actualDictionary).Using(_rvComparer)); + +// var updatedDictionary = (RealmValue)new Dictionary { { "key2", 2 } }; +// _realm.Write(() => +// { +// rvo.RealmValueProperty = updatedDictionary; +// }); + +// actualDictionary = rvo.RealmValueProperty; +// Assert.That(updatedDictionary, Is.EqualTo(actualDictionary).Using(_rvComparer)); +// } + +// [Test] +// public void Dictionary_AfterCreation_EmbeddedListCanBeReassigned([Values(true, false)] bool isManaged) +// { +// var initialList = new List { new List { 1, 2, 3 } }; +// var rvo = new RealmValueObject +// { +// RealmValueProperty = new Dictionary { { "key", initialList } } +// }; + +// if (isManaged) +// { +// _realm.Write(() => +// { +// _realm.Add(rvo); +// }); +// } + +// var actualEmbeddedList = rvo.RealmValueProperty.AsDictionary()["key"].AsList(); +// Assert.That(initialList, Is.EqualTo(actualEmbeddedList).Using(_rvComparer)); + +// var updatedList = (RealmValue)new List { 4, 5, 6 }; +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsDictionary()["key"] = updatedList; +// }); + +// actualEmbeddedList = rvo.RealmValueProperty.AsDictionary()["key"].AsList(); +// Assert.AreEqual(updatedList.AsList().Count, actualEmbeddedList.Count); +// } + +// [Test] +// public void Dict_AfterCreation_EmbeddedDictionaryCanBeReassigned([Values(true, false)] bool isManaged) +// { +// var embeddedDictionary = new Dictionary { { "key1", 1 } }; +// var rvo = new RealmValueObject +// { +// RealmValueProperty = new Dictionary { { "key", embeddedDictionary } } +// }; + +// if (isManaged) +// { +// _realm.Write(() => +// { +// _realm.Add(rvo); +// }); +// } + +// var actualEmbedded = rvo.RealmValueProperty.AsDictionary()["key"].AsDictionary(); +// Assert.That(embeddedDictionary, Is.EqualTo(actualEmbedded).Using(_rvComparer)); + +// var updatedDictionary = new Dictionary { { "key2", 2 } }; +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsDictionary()["key"] = updatedDictionary; +// }); + +// actualEmbedded = rvo.RealmValueProperty.AsDictionary()["key"].AsDictionary(); +// Assert.That(updatedDictionary, Is.EqualTo(actualEmbedded).Using(_rvComparer)); +// } + +// [Test] +// public void Dictionary_WhenManaged_CanBeModified() +// { +// var dictVal = DictGenerator(1); + +// var rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = dictVal })); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsDictionary()["s1"] = "Mario"; +// dictVal["s1"] = "Mario"; // To keep both list updated +// }); + +// Assert.That(rvo.RealmValueProperty.AsDictionary(), Is.EquivalentTo(dictVal)); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsDictionary().Remove("s2"); +// dictVal.Remove("s2"); +// }); + +// Assert.That(rvo.RealmValueProperty.AsDictionary(), Is.EquivalentTo(dictVal)); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsDictionary().Add("s4", "newVal"); +// dictVal.Add("s4", "newVal"); +// }); + +// Assert.That(rvo.RealmValueProperty.AsDictionary(), Is.EquivalentTo(dictVal)); +// } + +// [TestCaseSource(nameof(CollectionGenerators))] +// public void Dictionary_AddSetInsertMoveRemoveCollection_WorksAsIntended(Func collectionGenerator) +// { +// var dictVal = DictGenerator(1); + +// var rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = dictVal })); + +// // Indexer +// var c1 = collectionGenerator(1); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsDictionary()["s1"] = c1; +// dictVal["s1"] = c1; +// }); + +// Assert.That(rvo.RealmValueProperty.AsDictionary(), Is.EquivalentTo(dictVal).Using(_rvComparer)); + +// // Add +// var c3 = collectionGenerator(3); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsDictionary().Add("s4", c3); +// dictVal.Add("s4", c3); +// }); + +// Assert.That(rvo.RealmValueProperty.AsDictionary(), Is.EquivalentTo(dictVal).Using(_rvComparer)); + +// // Remove +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsDictionary().Remove("s4"); +// dictVal.Remove("s4"); +// }); + +// Assert.That(rvo.RealmValueProperty.AsDictionary(), Is.EquivalentTo(dictVal).Using(_rvComparer)); +// } + +// [Test] +// public void Dictionary_RemoveWithCollectionArgument_ReturnsFalse() +// { +// var innerList = ListGenerator(1); - var callbacks = new List(); - using var token = rvo.RealmValueProperty.AsList().SubscribeForNotifications((_, changes) => - { - if (changes != null) - { - callbacks.Add(changes); - } - }); +// var innerDict = DictGenerator(1); - _realm.Write(() => - { - rvo.RealmValueProperty.AsList()[0] = "mario"; - }); +// var dictVal = new Dictionary +// { +// { "s1", innerList }, +// { "s3", innerDict }, +// }; - _realm.Refresh(); - Assert.That(callbacks.Count, Is.EqualTo(1)); - Assert.That(callbacks[0].ModifiedIndices, Is.EqualTo(new[] { 0 })); +// var rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = dictVal })); - callbacks.Clear(); +// _realm.Write(() => +// { +// Assert.That(rvo.RealmValueProperty.AsDictionary().Remove(new KeyValuePair("s1", innerList)), Is.False); +// Assert.That(rvo.RealmValueProperty.AsDictionary().Remove(new KeyValuePair("s3", innerDict)), Is.False); +// }); +// } + +// [Test] +// public void Dictionary_WhenManaged_WorksWithDynamicLikeApi() +// { +// var dictVal = DictGenerator(1); - _realm.Write(() => - { - rvo.RealmValueProperty.AsList()[1].AsList()[0] = "luigi"; - }); +// var rvo = _realm.Write(() => _realm.Add(new RealmValueObject())); - _realm.Refresh(); - Assert.That(callbacks.Count, Is.EqualTo(1)); - Assert.That(callbacks[0].ModifiedIndices, Is.EqualTo(new[] { 1 })); +// _realm.Write(() => +// { +// rvo.DynamicApi.Set(nameof(RealmValueObject.RealmValueProperty), dictVal); +// }); - callbacks.Clear(); +// var rvp = rvo.DynamicApi.Get(nameof(RealmValueObject.RealmValueProperty)); - _realm.Write(() => - { - rvo.RealmValueProperty.AsList()[2].AsDictionary()["s1"] = "peach"; - }); - - _realm.Refresh(); - Assert.That(callbacks.Count, Is.EqualTo(1)); - Assert.That(callbacks[0].ModifiedIndices, Is.EqualTo(new[] { 2 })); +// Assert.That(rvp.AsDictionary(), Is.EqualTo(dictVal)); +// } - callbacks.Clear(); - } +//#if !UNITY +// [Test] +//#endif +// public void Dictionary_WhenManaged_WorksWithDynamic() +// { +// var dictVal = DictGenerator(1); + +// dynamic rvo = _realm.Write(() => _realm.Add(new RealmValueObject())); - #endregion +// _realm.Write(() => +// { +// rvo.RealmValueProperty = dictVal; +// }); + +// var rvp = rvo.RealmValueProperty; + +// Assert.That(rvp.AsDictionary(), Is.EqualTo(dictVal)); +// } - #region Dictionary - - [Test] - public void Dictionary_WhenRetrieved_WorksWithAllTypes([Values(true, false)] bool isManaged) - { - var innerList = ListGenerator(1); - var innerDict = DictGenerator(1); - - var originalDict = new Dictionary - { - { "1", RealmValue.Null }, - { "2", 1 }, - { "3", true }, - { "4", "string" }, - { "5", new byte[] { 0, 1, 2 } }, - { "6", new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero) }, - { "7", 1f }, - { "8", 2d }, - { "9", 3m }, - { "a", new ObjectId("5f63e882536de46d71877979") }, - { "b", Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31") }, - { "c", new InternalObject { IntProperty = 10, StringProperty = "brown" } }, - { "d", innerList }, - { "e", innerDict }, - }; - - RealmValue rv = originalDict; - - if (isManaged) - { - rv = PersistAndFind(rv).RealmValueProperty; - } - - Assert.That(rv.Type, Is.EqualTo(RealmValueType.Dictionary)); - Assert.That(rv != RealmValue.Null, "Different than null"); - - Assert.That(rv.AsDictionary(), Is.EquivalentTo(originalDict).Using(_rvComparer)); - Assert.That(rv.AsAny(), Is.EquivalentTo(originalDict).Using(_rvComparer)); - Assert.That(rv.As>(), Is.EquivalentTo(originalDict).Using(_rvComparer)); - } - - [Test] - public void Dictionary_InRealmValue_Equality([Values(true, false)] bool isManaged) - { - var innerList = ListGenerator(1); - var innerDict = DictGenerator(1); - - var originalDict = new Dictionary - { - { "c", new InternalObject { IntProperty = 10, StringProperty = "brown" } }, - { "d", innerList }, - { "e", innerDict }, - }; - - var copyOriginalDict = new Dictionary - { - { "c", new InternalObject { IntProperty = 10, StringProperty = "brown" } }, - { "d", innerList }, - { "e", innerDict }, - }; - - RealmValue rv = originalDict; - RealmValue rv2 = copyOriginalDict; - - if (isManaged) - { - rv = PersistAndFind(rv).RealmValueProperty; - } - -#pragma warning disable CS1718 // Comparison made to same variable - Assert.That(rv == rv, Is.True); -#pragma warning restore CS1718 // Comparison made to same variable - Assert.That(rv.Equals(rv), Is.True); - - // They contains the same values, but the collections do not point to the same object reference - Assert.That(rv == rv2, Is.False); - Assert.That(rv.Equals(rv2), Is.False); - - // If the object is unmanaged, the RealmValue just wraps the collection - Assert.That(rv == originalDict, isManaged ? Is.False : Is.True); - Assert.That(rv.Equals(originalDict), isManaged ? Is.False : Is.True); - } - - [Test] - public void Dictionary_WhenUsingIndexAccessWithCollections_WorkAsExpected([Values(true, false)] bool isManaged) - { - var innerList = ListGenerator(1); - var innerDict = DictGenerator(1); - - var originalDict = new Dictionary - { - { "0", innerList }, - { "1", innerDict }, - }; - - RealmValue rv = originalDict; - - if (isManaged) - { - rv = PersistAndFind(rv).RealmValueProperty; - } - - var retrievedList = rv.AsDictionary().ElementAt(0).Value; - var retrievedDict = rv.AsDictionary().ElementAt(1).Value; - - Assert.That(retrievedList.AsList(), Is.EqualTo(innerList)); - Assert.That(retrievedDict.AsDictionary(), Is.EquivalentTo(innerDict)); - - var retrievedList2 = rv.AsDictionary()["0"]; - var retrievedDict2 = rv.AsDictionary()["1"]; - - Assert.That(retrievedList2.AsList(), Is.EqualTo(innerList)); - Assert.That(retrievedDict2.AsDictionary(), Is.EquivalentTo(innerDict)); - } - - [Test] - public void Dictionary_CanBeCopiedFromManagedDictionary([Values(true, false)] bool isManaged) - { - var originalDict = DictGenerator(1); - - RealmValue rv = originalDict; - - if (isManaged) - { - rv = PersistAndFind(originalDict).RealmValueProperty; - } - - var newObj = new RealmValueObject { RealmValueProperty = rv }; - - var rv2 = isManaged ? PersistAndFind(rv).RealmValueProperty : newObj.RealmValueProperty; - - Assert.That(rv.AsDictionary(), Is.EqualTo(rv2.AsDictionary())); - Assert.That(rv.AsDictionary(), Is.EqualTo(originalDict)); - Assert.That(rv2.AsDictionary(), Is.EqualTo(originalDict)); - } - - [Test] - public void Dictionary_BuiltWithConstructorMethodOrOperatorOrCreate_WorksTheSame([Values(true, false)] bool isManaged) - { - var originalDict = DictGenerator(1); - - RealmValue rvOperator = originalDict; - RealmValue rvConstructor = RealmValue.Dictionary(originalDict); - RealmValue rvCreate = RealmValue.Create(originalDict, RealmValueType.Dictionary); - - if (isManaged) - { - rvOperator = PersistAndFind(rvOperator).RealmValueProperty; - rvConstructor = PersistAndFind(rvConstructor).RealmValueProperty; - rvCreate = PersistAndFind(rvCreate).RealmValueProperty; - } - - Assert.That(rvOperator.AsDictionary(), Is.EqualTo(originalDict)); - Assert.That(rvConstructor.AsDictionary(), Is.EqualTo(originalDict)); - Assert.That(rvCreate.AsDictionary(), Is.EqualTo(originalDict)); - } - - [Test] - public void Dictionary_WhenManaged_IsNotSameReferenceAsOriginalList() - { - var originalDict = DictGenerator(1); - - RealmValue rv = originalDict; - rv = PersistAndFind(rv).RealmValueProperty; - var retrievedDict = rv.AsDictionary(); - - Assert.That(ReferenceEquals(originalDict, retrievedDict), Is.False); - } - - [Test] - public void Dictionary_WhenUnmanaged_IsSameReferenceAsOriginalList() - { - var originalDict = DictGenerator(1); - - RealmValue rv = originalDict; - var retrievedDict = rv.AsDictionary(); - - Assert.That(ReferenceEquals(originalDict, retrievedDict), Is.True); - } - - [Test] - public void Dictionary_AfterCreation_CanBeAssigned([Values(true, false)] bool isManaged) - { - var stringVal = "Mario"; - var rvo = new RealmValueObject { RealmValueProperty = stringVal }; - - if (isManaged) - { - _realm.Write(() => - { - _realm.Add(rvo); - }); - } - - Assert.That(rvo.RealmValueProperty == stringVal); - - var dictVal = DictGenerator(1); - - _realm.Write(() => - { - rvo.RealmValueProperty = dictVal; - }); - - Assert.That(rvo.RealmValueProperty.AsDictionary(), Is.EquivalentTo(dictVal)); - - var newStringVal = "Luigi"; - - _realm.Write(() => - { - rvo.RealmValueProperty = newStringVal; - }); - - Assert.That(rvo.RealmValueProperty == newStringVal); - } - - [Test] - public void Dictionary_AfterCreation_CanBeReassigned([Values(true, false)] bool isManaged) - { - var initialDictionary = (RealmValue)new Dictionary { { "key1", 1 } }; - var rvo = new RealmValueObject { RealmValueProperty = initialDictionary }; - - if (isManaged) - { - _realm.Write(() => - { - _realm.Add(rvo); - }); - } - - var actualDictionary = rvo.RealmValueProperty; - Assert.That(initialDictionary, Is.EqualTo(actualDictionary).Using(_rvComparer)); - - var updatedDictionary = (RealmValue)new Dictionary { { "key2", 2 } }; - _realm.Write(() => - { - rvo.RealmValueProperty = updatedDictionary; - }); - - actualDictionary = rvo.RealmValueProperty; - Assert.That(updatedDictionary, Is.EqualTo(actualDictionary).Using(_rvComparer)); - } - - [Test] - public void Dictionary_AfterCreation_EmbeddedListCanBeReassigned([Values(true, false)] bool isManaged) - { - var initialList = new List { new List { 1, 2, 3 } }; - var rvo = new RealmValueObject - { - RealmValueProperty = new Dictionary { { "key", initialList } } - }; - - if (isManaged) - { - _realm.Write(() => - { - _realm.Add(rvo); - }); - } - - var actualEmbeddedList = rvo.RealmValueProperty.AsDictionary()["key"].AsList(); - Assert.That(initialList, Is.EqualTo(actualEmbeddedList).Using(_rvComparer)); - - var updatedList = (RealmValue)new List { 4, 5, 6 }; - _realm.Write(() => - { - rvo.RealmValueProperty.AsDictionary()["key"] = updatedList; - }); - - actualEmbeddedList = rvo.RealmValueProperty.AsDictionary()["key"].AsList(); - Assert.AreEqual(updatedList.AsList().Count, actualEmbeddedList.Count); - } - - [Test] - public void Dict_AfterCreation_EmbeddedDictionaryCanBeReassigned([Values(true, false)] bool isManaged) - { - var embeddedDictionary = new Dictionary { { "key1", 1 } }; - var rvo = new RealmValueObject - { - RealmValueProperty = new Dictionary { { "key", embeddedDictionary } } - }; - - if (isManaged) - { - _realm.Write(() => - { - _realm.Add(rvo); - }); - } - - var actualEmbedded = rvo.RealmValueProperty.AsDictionary()["key"].AsDictionary(); - Assert.That(embeddedDictionary, Is.EqualTo(actualEmbedded).Using(_rvComparer)); - - var updatedDictionary = new Dictionary { { "key2", 2 } }; - _realm.Write(() => - { - rvo.RealmValueProperty.AsDictionary()["key"] = updatedDictionary; - }); - - actualEmbedded = rvo.RealmValueProperty.AsDictionary()["key"].AsDictionary(); - Assert.That(updatedDictionary, Is.EqualTo(actualEmbedded).Using(_rvComparer)); - } - - [Test] - public void Dictionary_WhenManaged_CanBeModified() - { - var dictVal = DictGenerator(1); - - var rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = dictVal })); - - _realm.Write(() => - { - rvo.RealmValueProperty.AsDictionary()["s1"] = "Mario"; - dictVal["s1"] = "Mario"; // To keep both list updated - }); - - Assert.That(rvo.RealmValueProperty.AsDictionary(), Is.EquivalentTo(dictVal)); - - _realm.Write(() => - { - rvo.RealmValueProperty.AsDictionary().Remove("s2"); - dictVal.Remove("s2"); - }); - - Assert.That(rvo.RealmValueProperty.AsDictionary(), Is.EquivalentTo(dictVal)); - - _realm.Write(() => - { - rvo.RealmValueProperty.AsDictionary().Add("s4", "newVal"); - dictVal.Add("s4", "newVal"); - }); - - Assert.That(rvo.RealmValueProperty.AsDictionary(), Is.EquivalentTo(dictVal)); - } - - [TestCaseSource(nameof(CollectionGenerators))] - public void Dictionary_AddSetInsertMoveRemoveCollection_WorksAsIntended(Func collectionGenerator) - { - var dictVal = DictGenerator(1); - - var rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = dictVal })); - - // Indexer - var c1 = collectionGenerator(1); - - _realm.Write(() => - { - rvo.RealmValueProperty.AsDictionary()["s1"] = c1; - dictVal["s1"] = c1; - }); - - Assert.That(rvo.RealmValueProperty.AsDictionary(), Is.EquivalentTo(dictVal).Using(_rvComparer)); - - // Add - var c3 = collectionGenerator(3); - - _realm.Write(() => - { - rvo.RealmValueProperty.AsDictionary().Add("s4", c3); - dictVal.Add("s4", c3); - }); - - Assert.That(rvo.RealmValueProperty.AsDictionary(), Is.EquivalentTo(dictVal).Using(_rvComparer)); - - // Remove - _realm.Write(() => - { - rvo.RealmValueProperty.AsDictionary().Remove("s4"); - dictVal.Remove("s4"); - }); - - Assert.That(rvo.RealmValueProperty.AsDictionary(), Is.EquivalentTo(dictVal).Using(_rvComparer)); - } - - [Test] - public void Dictionary_RemoveWithCollectionArgument_ReturnsFalse() - { - var innerList = ListGenerator(1); - - var innerDict = DictGenerator(1); - - var dictVal = new Dictionary - { - { "s1", innerList }, - { "s3", innerDict }, - }; - - var rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = dictVal })); - - _realm.Write(() => - { - Assert.That(rvo.RealmValueProperty.AsDictionary().Remove(new KeyValuePair("s1", innerList)), Is.False); - Assert.That(rvo.RealmValueProperty.AsDictionary().Remove(new KeyValuePair("s3", innerDict)), Is.False); - }); - } - - [Test] - public void Dictionary_WhenManaged_WorksWithDynamicLikeApi() - { - var dictVal = DictGenerator(1); - - var rvo = _realm.Write(() => _realm.Add(new RealmValueObject())); - - _realm.Write(() => - { - rvo.DynamicApi.Set(nameof(RealmValueObject.RealmValueProperty), dictVal); - }); - - var rvp = rvo.DynamicApi.Get(nameof(RealmValueObject.RealmValueProperty)); - - Assert.That(rvp.AsDictionary(), Is.EqualTo(dictVal)); - } - -#if !UNITY - [Test] -#endif - public void Dictionary_WhenManaged_WorksWithDynamic() - { - var dictVal = DictGenerator(1); - - dynamic rvo = _realm.Write(() => _realm.Add(new RealmValueObject())); - - _realm.Write(() => - { - rvo.RealmValueProperty = dictVal; - }); - - var rvp = rvo.RealmValueProperty; - - Assert.That(rvp.AsDictionary(), Is.EqualTo(dictVal)); - } - - [Test] - public void Dictionary_WhenManaged_WorksWithNotifications() - { - var dictVal = new Dictionary { { "s1", 1 }, { "s2", ListGenerator(1) }, { "s3", DictGenerator(1) } }; - - var rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = dictVal })); - - var callbacks = new List(); - using var token = rvo.RealmValueProperty.AsDictionary().SubscribeForNotifications((_, changes) => - { - if (changes != null) - { - callbacks.Add(changes); - } - }); - - _realm.Write(() => - { - rvo.RealmValueProperty.AsDictionary()["s1"] = "mario"; - }); - - _realm.Refresh(); - Assert.That(callbacks.Count, Is.EqualTo(1)); - - callbacks.Clear(); - - _realm.Write(() => - { - rvo.RealmValueProperty.AsDictionary()["s2"].AsList()[0] = "mario"; - }); - - _realm.Refresh(); - Assert.That(callbacks.Count, Is.EqualTo(1)); - - callbacks.Clear(); - - _realm.Write(() => - { - rvo.RealmValueProperty.AsDictionary()["s3"].AsDictionary()["s1"] = "peach"; - }); - - _realm.Refresh(); - Assert.That(callbacks.Count, Is.EqualTo(1)); - - callbacks.Clear(); - } - - [Test] - public void MixedCollection_Filter_CountSizeType() - { - var ob1 = new RealmValueObject { RealmValueProperty = 2 }; - var ob2 = new RealmValueObject { RealmValueProperty = new List { 1, "string", 23.0 } }; - var ob3 = new RealmValueObject { RealmValueProperty = new List { 1, "string" } }; - var ob4 = new RealmValueObject { RealmValueProperty = new Dictionary { { "s1", 22 } } }; - - _realm.Write(() => - { - _realm.Add(ob1); - _realm.Add(ob2); - _realm.Add(ob3); - _realm.Add(ob4); - }); - - var rvos = _realm.All(); - - var q = rvos.Filter("RealmValueProperty.@size <= 2"); - Assert.That(q.ToList().Select(i => i.Id), Is.EquivalentTo(new[] { ob3.Id, ob4.Id })); - - q = rvos.Filter("RealmValueProperty.@count > 2"); - Assert.That(q.ToList().Select(i => i.Id), Is.EquivalentTo(new[] { ob2.Id })); - - q = rvos.Filter("RealmValueProperty.@type == 'dictionary'"); - Assert.That(q.ToList().Select(i => i.Id), Is.EquivalentTo(new[] { ob4.Id })); - - q = rvos.Filter("RealmValueProperty.@type == 'list'"); - Assert.That(q.ToList().Select(i => i.Id), Is.EquivalentTo(new[] { ob2.Id, ob3.Id })); - - q = rvos.Filter("RealmValueProperty.@type == 'collection'"); - Assert.That(q.ToList().Select(i => i.Id), Is.EquivalentTo(new[] { ob2.Id, ob3.Id, ob4.Id })); - } - - [Test] - public void MixedCollection_Filter_AnyAllNone() - { - var ob1 = new RealmValueObject { RealmValueProperty = 2 }; - var ob2 = new RealmValueObject { RealmValueProperty = new List { "a", "string" } }; - var ob3 = new RealmValueObject { RealmValueProperty = new List { 1, "string" } }; - var ob4 = new RealmValueObject { RealmValueProperty = new List { 1, 23 } }; - - _realm.Write(() => - { - _realm.Add(ob1); - _realm.Add(ob2); - _realm.Add(ob3); - _realm.Add(ob4); - }); - - var rvos = _realm.All(); - - var q = rvos.Filter("ANY RealmValueProperty[*].@type == 'string'"); - Assert.That(q.ToList().Select(i => i.Id), Is.EquivalentTo(new[] { ob2.Id, ob3.Id })); - - // NONE and ALL match both also on "empty lists", that's why they match also on ob1 - q = rvos.Filter("NONE RealmValueProperty[*].@type == 'string'"); - Assert.That(q.ToList().Select(i => i.Id), Is.EquivalentTo(new[] { ob1.Id, ob4.Id })); - - q = rvos.Filter("ALL RealmValueProperty[*].@type == 'string'"); - Assert.That(q.ToList().Select(i => i.Id), Is.EquivalentTo(new[] { ob2.Id, ob1.Id })); - } - - [Test] - public void IndexedRealmValue_WithCollection_BasicTest() - { - var innerList = ListGenerator(1); - var innerDict = DictGenerator(1); - - var originalList = new List - { - RealmValue.Null, - 1, - true, - "string", - new byte[] { 0, 1, 2 }, - new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero), - 1f, - 2d, - 3m, - new ObjectId("5f63e882536de46d71877979"), - Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31"), - new InternalObject { IntProperty = 10, StringProperty = "brown" }, - innerList, - innerDict, - }; - - var obj = _realm.Write( - () => _realm.Add(new IndexedRealmValueObject { RealmValueProperty = originalList })); - - RealmValue rv = obj.RealmValueProperty; - - Assert.That(rv.Type, Is.EqualTo(RealmValueType.List)); - Assert.That(rv != RealmValue.Null); - Assert.That(rv.AsList(), Is.EqualTo(originalList).Using(_rvComparer)); - - var originalDict = new Dictionary - { - { "1", RealmValue.Null }, - { "2", 1 }, - { "3", true }, - { "4", "string" }, - { "5", new byte[] { 0, 1, 2 } }, - { "6", new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero) }, - { "7", 1f }, - { "8", 2d }, - { "9", 3m }, - { "a", new ObjectId("5f63e882536de46d71877979") }, - { "b", Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31") }, - { "c", new InternalObject { IntProperty = 10, StringProperty = "brown" } }, - { "d", innerList }, - { "e", innerDict }, - }; - - _realm.Write(() => - { - obj.RealmValueProperty = originalDict; - }); - - rv = obj.RealmValueProperty; - - Assert.That(rv.Type, Is.EqualTo(RealmValueType.Dictionary)); - Assert.That(rv != RealmValue.Null, "Different than null"); - - Assert.That(rv.AsDictionary(), Is.EqualTo(originalDict).Using(_rvComparer)); - Assert.That(rv.AsAny(), Is.EqualTo(originalDict).Using(_rvComparer)); - Assert.That(rv.As>(), Is.EqualTo(originalDict).Using(_rvComparer)); - } +// [Test] +// public void Dictionary_WhenManaged_WorksWithNotifications() +// { +// var dictVal = new Dictionary { { "s1", 1 }, { "s2", ListGenerator(1) }, { "s3", DictGenerator(1) } }; + +// var rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = dictVal })); - #endregion +// var callbacks = new List(); +// using var token = rvo.RealmValueProperty.AsDictionary().SubscribeForNotifications((_, changes) => +// { +// if (changes != null) +// { +// callbacks.Add(changes); +// } +// }); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsDictionary()["s1"] = "mario"; +// }); + +// _realm.Refresh(); +// Assert.That(callbacks.Count, Is.EqualTo(1)); + +// callbacks.Clear(); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsDictionary()["s2"].AsList()[0] = "mario"; +// }); + +// _realm.Refresh(); +// Assert.That(callbacks.Count, Is.EqualTo(1)); + +// callbacks.Clear(); + +// _realm.Write(() => +// { +// rvo.RealmValueProperty.AsDictionary()["s3"].AsDictionary()["s1"] = "peach"; +// }); + +// _realm.Refresh(); +// Assert.That(callbacks.Count, Is.EqualTo(1)); + +// callbacks.Clear(); +// } + +// [Test] +// public void MixedCollection_Filter_CountSizeType() +// { +// var ob1 = new RealmValueObject { RealmValueProperty = 2 }; +// var ob2 = new RealmValueObject { RealmValueProperty = new List { 1, "string", 23.0 } }; +// var ob3 = new RealmValueObject { RealmValueProperty = new List { 1, "string" } }; +// var ob4 = new RealmValueObject { RealmValueProperty = new Dictionary { { "s1", 22 } } }; + +// _realm.Write(() => +// { +// _realm.Add(ob1); +// _realm.Add(ob2); +// _realm.Add(ob3); +// _realm.Add(ob4); +// }); + +// var rvos = _realm.All(); + +// var q = rvos.Filter("RealmValueProperty.@size <= 2"); +// Assert.That(q.ToList().Select(i => i.Id), Is.EquivalentTo(new[] { ob3.Id, ob4.Id })); + +// q = rvos.Filter("RealmValueProperty.@count > 2"); +// Assert.That(q.ToList().Select(i => i.Id), Is.EquivalentTo(new[] { ob2.Id })); + +// q = rvos.Filter("RealmValueProperty.@type == 'dictionary'"); +// Assert.That(q.ToList().Select(i => i.Id), Is.EquivalentTo(new[] { ob4.Id })); + +// q = rvos.Filter("RealmValueProperty.@type == 'list'"); +// Assert.That(q.ToList().Select(i => i.Id), Is.EquivalentTo(new[] { ob2.Id, ob3.Id })); + +// q = rvos.Filter("RealmValueProperty.@type == 'collection'"); +// Assert.That(q.ToList().Select(i => i.Id), Is.EquivalentTo(new[] { ob2.Id, ob3.Id, ob4.Id })); +// } + +// [Test] +// public void MixedCollection_Filter_AnyAllNone() +// { +// var ob1 = new RealmValueObject { RealmValueProperty = 2 }; +// var ob2 = new RealmValueObject { RealmValueProperty = new List { "a", "string" } }; +// var ob3 = new RealmValueObject { RealmValueProperty = new List { 1, "string" } }; +// var ob4 = new RealmValueObject { RealmValueProperty = new List { 1, 23 } }; + +// _realm.Write(() => +// { +// _realm.Add(ob1); +// _realm.Add(ob2); +// _realm.Add(ob3); +// _realm.Add(ob4); +// }); + +// var rvos = _realm.All(); + +// var q = rvos.Filter("ANY RealmValueProperty[*].@type == 'string'"); +// Assert.That(q.ToList().Select(i => i.Id), Is.EquivalentTo(new[] { ob2.Id, ob3.Id })); + +// // NONE and ALL match both also on "empty lists", that's why they match also on ob1 +// q = rvos.Filter("NONE RealmValueProperty[*].@type == 'string'"); +// Assert.That(q.ToList().Select(i => i.Id), Is.EquivalentTo(new[] { ob1.Id, ob4.Id })); + +// q = rvos.Filter("ALL RealmValueProperty[*].@type == 'string'"); +// Assert.That(q.ToList().Select(i => i.Id), Is.EquivalentTo(new[] { ob2.Id, ob1.Id })); +// } + +// [Test] +// public void IndexedRealmValue_WithCollection_BasicTest() +// { +// var innerList = ListGenerator(1); +// var innerDict = DictGenerator(1); + +// var originalList = new List +// { +// RealmValue.Null, +// 1, +// true, +// "string", +// new byte[] { 0, 1, 2 }, +// new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero), +// 1f, +// 2d, +// 3m, +// new ObjectId("5f63e882536de46d71877979"), +// Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31"), +// new InternalObject { IntProperty = 10, StringProperty = "brown" }, +// innerList, +// innerDict, +// }; + +// var obj = _realm.Write( +// () => _realm.Add(new IndexedRealmValueObject { RealmValueProperty = originalList })); + +// RealmValue rv = obj.RealmValueProperty; + +// Assert.That(rv.Type, Is.EqualTo(RealmValueType.List)); +// Assert.That(rv != RealmValue.Null); +// Assert.That(rv.AsList(), Is.EqualTo(originalList).Using(_rvComparer)); + +// var originalDict = new Dictionary +// { +// { "1", RealmValue.Null }, +// { "2", 1 }, +// { "3", true }, +// { "4", "string" }, +// { "5", new byte[] { 0, 1, 2 } }, +// { "6", new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero) }, +// { "7", 1f }, +// { "8", 2d }, +// { "9", 3m }, +// { "a", new ObjectId("5f63e882536de46d71877979") }, +// { "b", Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31") }, +// { "c", new InternalObject { IntProperty = 10, StringProperty = "brown" } }, +// { "d", innerList }, +// { "e", innerDict }, +// }; + +// _realm.Write(() => +// { +// obj.RealmValueProperty = originalDict; +// }); + +// rv = obj.RealmValueProperty; + +// Assert.That(rv.Type, Is.EqualTo(RealmValueType.Dictionary)); +// Assert.That(rv != RealmValue.Null, "Different than null"); + +// Assert.That(rv.AsDictionary(), Is.EqualTo(originalDict).Using(_rvComparer)); +// Assert.That(rv.AsAny(), Is.EqualTo(originalDict).Using(_rvComparer)); +// Assert.That(rv.As>(), Is.EqualTo(originalDict).Using(_rvComparer)); +// } + +// #endregion internal class RealmValueComparer : IEqualityComparer { diff --git a/Tests/Realm.Tests/Sync/DataTypeSynchronizationTests.cs b/Tests/Realm.Tests/Sync/DataTypeSynchronizationTests.cs index 4d55c43431..43df94bb04 100644 --- a/Tests/Realm.Tests/Sync/DataTypeSynchronizationTests.cs +++ b/Tests/Realm.Tests/Sync/DataTypeSynchronizationTests.cs @@ -279,80 +279,80 @@ public class DataTypeSynchronizationTests : SyncTestBase new object[] { (RealmValue)12.5f, (RealmValue)15d }, }; - public static readonly object[] RealmTestValuesWithCollections = RealmTestPrimitiveValues.Concat(new[] - { - new object[] { (RealmValue)12.5f, (RealmValue)15d }, - new object[] - { - (RealmValue)new List - { - RealmValue.Null, - 1, - true, - "string", - new byte[] { 0, 1, 2 }, - new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero), - 1f, - 2d, - 3m, - new ObjectId("5f63e882536de46d71877979"), - Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31"), - new List { 1, true, "string" }, - new Dictionary - { - { "key1", RealmValue.Null }, - { "key2", 1 }, - { "key3", true }, - { "key4", "string" }, - } - }, - (RealmValue)15d - }, - new object[] - { - (RealmValue)new Dictionary - { - { "key1", RealmValue.Null }, - { "key2", 1 }, - { "key3", true }, - { "key4", "string" }, - { "key5", new byte[] { 0, 1, 2, 3 } }, - { "key6", new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero) }, - { "key7", 1f }, - { "key8", 2d }, - { "key9", 3m }, - { "key10", new ObjectId("5f63e882536de46d71877979") }, - { "key11", Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31") }, - { "key12", new List { 1, true, "string" } }, - { - "key13", new Dictionary - { - { "key1", RealmValue.Null }, - { "key2", 1 }, - { "key3", true }, - { "key4", "string" }, - } - }, - }, - (RealmValue)15d - }, - }).ToArray(); - - [TestCaseSource(nameof(RealmTestValuesWithCollections))] - public void List_RealmValue(RealmValue first, RealmValue second) => TestListCore(o => o.RealmValueList, - Clone(first), Clone(second), equalsOverride: RealmValueEquals); - - [TestCaseSource(nameof(RealmTestPrimitiveValues))] - public void Set_RealmValue(RealmValue first, RealmValue second) => TestSetCore(o => o.RealmValueSet, - Clone(first), Clone(second), equalsOverride: RealmValueEquals); - - [TestCaseSource(nameof(RealmTestValuesWithCollections))] - public void Dict_RealmValue(RealmValue first, RealmValue second) => TestDictionaryCore(o => o.RealmValueDict, - Clone(first), Clone(second), equalsOverride: RealmValueEquals); - - [TestCaseSource(nameof(RealmTestValuesWithCollections))] - public void Property_RealmValue(RealmValue first, RealmValue second) => TestPropertyCore( - o => o.RealmValueProperty, (o, rv) => o.RealmValueProperty = rv, Clone(first), Clone(second)); + //public static readonly object[] RealmTestValuesWithCollections = RealmTestPrimitiveValues.Concat(new[] + //{ + // new object[] { (RealmValue)12.5f, (RealmValue)15d }, + // new object[] + // { + // (RealmValue)new List + // { + // RealmValue.Null, + // 1, + // true, + // "string", + // new byte[] { 0, 1, 2 }, + // new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero), + // 1f, + // 2d, + // 3m, + // new ObjectId("5f63e882536de46d71877979"), + // Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31"), + // new List { 1, true, "string" }, + // new Dictionary + // { + // { "key1", RealmValue.Null }, + // { "key2", 1 }, + // { "key3", true }, + // { "key4", "string" }, + // } + // }, + // (RealmValue)15d + // }, + // new object[] + // { + // (RealmValue)new Dictionary + // { + // { "key1", RealmValue.Null }, + // { "key2", 1 }, + // { "key3", true }, + // { "key4", "string" }, + // { "key5", new byte[] { 0, 1, 2, 3 } }, + // { "key6", new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero) }, + // { "key7", 1f }, + // { "key8", 2d }, + // { "key9", 3m }, + // { "key10", new ObjectId("5f63e882536de46d71877979") }, + // { "key11", Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31") }, + // { "key12", new List { 1, true, "string" } }, + // { + // "key13", new Dictionary + // { + // { "key1", RealmValue.Null }, + // { "key2", 1 }, + // { "key3", true }, + // { "key4", "string" }, + // } + // }, + // }, + // (RealmValue)15d + // }, + //}).ToArray(); + + //[TestCaseSource(nameof(RealmTestValuesWithCollections))] + //public void List_RealmValue(RealmValue first, RealmValue second) => TestListCore(o => o.RealmValueList, + // Clone(first), Clone(second), equalsOverride: RealmValueEquals); + + //[TestCaseSource(nameof(RealmTestPrimitiveValues))] + //public void Set_RealmValue(RealmValue first, RealmValue second) => TestSetCore(o => o.RealmValueSet, + // Clone(first), Clone(second), equalsOverride: RealmValueEquals); + + //[TestCaseSource(nameof(RealmTestValuesWithCollections))] + //public void Dict_RealmValue(RealmValue first, RealmValue second) => TestDictionaryCore(o => o.RealmValueDict, + // Clone(first), Clone(second), equalsOverride: RealmValueEquals); + + //[TestCaseSource(nameof(RealmTestValuesWithCollections))] + //public void Property_RealmValue(RealmValue first, RealmValue second) => TestPropertyCore( + // o => o.RealmValueProperty, (o, rv) => o.RealmValueProperty = rv, Clone(first), Clone(second)); #endregion @@ -597,340 +597,340 @@ private void TestPropertyCore(Func getter, Action - { - var realm1 = await GetFLXIntegrationRealmAsync(); - realm1.Subscriptions.Update(() => - { - realm1.Subscriptions.Add(realm1.All()); - realm1.Subscriptions.Add(realm1.All()); - }); - - var parent = new SyncAllTypesObject(); - var child = new IntPropertyObject(); - - var valuesValue = new List - { - 1, - "Realm", - child, - new List { 1, "Realm", child }, - new Dictionary - { - { "key1", 1 }, { "key2", "Realm" }, { "key3", child }, - } - }; - - realm1.Write(() => - { - realm1.Add(parent); - parent.StringProperty = "PARENT"; - parent.ObjectProperty = child; - parent.RealmValueProperty = valuesValue; - }); - - var parentId = parent.Id; - var childId = child.Id; - - await realm1.SyncSession.WaitForUploadAsync(); - realm1.Dispose(); - - var realm2 = await GetFLXIntegrationRealmAsync(); - realm2.Subscriptions.Update(() => - { - realm2.Subscriptions.Add(realm2.All()); - realm2.Subscriptions.Add(realm2.All()); - }); - await realm2.SyncSession.WaitForDownloadAsync(); - - var syncedParent = - await TestHelpers.WaitForConditionAsync(() => realm2.FindCore(parentId), - o => o != null); - var syncedChild = - await TestHelpers.WaitForConditionAsync(() => realm2.FindCore(childId), - o => o != null); - var syncedValues = syncedParent!.RealmValueProperty.AsList(); - Assert.AreEqual(valuesValue[0], syncedValues[0]); - Assert.AreEqual(valuesValue[1], syncedValues[1]); - Assert.AreEqual(childId, syncedValues[2].AsRealmObject().Id); - var nestedExpectedList = valuesValue[3].AsList(); - var nestedSyncedList = syncedValues[3].AsList(); - Assert.AreEqual(nestedExpectedList[0], nestedSyncedList[0]); - Assert.AreEqual(nestedExpectedList[1], nestedSyncedList[1]); - Assert.AreEqual(childId, nestedSyncedList[2].AsRealmObject().Id); - - var nestedExpectedDictionary = valuesValue[4].AsDictionary(); - var nestedSyncedDictionary = syncedValues[4].AsDictionary(); - Assert.AreEqual(nestedExpectedDictionary["key1"], nestedSyncedDictionary["key1"]); - Assert.AreEqual(nestedExpectedDictionary["key2"], nestedSyncedDictionary["key2"]); - Assert.AreEqual(childId, nestedSyncedDictionary["key3"].AsRealmObject().Id); - }); - } - - public static readonly IList RealmValueCollectionTestValues = new List() - { - "abc", - new ObjectId("5f63e882536de46d71877979"), - new byte[] { 0, 1, 2 }, - DateTimeOffset.FromUnixTimeSeconds(1616137641), - true, - RealmValue.Null, - 5m, - 12.5f, - 15d, - new List - { - RealmValue.Null, - 1, - true, - "string", - new byte[] { 0, 1, 2 }, - new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero), - 1f, - 2d, - 3m, - new ObjectId("5f63e882536de46d71877979"), - Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31"), - new List { 1, true, "string" }, - new Dictionary - { - { "key1", RealmValue.Null }, - { "key2", 1 }, - { "key3", true }, - { "key4", "string" }, - } - }, - new Dictionary - { - { "key1", RealmValue.Null }, - { "key2", 1 }, - { "key3", true }, - { "key4", "string" }, - { "key5", new byte[] { 0, 1, 2, 3 } }, - { "key6", new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero) }, - { "key7", 1f }, - { "key8", 2d }, - { "key9", 3m }, - { "key10", new ObjectId("5f63e882536de46d71877979") }, - { "key11", Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31") }, - { "key12", new List { 1, true, "string" } }, - { - "key13", new Dictionary - { - { "key1", RealmValue.Null }, - { "key2", 1 }, - { "key3", true }, - { "key4", "string" }, - } - }, - }, - }; - - [Test] - public void ListManipulations() - { - SyncTestHelpers.RunBaasTestAsync(async () => - { - var realm1 = await GetFLXIntegrationRealmAsync(); - var realm2 = await GetFLXIntegrationRealmAsync(); - - realm1.Subscriptions.Update(() => { realm1.Subscriptions.Add(realm1.All()); }); - realm2.Subscriptions.Update(() => { realm2.Subscriptions.Add(realm2.All()); }); - - var obj1 = realm1.Write(() => - { - var o = realm1.Add(new SyncAllTypesObject()); - o.RealmValueProperty = new List(); - return o; - }); - - var obj2 = await WaitForObjectAsync(obj1, realm2); - - // Append elements one by one and verify that they are synced - foreach (var realmTestValue in RealmValueCollectionTestValues) - { - realm1.Write(() => - { - obj1.RealmValueProperty.AsList().Add(realmTestValue); - }); - await realm1.SyncSession.WaitForUploadAsync(); - - await realm2.SyncSession.WaitForDownloadAsync(); - var expectedValues = obj1.RealmValueProperty.AsList(); - var actualValues = obj2.RealmValueProperty.AsList(); - Assert.That(expectedValues, Is.EqualTo(actualValues).Using(_rvComparer)); - } - - // Remove elements one by one and verify that changes are synced - for (int index = 0; index < RealmValueCollectionTestValues.Count; index++) - { - realm1.Write(() => - { - obj1.RealmValueProperty.AsList().RemoveAt(0); - }); - await realm1.SyncSession.WaitForUploadAsync(); - - await realm2.SyncSession.WaitForDownloadAsync(); - var expectedValues = obj1.RealmValueProperty.AsList(); - var actualValues = obj2.RealmValueProperty.AsList(); - Assert.That(expectedValues, Is.EqualTo(actualValues).Using(_rvComparer)); - } - - // Insert/override elements at index 0 and verify that changes are synced - foreach (var realmTestValue in RealmValueCollectionTestValues) - { - realm1.Write(() => - { - if (obj1.RealmValueProperty.AsList().Count == 0) - { - obj1.RealmValueProperty.AsList().Insert(0, realmTestValue); - } - else - { - obj1.RealmValueProperty.AsList()[0] = realmTestValue; - } - }); - await realm1.SyncSession.WaitForUploadAsync(); - - await realm2.SyncSession.WaitForDownloadAsync(); - var expectedValues = obj1.RealmValueProperty.AsList(); - var actualValues = obj2.RealmValueProperty.AsList(); - Assert.That(expectedValues, Is.EqualTo(actualValues).Using(_rvComparer)); - } - }); - } - - [Test] - public void DictionaryManipulations() - { - SyncTestHelpers.RunBaasTestAsync(async () => - { - var realm1 = await GetFLXIntegrationRealmAsync(); - realm1.Subscriptions.Update(() => - { - realm1.Subscriptions.Add(realm1.All()); - }); - - var realm2 = await GetFLXIntegrationRealmAsync(); - realm2.Subscriptions.Update(() => - { - realm2.Subscriptions.Add(realm2.All()); - }); - - var obj1 = realm1.Write(() => - { - var o = realm1.Add(new SyncAllTypesObject()); - o.RealmValueProperty = new Dictionary(); - return o; - }); - - var obj2 = await WaitForObjectAsync(obj1, realm2); - - for (int index = 0; index < RealmTestValuesWithCollections.Length; index++) - { - var realmTestValue = RealmValueCollectionTestValues[index]; - realm1.Write(() => { obj1.RealmValueProperty.AsDictionary()[$"{index}"] = realmTestValue; }); - - await realm1.SyncSession.WaitForUploadAsync(); - await realm2.SyncSession.WaitForDownloadAsync(); - var expectedValues = obj1.RealmValueProperty.AsDictionary(); - var actualValues = obj2.RealmValueProperty.AsDictionary(); - Assert.That(expectedValues, Is.EqualTo(actualValues).Using(_rvComparer)); - } - - for (int index = 0; index < RealmTestValuesWithCollections.Length; index++) - { - realm1.Write(() => { obj1.RealmValueProperty.AsDictionary().Remove($"{index}"); }); - await realm1.SyncSession.WaitForUploadAsync(); - await realm2.SyncSession.WaitForDownloadAsync(); - var expectedValues = obj1.RealmValueProperty.AsDictionary(); - var actualValues = obj2.RealmValueProperty.AsDictionary(); - Assert.That(expectedValues, Is.EqualTo(actualValues).Using(_rvComparer)); - } - }); - } - - [Test] - [Ignore("Crashes until https://github.com/realm/realm-core/issues/7488 is fixed")] - public void CollectionMerge() - { - SyncTestHelpers.RunBaasTestAsync(async () => - { - var realm1 = await GetFLXIntegrationRealmAsync(); - realm1.Subscriptions.Update(() => - { - realm1.Subscriptions.Add(realm1.All()); - }); - var realm2 = await GetFLXIntegrationRealmAsync(); - realm2.Subscriptions.Update(() => - { - realm2.Subscriptions.Add(realm2.All()); - }); - - var obj1 = realm1.Write(() => - { - var o = realm1.Add(new SyncAllTypesObject()); - o.RealmValueProperty = new Dictionary - { - { "list", new List { 1, 2, 3 } }, - { "dictionary", new Dictionary() { { "key1", 1 } } }, - }; - return o; - }); - - var obj2 = await WaitForObjectAsync(obj1, realm2); - - realm1.SyncSession.Stop(); - realm2.SyncSession.Stop(); - - realm1.Write(() => - { - var list = obj1.RealmValueProperty.AsDictionary()["list"].AsList(); - list.RemoveAt(0); - list.Add(4); - var dictionary = obj1.RealmValueProperty.AsDictionary()["dictionary"].AsDictionary(); - dictionary.Remove("key1"); - dictionary["key2"] = 2; - }); - realm2.Write(() => - { - var list = obj2.RealmValueProperty.AsDictionary()["list"].AsList(); - list.RemoveAt(0); - list.Add(5); - var dictionary = obj2.RealmValueProperty.AsDictionary()["dictionary"].AsDictionary(); - dictionary.Remove("key1"); - dictionary["key3"] = 3; - }); - - realm1.SyncSession.Start(); - realm2.SyncSession.Start(); - - await realm1.SyncSession.WaitForUploadAsync(); - await realm2.SyncSession.WaitForUploadAsync(); - await realm1.SyncSession.WaitForDownloadAsync(); - await realm2.SyncSession.WaitForDownloadAsync(); - - var list1 = obj1.RealmValueProperty.AsDictionary()["list"].AsList(); - var dictionary1 = obj1.RealmValueProperty.AsDictionary()["dictionary"].AsDictionary(); - var list2 = obj1.RealmValueProperty.AsDictionary()["list"].AsList(); - var dictionary2 = obj1.RealmValueProperty.AsDictionary()["dictionary"].AsDictionary(); - - Assert.That(list1, new NotConstraint(Contains.Item((RealmValue)1))); - Assert.That(list1, Contains.Item((RealmValue)2)); - Assert.That(list1, Contains.Item((RealmValue)3)); - Assert.That(list1, Contains.Item((RealmValue)4)); - Assert.That(list1, Contains.Item((RealmValue)5)); - Assert.That(list1, Is.EqualTo(list2).Using(_rvComparer)); - - Assert.That(dictionary1, new NotConstraint(Contains.Key("key1"))); - Assert.That(dictionary1, Contains.Key("key2")); - Assert.That(dictionary1, Contains.Key("key3")); - Assert.That(dictionary1, Is.EqualTo(dictionary2).Using(_rvComparer)); - }); - } + //[Test] + //public void Bootstrap() + //{ + // SyncTestHelpers.RunBaasTestAsync(async () => + // { + // var realm1 = await GetFLXIntegrationRealmAsync(); + // realm1.Subscriptions.Update(() => + // { + // realm1.Subscriptions.Add(realm1.All()); + // realm1.Subscriptions.Add(realm1.All()); + // }); + + // var parent = new SyncAllTypesObject(); + // var child = new IntPropertyObject(); + + // var valuesValue = new List + // { + // 1, + // "Realm", + // child, + // new List { 1, "Realm", child }, + // new Dictionary + // { + // { "key1", 1 }, { "key2", "Realm" }, { "key3", child }, + // } + // }; + + // realm1.Write(() => + // { + // realm1.Add(parent); + // parent.StringProperty = "PARENT"; + // parent.ObjectProperty = child; + // parent.RealmValueProperty = valuesValue; + // }); + + // var parentId = parent.Id; + // var childId = child.Id; + + // await realm1.SyncSession.WaitForUploadAsync(); + // realm1.Dispose(); + + // var realm2 = await GetFLXIntegrationRealmAsync(); + // realm2.Subscriptions.Update(() => + // { + // realm2.Subscriptions.Add(realm2.All()); + // realm2.Subscriptions.Add(realm2.All()); + // }); + // await realm2.SyncSession.WaitForDownloadAsync(); + + // var syncedParent = + // await TestHelpers.WaitForConditionAsync(() => realm2.FindCore(parentId), + // o => o != null); + // var syncedChild = + // await TestHelpers.WaitForConditionAsync(() => realm2.FindCore(childId), + // o => o != null); + // var syncedValues = syncedParent!.RealmValueProperty.AsList(); + // Assert.AreEqual(valuesValue[0], syncedValues[0]); + // Assert.AreEqual(valuesValue[1], syncedValues[1]); + // Assert.AreEqual(childId, syncedValues[2].AsRealmObject().Id); + // var nestedExpectedList = valuesValue[3].AsList(); + // var nestedSyncedList = syncedValues[3].AsList(); + // Assert.AreEqual(nestedExpectedList[0], nestedSyncedList[0]); + // Assert.AreEqual(nestedExpectedList[1], nestedSyncedList[1]); + // Assert.AreEqual(childId, nestedSyncedList[2].AsRealmObject().Id); + + // var nestedExpectedDictionary = valuesValue[4].AsDictionary(); + // var nestedSyncedDictionary = syncedValues[4].AsDictionary(); + // Assert.AreEqual(nestedExpectedDictionary["key1"], nestedSyncedDictionary["key1"]); + // Assert.AreEqual(nestedExpectedDictionary["key2"], nestedSyncedDictionary["key2"]); + // Assert.AreEqual(childId, nestedSyncedDictionary["key3"].AsRealmObject().Id); + // }); + //} + + //public static readonly IList RealmValueCollectionTestValues = new List() + //{ + // "abc", + // new ObjectId("5f63e882536de46d71877979"), + // new byte[] { 0, 1, 2 }, + // DateTimeOffset.FromUnixTimeSeconds(1616137641), + // true, + // RealmValue.Null, + // 5m, + // 12.5f, + // 15d, + // new List + // { + // RealmValue.Null, + // 1, + // true, + // "string", + // new byte[] { 0, 1, 2 }, + // new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero), + // 1f, + // 2d, + // 3m, + // new ObjectId("5f63e882536de46d71877979"), + // Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31"), + // new List { 1, true, "string" }, + // new Dictionary + // { + // { "key1", RealmValue.Null }, + // { "key2", 1 }, + // { "key3", true }, + // { "key4", "string" }, + // } + // }, + // new Dictionary + // { + // { "key1", RealmValue.Null }, + // { "key2", 1 }, + // { "key3", true }, + // { "key4", "string" }, + // { "key5", new byte[] { 0, 1, 2, 3 } }, + // { "key6", new DateTimeOffset(1234, 5, 6, 7, 8, 9, TimeSpan.Zero) }, + // { "key7", 1f }, + // { "key8", 2d }, + // { "key9", 3m }, + // { "key10", new ObjectId("5f63e882536de46d71877979") }, + // { "key11", Guid.Parse("3809d6d9-7618-4b3d-8044-2aa35fd02f31") }, + // { "key12", new List { 1, true, "string" } }, + // { + // "key13", new Dictionary + // { + // { "key1", RealmValue.Null }, + // { "key2", 1 }, + // { "key3", true }, + // { "key4", "string" }, + // } + // }, + // }, + //}; + + //[Test] + //public void ListManipulations() + //{ + // SyncTestHelpers.RunBaasTestAsync(async () => + // { + // var realm1 = await GetFLXIntegrationRealmAsync(); + // var realm2 = await GetFLXIntegrationRealmAsync(); + + // realm1.Subscriptions.Update(() => { realm1.Subscriptions.Add(realm1.All()); }); + // realm2.Subscriptions.Update(() => { realm2.Subscriptions.Add(realm2.All()); }); + + // var obj1 = realm1.Write(() => + // { + // var o = realm1.Add(new SyncAllTypesObject()); + // o.RealmValueProperty = new List(); + // return o; + // }); + + // var obj2 = await WaitForObjectAsync(obj1, realm2); + + // // Append elements one by one and verify that they are synced + // foreach (var realmTestValue in RealmValueCollectionTestValues) + // { + // realm1.Write(() => + // { + // obj1.RealmValueProperty.AsList().Add(realmTestValue); + // }); + // await realm1.SyncSession.WaitForUploadAsync(); + + // await realm2.SyncSession.WaitForDownloadAsync(); + // var expectedValues = obj1.RealmValueProperty.AsList(); + // var actualValues = obj2.RealmValueProperty.AsList(); + // Assert.That(expectedValues, Is.EqualTo(actualValues).Using(_rvComparer)); + // } + + // // Remove elements one by one and verify that changes are synced + // for (int index = 0; index < RealmValueCollectionTestValues.Count; index++) + // { + // realm1.Write(() => + // { + // obj1.RealmValueProperty.AsList().RemoveAt(0); + // }); + // await realm1.SyncSession.WaitForUploadAsync(); + + // await realm2.SyncSession.WaitForDownloadAsync(); + // var expectedValues = obj1.RealmValueProperty.AsList(); + // var actualValues = obj2.RealmValueProperty.AsList(); + // Assert.That(expectedValues, Is.EqualTo(actualValues).Using(_rvComparer)); + // } + + // // Insert/override elements at index 0 and verify that changes are synced + // foreach (var realmTestValue in RealmValueCollectionTestValues) + // { + // realm1.Write(() => + // { + // if (obj1.RealmValueProperty.AsList().Count == 0) + // { + // obj1.RealmValueProperty.AsList().Insert(0, realmTestValue); + // } + // else + // { + // obj1.RealmValueProperty.AsList()[0] = realmTestValue; + // } + // }); + // await realm1.SyncSession.WaitForUploadAsync(); + + // await realm2.SyncSession.WaitForDownloadAsync(); + // var expectedValues = obj1.RealmValueProperty.AsList(); + // var actualValues = obj2.RealmValueProperty.AsList(); + // Assert.That(expectedValues, Is.EqualTo(actualValues).Using(_rvComparer)); + // } + // }); + //} + + //[Test] + //public void DictionaryManipulations() + //{ + // SyncTestHelpers.RunBaasTestAsync(async () => + // { + // var realm1 = await GetFLXIntegrationRealmAsync(); + // realm1.Subscriptions.Update(() => + // { + // realm1.Subscriptions.Add(realm1.All()); + // }); + + // var realm2 = await GetFLXIntegrationRealmAsync(); + // realm2.Subscriptions.Update(() => + // { + // realm2.Subscriptions.Add(realm2.All()); + // }); + + // var obj1 = realm1.Write(() => + // { + // var o = realm1.Add(new SyncAllTypesObject()); + // o.RealmValueProperty = new Dictionary(); + // return o; + // }); + + // var obj2 = await WaitForObjectAsync(obj1, realm2); + + // for (int index = 0; index < RealmTestValuesWithCollections.Length; index++) + // { + // var realmTestValue = RealmValueCollectionTestValues[index]; + // realm1.Write(() => { obj1.RealmValueProperty.AsDictionary()[$"{index}"] = realmTestValue; }); + + // await realm1.SyncSession.WaitForUploadAsync(); + // await realm2.SyncSession.WaitForDownloadAsync(); + // var expectedValues = obj1.RealmValueProperty.AsDictionary(); + // var actualValues = obj2.RealmValueProperty.AsDictionary(); + // Assert.That(expectedValues, Is.EqualTo(actualValues).Using(_rvComparer)); + // } + + // for (int index = 0; index < RealmTestValuesWithCollections.Length; index++) + // { + // realm1.Write(() => { obj1.RealmValueProperty.AsDictionary().Remove($"{index}"); }); + // await realm1.SyncSession.WaitForUploadAsync(); + // await realm2.SyncSession.WaitForDownloadAsync(); + // var expectedValues = obj1.RealmValueProperty.AsDictionary(); + // var actualValues = obj2.RealmValueProperty.AsDictionary(); + // Assert.That(expectedValues, Is.EqualTo(actualValues).Using(_rvComparer)); + // } + // }); + //} + + //[Test] + //[Ignore("Crashes until https://github.com/realm/realm-core/issues/7488 is fixed")] + //public void CollectionMerge() + //{ + // SyncTestHelpers.RunBaasTestAsync(async () => + // { + // var realm1 = await GetFLXIntegrationRealmAsync(); + // realm1.Subscriptions.Update(() => + // { + // realm1.Subscriptions.Add(realm1.All()); + // }); + // var realm2 = await GetFLXIntegrationRealmAsync(); + // realm2.Subscriptions.Update(() => + // { + // realm2.Subscriptions.Add(realm2.All()); + // }); + + // var obj1 = realm1.Write(() => + // { + // var o = realm1.Add(new SyncAllTypesObject()); + // o.RealmValueProperty = new Dictionary + // { + // { "list", new List { 1, 2, 3 } }, + // { "dictionary", new Dictionary() { { "key1", 1 } } }, + // }; + // return o; + // }); + + // var obj2 = await WaitForObjectAsync(obj1, realm2); + + // realm1.SyncSession.Stop(); + // realm2.SyncSession.Stop(); + + // realm1.Write(() => + // { + // var list = obj1.RealmValueProperty.AsDictionary()["list"].AsList(); + // list.RemoveAt(0); + // list.Add(4); + // var dictionary = obj1.RealmValueProperty.AsDictionary()["dictionary"].AsDictionary(); + // dictionary.Remove("key1"); + // dictionary["key2"] = 2; + // }); + // realm2.Write(() => + // { + // var list = obj2.RealmValueProperty.AsDictionary()["list"].AsList(); + // list.RemoveAt(0); + // list.Add(5); + // var dictionary = obj2.RealmValueProperty.AsDictionary()["dictionary"].AsDictionary(); + // dictionary.Remove("key1"); + // dictionary["key3"] = 3; + // }); + + // realm1.SyncSession.Start(); + // realm2.SyncSession.Start(); + + // await realm1.SyncSession.WaitForUploadAsync(); + // await realm2.SyncSession.WaitForUploadAsync(); + // await realm1.SyncSession.WaitForDownloadAsync(); + // await realm2.SyncSession.WaitForDownloadAsync(); + + // var list1 = obj1.RealmValueProperty.AsDictionary()["list"].AsList(); + // var dictionary1 = obj1.RealmValueProperty.AsDictionary()["dictionary"].AsDictionary(); + // var list2 = obj1.RealmValueProperty.AsDictionary()["list"].AsList(); + // var dictionary2 = obj1.RealmValueProperty.AsDictionary()["dictionary"].AsDictionary(); + + // Assert.That(list1, new NotConstraint(Contains.Item((RealmValue)1))); + // Assert.That(list1, Contains.Item((RealmValue)2)); + // Assert.That(list1, Contains.Item((RealmValue)3)); + // Assert.That(list1, Contains.Item((RealmValue)4)); + // Assert.That(list1, Contains.Item((RealmValue)5)); + // Assert.That(list1, Is.EqualTo(list2).Using(_rvComparer)); + + // Assert.That(dictionary1, new NotConstraint(Contains.Key("key1"))); + // Assert.That(dictionary1, Contains.Key("key2")); + // Assert.That(dictionary1, Contains.Key("key3")); + // Assert.That(dictionary1, Is.EqualTo(dictionary2).Using(_rvComparer)); + // }); + //} private static RealmValue Clone(RealmValue original) {