From 02bc7dd5be2f39c6e3941f3f0e4c0cf9716a76f8 Mon Sep 17 00:00:00 2001 From: Nikola Irinchev Date: Tue, 21 May 2024 22:55:02 +0200 Subject: [PATCH 1/4] RNET-1145, RNET-1143: Fix reading schema from native (#3601) * Fix reading schema from native * Add more tests * tweak usage of obj() * Move metadata lookup inside the if --- CHANGELOG.md | 4 +- Realm/Realm/Handles/SharedRealmHandle.cs | 18 + Realm/Realm/Migration.cs | 22 + Realm/Realm/Native/PrimitiveValue.cs | 7 +- Realm/Realm/Realm.cs | 23 +- Realm/Realm/Schema/Property.cs | 7 +- Tests/Realm.Tests/Database/MigrationTests.cs | 129 +++++ .../Dotnet_3597_Old_generated.cs | 449 ++++++++++++++++++ .../Dotnet_3597_generated.cs | 446 +++++++++++++++++ wrappers/src/shared_realm_cs.cpp | 15 + 10 files changed, 1109 insertions(+), 11 deletions(-) create mode 100644 Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Dotnet_3597_Old_generated.cs create mode 100644 Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Dotnet_3597_generated.cs diff --git a/CHANGELOG.md b/CHANGELOG.md index dcbc9613d8..8f6c064ffb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,10 +1,10 @@ ## vNext (TBD) ### Enhancements -* None +* Added support for `Migration.FindInNewRealm` which is a helper that allows you to lookup the object in the post-migration Realm that corresponds to an object from the pre-migration Realm. (Issue [#3600](https://github.com/realm/realm-dotnet/issues/3600)) ### Fixed -* None +* Fixed an issue that would cause `RealmObject.DynamicApi.GetList/Set/Dictionary` to fail when the collection contains primitive values. (Issue [#3597](https://github.com/realm/realm-dotnet/issues/3597)) ### Compatibility * Realm Studio: 15.0.0 or later. diff --git a/Realm/Realm/Handles/SharedRealmHandle.cs b/Realm/Realm/Handles/SharedRealmHandle.cs index add76a9f13..ff223c3e46 100644 --- a/Realm/Realm/Handles/SharedRealmHandle.cs +++ b/Realm/Realm/Handles/SharedRealmHandle.cs @@ -229,6 +229,9 @@ public static extern void rename_property(SharedRealmHandle sharedRealm, [DllImport(InteropConfig.DLL_NAME, EntryPoint = "shared_realm_get_operating_system", CallingConvention = CallingConvention.Cdecl)] public static extern IntPtr get_operating_system(IntPtr buffer, IntPtr buffer_length); + [DllImport(InteropConfig.DLL_NAME, EntryPoint = "shared_realm_get_object_for_object", CallingConvention = CallingConvention.Cdecl)] + public static extern IntPtr get_object_for_object(SharedRealmHandle realmHandle, ObjectHandle handle, out NativeException ex); + #pragma warning restore SA1121 // Use built-in type alias #pragma warning restore IDE0049 // Use built-in type alias } @@ -677,6 +680,21 @@ public bool TryFindObject(TableKey tableKey, in RealmValue id, [MaybeNullWhen(fa return true; } + public bool TryFindObject(ObjectHandle handle, [MaybeNullWhen(false)] out ObjectHandle objectHandle) + { + var result = NativeMethods.get_object_for_object(this, handle, out var ex); + ex.ThrowIfNecessary(); + + if (result == IntPtr.Zero) + { + objectHandle = null; + return false; + } + + objectHandle = new ObjectHandle(this, result); + return true; + } + public void RenameProperty(string typeName, string oldName, string newName, IntPtr migrationSchema) { NativeMethods.rename_property(this, typeName, (IntPtr)typeName.Length, diff --git a/Realm/Realm/Migration.cs b/Realm/Realm/Migration.cs index 02dea33a7c..998e8bc738 100644 --- a/Realm/Realm/Migration.cs +++ b/Realm/Realm/Migration.cs @@ -115,5 +115,27 @@ public void RenameProperty(string typeName, string oldPropertyName, string newPr NewRealm.SharedRealmHandle.RenameProperty(typeName, oldPropertyName, newPropertyName, _migrationSchema); } + + /// + /// Finds an object obtained from in . + /// + /// The type of the object in the new realm. + /// The object obtained from the old realm. + /// The corresponding object post-migration or null if the object no longer exists in the new realm. + /// + /// + /// foreach (var oldPerson in migration.OldRealm.DynamicApi.All("Person")) + /// { + /// var newPerson = migration.FindInNewRealm<Person>(oldPerson) + /// newPerson.Name = $"{oldPerson.DynamicApi.Get<string>("FirstName")} {oldPerson.DynamicApi.Get<string>("LastName")}"; + /// } + /// + /// + public T? FindInNewRealm(IRealmObject obj) + where T : IRealmObject + { + Argument.Ensure(obj.IsManaged, "Only managed RealmObject instances can be looked up in the new Realm", nameof(obj)); + return NewRealm.FindExisting(obj); + } } } diff --git a/Realm/Realm/Native/PrimitiveValue.cs b/Realm/Realm/Native/PrimitiveValue.cs index 0f333fcfe9..b31ec8921b 100644 --- a/Realm/Realm/Native/PrimitiveValue.cs +++ b/Realm/Realm/Native/PrimitiveValue.cs @@ -353,7 +353,12 @@ public static StringValue AllocateFrom(string? value, Arena arena) public static implicit operator bool(in StringValue value) => value.data != null; - public static implicit operator string?(in StringValue value) => !value ? null : Encoding.UTF8.GetString(value.data, (int)value.size); + public static implicit operator string?(in StringValue value) => value.ToDotnetString(); + + public readonly string? ToDotnetString(bool treatEmptyAsNull = false) + => data == null || (size == 0 && treatEmptyAsNull) + ? null + : Encoding.UTF8.GetString(data, (int)size); } [StructLayout(LayoutKind.Sequential)] diff --git a/Realm/Realm/Realm.cs b/Realm/Realm/Realm.cs index 45e2138ed8..9d741994d7 100644 --- a/Realm/Realm/Realm.cs +++ b/Realm/Realm/Realm.cs @@ -1111,6 +1111,21 @@ internal IQueryable AllEmbedded() return default; } + // This is only used during migrations. obj here is the object in the old realm, and we're trying to find + // its counterpart post-migration. + internal T? FindExisting(IRealmObject obj) + { + ThrowIfDisposed(); + Argument.Ensure(obj.IsManaged, "Only managed objects can be used in FindExisting", nameof(obj)); + if (SharedRealmHandle.TryFindObject(obj.GetObjectHandle()!, out var objectHandle)) + { + var metadata = Metadata[typeof(T).GetMappedOrOriginalName()]; + return (T)MakeObject(metadata, objectHandle); + } + + return default; + } + #endregion Quick Find using primary key #region Thread Handover @@ -1589,7 +1604,7 @@ internal Dynamic(Realm realm) public IRealmObjectBase CreateObject(string className) => CreateObjectCore(className, primaryKey: null); /// - /// Factory for a managed object without a primary key in a realm. Only valid within a write . + /// Factory for a managed object with a primary key in a realm. Only valid within a write . /// /// A dynamically-accessed Realm object. /// The type of object to create as defined in the schema. @@ -1609,7 +1624,7 @@ internal Dynamic(Realm realm) public IRealmObjectBase CreateObject(string className, long? primaryKey) => CreateObjectCore(className, primaryKey); /// - /// Factory for a managed object without a primary key in a realm. Only valid within a write . + /// Factory for a managed object with a primary key in a realm. Only valid within a write . /// /// A dynamically-accessed Realm object. /// The type of object to create as defined in the schema. @@ -1629,7 +1644,7 @@ internal Dynamic(Realm realm) public IRealmObjectBase CreateObject(string className, string? primaryKey) => CreateObjectCore(className, primaryKey); /// - /// Factory for a managed object without a primary key in a realm. Only valid within a write . + /// Factory for a managed object with a primary key in a realm. Only valid within a write . /// /// A dynamically-accessed Realm object. /// The type of object to create as defined in the schema. @@ -1649,7 +1664,7 @@ internal Dynamic(Realm realm) public IRealmObjectBase CreateObject(string className, ObjectId? primaryKey) => CreateObjectCore(className, primaryKey); /// - /// Factory for a managed object without a primary key in a realm. Only valid within a write . + /// Factory for a managed object with a primary key in a realm. Only valid within a write . /// /// A dynamically-accessed Realm object. /// The type of object to create as defined in the schema. diff --git a/Realm/Realm/Schema/Property.cs b/Realm/Realm/Schema/Property.cs index b2324b4ca4..2378756816 100644 --- a/Realm/Realm/Schema/Property.cs +++ b/Realm/Realm/Schema/Property.cs @@ -170,11 +170,10 @@ public Property(string name, PropertyType type, string? objectType = null, strin internal Property(in SchemaProperty nativeProperty) { Name = nativeProperty.name!; - string? managedName = nativeProperty.managed_name; - ManagedName = !string.IsNullOrEmpty(managedName) ? managedName! : Name; + ManagedName = nativeProperty.managed_name.ToDotnetString(treatEmptyAsNull: true) ?? Name; Type = nativeProperty.type; - ObjectType = nativeProperty.object_type; - LinkOriginPropertyName = nativeProperty.link_origin_property_name; + ObjectType = nativeProperty.object_type.ToDotnetString(treatEmptyAsNull: true); + LinkOriginPropertyName = nativeProperty.link_origin_property_name.ToDotnetString(treatEmptyAsNull: true); IsPrimaryKey = nativeProperty.is_primary; IndexType = nativeProperty.index; } diff --git a/Tests/Realm.Tests/Database/MigrationTests.cs b/Tests/Realm.Tests/Database/MigrationTests.cs index 20ab122c9d..d507100660 100644 --- a/Tests/Realm.Tests/Database/MigrationTests.cs +++ b/Tests/Realm.Tests/Database/MigrationTests.cs @@ -834,6 +834,113 @@ public void Migration_ToEmbedded_DeletesOrphans() Assert.That(newRealm.AllEmbedded().Count(), Is.EqualTo(1)); Assert.That(newRealm.AllEmbedded().Any(e => e.Value == "bar"), Is.False); } + + [Test] + public void Migration_FindInNewRealm_WhenObjectIsDeleted_ReturnsNull() + { + var oldConfig = new RealmConfiguration(Guid.NewGuid().ToString()) + { + Schema = new[] + { + typeof(Dotnet_3597_Old) + } + }; + + using (var oldRealm = GetRealm(oldConfig)) + { + oldRealm.Write(() => + { + oldRealm.Add(new Dotnet_3597_Old { FloatProp = 1, IntProp = 1 }); + oldRealm.Add(new Dotnet_3597_Old { FloatProp = 2, IntProp = 2 }); + }); + } + + var newConfig = new RealmConfiguration(oldConfig.DatabasePath) + { + Schema = new[] + { + typeof(Dotnet_3597) + }, + SchemaVersion = 2, + MigrationCallback = (migration, version) => + { + var oldObjects = migration.OldRealm.DynamicApi.All(nameof(Dotnet_3597)).ToArray(); + var old1 = oldObjects.First(o => o.DynamicApi.Get("IntProp") == 1); + var old2 = oldObjects.First(o => o.DynamicApi.Get("IntProp") == 2); + + var newObjects = migration.NewRealm.All().ToArray(); + var new1 = newObjects.First(o => o.IntProp == 1); + var new2 = newObjects.First(o => o.IntProp == 2); + + Assert.That(migration.FindInNewRealm(old1), Is.EqualTo(new1)); + Assert.That(migration.FindInNewRealm(old2), Is.EqualTo(new2)); + + migration.NewRealm.Remove(new1); + + Assert.That(migration.FindInNewRealm(old1), Is.Null); + } + }; + + var newRealm = GetRealm(newConfig); + Assert.That(newRealm.All().Count(), Is.EqualTo(1)); + } + + // Test for https://github.com/realm/realm-dotnet/issues/3597 + [Test] + public void Migration_MigratesListOfFloats() + { + var oldConfig = new RealmConfiguration(Guid.NewGuid().ToString()) + { + Schema = new[] + { + typeof(Dotnet_3597_Old) + } + }; + + using (var oldRealm = GetRealm(oldConfig)) + { + oldRealm.Write(() => + { + oldRealm.Add(new Dotnet_3597_Old + { + FloatProp = 3.14f, + FloatList = + { + 1, + 2, + -1.23f + } + }); + }); + } + + var newConfig = new RealmConfiguration(oldConfig.DatabasePath) + { + Schema = new[] + { + typeof(Dotnet_3597) + }, + SchemaVersion = 2, + MigrationCallback = (migration, version) => + { + foreach (var item in migration.OldRealm.DynamicApi.All(nameof(Dotnet_3597))) + { + var newItem = migration.FindInNewRealm(item)!; + newItem.FloatProp = item.DynamicApi.Get("FloatProp").ToString()!; + foreach (var floatValue in item.DynamicApi.GetList("FloatList")) + { + newItem.FloatList.Add(floatValue.ToString()!); + } + } + } + }; + + var newRealm = GetRealm(newConfig); + + var obj = newRealm.All().Single(); + Assert.That(obj.FloatProp, Is.EqualTo("3.14")); + CollectionAssert.AreEqual(obj.FloatList, new[] { "1", "2", "-1.23" }); + } } [Explicit] @@ -884,4 +991,26 @@ public partial class ObjectEmbedded : TestEmbeddedObject { public string? Value { get; set; } } + + [Explicit] + [MapTo("Dotnet_3597")] + public partial class Dotnet_3597_Old : TestRealmObject + { + public int IntProp { get; set; } + + public float? FloatProp { get; set; } + + public IList FloatList { get; } + } + + [Explicit] + [MapTo("Dotnet_3597")] + public partial class Dotnet_3597 : TestRealmObject + { + public int IntProp { get; set; } + + public string FloatProp { get; set; } + + public IList FloatList { get; } + } } diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Dotnet_3597_Old_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Dotnet_3597_Old_generated.cs new file mode 100644 index 0000000000..be32bf8ac4 --- /dev/null +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Dotnet_3597_Old_generated.cs @@ -0,0 +1,449 @@ +// +#nullable enable + +using MongoDB.Bson.Serialization; +using NUnit.Framework; +using Realms; +using Realms.Exceptions; +using Realms.Extensions; +using Realms.Schema; +using Realms.Tests.Database; +using Realms.Weaving; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Linq; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.Serialization; +using System.Xml.Serialization; +using TestEmbeddedObject = Realms.IEmbeddedObject; +using TestRealmObject = Realms.IRealmObject; + +namespace Realms.Tests.Database +{ + [Generated] + [Woven(typeof(Dotnet_3597_OldObjectHelper)), Realms.Preserve(AllMembers = true)] + public partial class Dotnet_3597_Old : IRealmObject, INotifyPropertyChanged, IReflectableType + { + + [Realms.Preserve] + static Dotnet_3597_Old() + { + Realms.Serialization.RealmObjectSerializer.Register(new Dotnet_3597_OldSerializer()); + } + + /// + /// Defines the schema for the class. + /// + public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Dotnet_3597", ObjectSchema.ObjectType.RealmObject) + { + Realms.Schema.Property.Primitive("IntProp", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "IntProp"), + Realms.Schema.Property.Primitive("FloatProp", Realms.RealmValueType.Float, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "FloatProp"), + Realms.Schema.Property.PrimitiveList("FloatList", Realms.RealmValueType.Float, areElementsNullable: true, managedName: "FloatList"), + }.Build(); + + #region IRealmObject implementation + + private IDotnet_3597_OldAccessor? _accessor; + + Realms.IRealmAccessor Realms.IRealmObjectBase.Accessor => Accessor; + + private IDotnet_3597_OldAccessor Accessor => _accessor ??= new Dotnet_3597_OldUnmanagedAccessor(typeof(Dotnet_3597_Old)); + + /// + [IgnoreDataMember, XmlIgnore] + public bool IsManaged => Accessor.IsManaged; + + /// + [IgnoreDataMember, XmlIgnore] + public bool IsValid => Accessor.IsValid; + + /// + [IgnoreDataMember, XmlIgnore] + public bool IsFrozen => Accessor.IsFrozen; + + /// + [IgnoreDataMember, XmlIgnore] + public Realms.Realm? Realm => Accessor.Realm; + + /// + [IgnoreDataMember, XmlIgnore] + public Realms.Schema.ObjectSchema ObjectSchema => Accessor.ObjectSchema!; + + /// + [IgnoreDataMember, XmlIgnore] + public Realms.DynamicObjectApi DynamicApi => Accessor.DynamicApi; + + /// + [IgnoreDataMember, XmlIgnore] + public int BacklinksCount => Accessor.BacklinksCount; + + void ISettableManagedAccessor.SetManagedAccessor(Realms.IRealmAccessor managedAccessor, Realms.Weaving.IRealmObjectHelper? helper, bool update, bool skipDefaults) + { + var newAccessor = (IDotnet_3597_OldAccessor)managedAccessor; + var oldAccessor = _accessor; + _accessor = newAccessor; + + if (helper != null && oldAccessor != null) + { + if (!skipDefaults) + { + newAccessor.FloatList.Clear(); + } + + if (!skipDefaults || oldAccessor.IntProp != default(int)) + { + newAccessor.IntProp = oldAccessor.IntProp; + } + if (!skipDefaults || oldAccessor.FloatProp != default(float?)) + { + newAccessor.FloatProp = oldAccessor.FloatProp; + } + Realms.CollectionExtensions.PopulateCollection(oldAccessor.FloatList, newAccessor.FloatList, update, skipDefaults); + } + + if (_propertyChanged != null) + { + SubscribeForNotifications(); + } + + OnManaged(); + } + + #endregion + + /// + /// Called when the object has been managed by a Realm. + /// + /// + /// This method will be called either when a managed object is materialized or when an unmanaged object has been + /// added to the Realm. It can be useful for providing some initialization logic as when the constructor is invoked, + /// it is not yet clear whether the object is managed or not. + /// + partial void OnManaged(); + + private event PropertyChangedEventHandler? _propertyChanged; + + /// + public event PropertyChangedEventHandler? PropertyChanged + { + add + { + if (_propertyChanged == null) + { + SubscribeForNotifications(); + } + + _propertyChanged += value; + } + + remove + { + _propertyChanged -= value; + + if (_propertyChanged == null) + { + UnsubscribeFromNotifications(); + } + } + } + + /// + /// Called when a property has changed on this class. + /// + /// The name of the property. + /// + /// For this method to be called, you need to have first subscribed to . + /// This can be used to react to changes to the current object, e.g. raising for computed properties. + /// + /// + /// + /// class MyClass : IRealmObject + /// { + /// public int StatusCodeRaw { get; set; } + /// public StatusCodeEnum StatusCode => (StatusCodeEnum)StatusCodeRaw; + /// partial void OnPropertyChanged(string propertyName) + /// { + /// if (propertyName == nameof(StatusCodeRaw)) + /// { + /// RaisePropertyChanged(nameof(StatusCode)); + /// } + /// } + /// } + /// + /// Here, we have a computed property that depends on a persisted one. In order to notify any + /// subscribers that StatusCode has changed, we implement and + /// raise manually by calling . + /// + partial void OnPropertyChanged(string? propertyName); + + private void RaisePropertyChanged([CallerMemberName] string propertyName = "") + { + _propertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); + OnPropertyChanged(propertyName); + } + + private void SubscribeForNotifications() + { + Accessor.SubscribeForNotifications(RaisePropertyChanged); + } + + private void UnsubscribeFromNotifications() + { + Accessor.UnsubscribeFromNotifications(); + } + + /// + /// Converts a to . Equivalent to . + /// + /// The to convert. + /// The stored in the . + public static explicit operator Dotnet_3597_Old?(Realms.RealmValue val) => val.Type == Realms.RealmValueType.Null ? null : val.AsRealmObject(); + + /// + /// Implicitly constructs a from . + /// + /// The value to store in the . + /// A containing the supplied . + public static implicit operator Realms.RealmValue(Dotnet_3597_Old? val) => val == null ? Realms.RealmValue.Null : Realms.RealmValue.Object(val); + + /// + /// Implicitly constructs a from . + /// + /// The value to store in the . + /// A containing the supplied . + public static implicit operator Realms.QueryArgument(Dotnet_3597_Old? val) => (Realms.RealmValue)val; + + /// + [EditorBrowsable(EditorBrowsableState.Never)] + public TypeInfo GetTypeInfo() => Accessor.GetTypeInfo(this); + + /// + public override bool Equals(object? obj) + { + if (obj is null) + { + return false; + } + + if (ReferenceEquals(this, obj)) + { + return true; + } + + if (obj is InvalidObject) + { + return !IsValid; + } + + if (!(obj is Realms.IRealmObjectBase iro)) + { + return false; + } + + return Accessor.Equals(iro.Accessor); + } + + /// + public override int GetHashCode() => IsManaged ? Accessor.GetHashCode() : base.GetHashCode(); + + /// + public override string? ToString() => Accessor.ToString(); + + [EditorBrowsable(EditorBrowsableState.Never), Realms.Preserve(AllMembers = true)] + private class Dotnet_3597_OldObjectHelper : Realms.Weaving.IRealmObjectHelper + { + public void CopyToRealm(Realms.IRealmObjectBase instance, bool update, bool skipDefaults) + { + throw new InvalidOperationException("This method should not be called for source generated classes."); + } + + public Realms.ManagedAccessor CreateAccessor() => new Dotnet_3597_OldManagedAccessor(); + + public Realms.IRealmObjectBase CreateInstance() => new Dotnet_3597_Old(); + + public bool TryGetPrimaryKeyValue(Realms.IRealmObjectBase instance, out RealmValue value) + { + value = RealmValue.Null; + return false; + } + } + + [EditorBrowsable(EditorBrowsableState.Never), Realms.Preserve(AllMembers = true)] + internal interface IDotnet_3597_OldAccessor : Realms.IRealmAccessor + { + int IntProp { get; set; } + + float? FloatProp { get; set; } + + System.Collections.Generic.IList FloatList { get; } + } + + [EditorBrowsable(EditorBrowsableState.Never), Realms.Preserve(AllMembers = true)] + private class Dotnet_3597_OldManagedAccessor : Realms.ManagedAccessor, IDotnet_3597_OldAccessor + { + public int IntProp + { + get => (int)GetValue("IntProp"); + set => SetValue("IntProp", value); + } + + public float? FloatProp + { + get => (float?)GetValue("FloatProp"); + set => SetValue("FloatProp", value); + } + + private System.Collections.Generic.IList _floatList = null!; + public System.Collections.Generic.IList FloatList + { + get + { + if (_floatList == null) + { + _floatList = GetListValue("FloatList"); + } + + return _floatList; + } + } + } + + [EditorBrowsable(EditorBrowsableState.Never), Realms.Preserve(AllMembers = true)] + private class Dotnet_3597_OldUnmanagedAccessor : Realms.UnmanagedAccessor, IDotnet_3597_OldAccessor + { + public override ObjectSchema ObjectSchema => Dotnet_3597_Old.RealmSchema; + + private int _intProp; + public int IntProp + { + get => _intProp; + set + { + _intProp = value; + RaisePropertyChanged("IntProp"); + } + } + + private float? _floatProp; + public float? FloatProp + { + get => _floatProp; + set + { + _floatProp = value; + RaisePropertyChanged("FloatProp"); + } + } + + public System.Collections.Generic.IList FloatList { get; } = new List(); + + public Dotnet_3597_OldUnmanagedAccessor(Type objectType) : base(objectType) + { + } + + public override Realms.RealmValue GetValue(string propertyName) + { + return propertyName switch + { + "IntProp" => _intProp, + "FloatProp" => _floatProp, + _ => throw new MissingMemberException($"The object does not have a gettable Realm property with name {propertyName}"), + }; + } + + public override void SetValue(string propertyName, Realms.RealmValue val) + { + switch (propertyName) + { + case "IntProp": + IntProp = (int)val; + return; + case "FloatProp": + FloatProp = (float?)val; + return; + default: + throw new MissingMemberException($"The object does not have a settable Realm property with name {propertyName}"); + } + } + + public override void SetValueUnique(string propertyName, Realms.RealmValue val) + { + throw new InvalidOperationException("Cannot set the value of an non primary key property with SetValueUnique"); + } + + public override IList GetListValue(string propertyName) + { + return propertyName switch + { + "FloatList" => (IList)FloatList, + _ => throw new MissingMemberException($"The object does not have a Realm list property with name {propertyName}"), + }; + } + + public override ISet GetSetValue(string propertyName) + { + throw new MissingMemberException($"The object does not have a Realm set property with name {propertyName}"); + } + + public override IDictionary GetDictionaryValue(string propertyName) + { + throw new MissingMemberException($"The object does not have a Realm dictionary property with name {propertyName}"); + } + } + + [EditorBrowsable(EditorBrowsableState.Never), Realms.Preserve(AllMembers = true)] + private class Dotnet_3597_OldSerializer : Realms.Serialization.RealmObjectSerializerBase + { + public override string SchemaName => "Dotnet_3597"; + + protected override void SerializeValue(MongoDB.Bson.Serialization.BsonSerializationContext context, BsonSerializationArgs args, Dotnet_3597_Old value) + { + context.Writer.WriteStartDocument(); + + WriteValue(context, args, "IntProp", value.IntProp); + WriteValue(context, args, "FloatProp", value.FloatProp); + WriteList(context, args, "FloatList", value.FloatList); + + context.Writer.WriteEndDocument(); + } + + protected override Dotnet_3597_Old CreateInstance() => new Dotnet_3597_Old(); + + protected override void ReadValue(Dotnet_3597_Old instance, string name, BsonDeserializationContext context) + { + switch (name) + { + case "IntProp": + instance.IntProp = BsonSerializer.LookupSerializer().Deserialize(context); + break; + case "FloatProp": + instance.FloatProp = BsonSerializer.LookupSerializer().Deserialize(context); + break; + case "FloatList": + ReadArray(instance, name, context); + break; + default: + context.Reader.SkipValue(); + break; + } + } + + protected override void ReadArrayElement(Dotnet_3597_Old instance, string name, BsonDeserializationContext context) + { + switch (name) + { + case "FloatList": + instance.FloatList.Add(BsonSerializer.LookupSerializer().Deserialize(context)); + break; + } + } + + protected override void ReadDocumentField(Dotnet_3597_Old instance, string name, string fieldName, BsonDeserializationContext context) + { + // No persisted dictionary properties to deserialize + } + } + } +} diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Dotnet_3597_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Dotnet_3597_generated.cs new file mode 100644 index 0000000000..eca00f0a47 --- /dev/null +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Dotnet_3597_generated.cs @@ -0,0 +1,446 @@ +// +#nullable enable + +using MongoDB.Bson.Serialization; +using NUnit.Framework; +using Realms; +using Realms.Exceptions; +using Realms.Extensions; +using Realms.Schema; +using Realms.Tests.Database; +using Realms.Weaving; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Linq; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.Serialization; +using System.Xml.Serialization; +using TestEmbeddedObject = Realms.IEmbeddedObject; +using TestRealmObject = Realms.IRealmObject; + +namespace Realms.Tests.Database +{ + [Generated] + [Woven(typeof(Dotnet_3597ObjectHelper)), Realms.Preserve(AllMembers = true)] + public partial class Dotnet_3597 : IRealmObject, INotifyPropertyChanged, IReflectableType + { + + [Realms.Preserve] + static Dotnet_3597() + { + Realms.Serialization.RealmObjectSerializer.Register(new Dotnet_3597Serializer()); + } + + /// + /// Defines the schema for the class. + /// + public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Dotnet_3597", ObjectSchema.ObjectType.RealmObject) + { + Realms.Schema.Property.Primitive("IntProp", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "IntProp"), + Realms.Schema.Property.Primitive("FloatProp", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "FloatProp"), + Realms.Schema.Property.PrimitiveList("FloatList", Realms.RealmValueType.String, areElementsNullable: false, managedName: "FloatList"), + }.Build(); + + #region IRealmObject implementation + + private IDotnet_3597Accessor? _accessor; + + Realms.IRealmAccessor Realms.IRealmObjectBase.Accessor => Accessor; + + private IDotnet_3597Accessor Accessor => _accessor ??= new Dotnet_3597UnmanagedAccessor(typeof(Dotnet_3597)); + + /// + [IgnoreDataMember, XmlIgnore] + public bool IsManaged => Accessor.IsManaged; + + /// + [IgnoreDataMember, XmlIgnore] + public bool IsValid => Accessor.IsValid; + + /// + [IgnoreDataMember, XmlIgnore] + public bool IsFrozen => Accessor.IsFrozen; + + /// + [IgnoreDataMember, XmlIgnore] + public Realms.Realm? Realm => Accessor.Realm; + + /// + [IgnoreDataMember, XmlIgnore] + public Realms.Schema.ObjectSchema ObjectSchema => Accessor.ObjectSchema!; + + /// + [IgnoreDataMember, XmlIgnore] + public Realms.DynamicObjectApi DynamicApi => Accessor.DynamicApi; + + /// + [IgnoreDataMember, XmlIgnore] + public int BacklinksCount => Accessor.BacklinksCount; + + void ISettableManagedAccessor.SetManagedAccessor(Realms.IRealmAccessor managedAccessor, Realms.Weaving.IRealmObjectHelper? helper, bool update, bool skipDefaults) + { + var newAccessor = (IDotnet_3597Accessor)managedAccessor; + var oldAccessor = _accessor; + _accessor = newAccessor; + + if (helper != null && oldAccessor != null) + { + if (!skipDefaults) + { + newAccessor.FloatList.Clear(); + } + + if (!skipDefaults || oldAccessor.IntProp != default(int)) + { + newAccessor.IntProp = oldAccessor.IntProp; + } + newAccessor.FloatProp = oldAccessor.FloatProp; + Realms.CollectionExtensions.PopulateCollection(oldAccessor.FloatList, newAccessor.FloatList, update, skipDefaults); + } + + if (_propertyChanged != null) + { + SubscribeForNotifications(); + } + + OnManaged(); + } + + #endregion + + /// + /// Called when the object has been managed by a Realm. + /// + /// + /// This method will be called either when a managed object is materialized or when an unmanaged object has been + /// added to the Realm. It can be useful for providing some initialization logic as when the constructor is invoked, + /// it is not yet clear whether the object is managed or not. + /// + partial void OnManaged(); + + private event PropertyChangedEventHandler? _propertyChanged; + + /// + public event PropertyChangedEventHandler? PropertyChanged + { + add + { + if (_propertyChanged == null) + { + SubscribeForNotifications(); + } + + _propertyChanged += value; + } + + remove + { + _propertyChanged -= value; + + if (_propertyChanged == null) + { + UnsubscribeFromNotifications(); + } + } + } + + /// + /// Called when a property has changed on this class. + /// + /// The name of the property. + /// + /// For this method to be called, you need to have first subscribed to . + /// This can be used to react to changes to the current object, e.g. raising for computed properties. + /// + /// + /// + /// class MyClass : IRealmObject + /// { + /// public int StatusCodeRaw { get; set; } + /// public StatusCodeEnum StatusCode => (StatusCodeEnum)StatusCodeRaw; + /// partial void OnPropertyChanged(string propertyName) + /// { + /// if (propertyName == nameof(StatusCodeRaw)) + /// { + /// RaisePropertyChanged(nameof(StatusCode)); + /// } + /// } + /// } + /// + /// Here, we have a computed property that depends on a persisted one. In order to notify any + /// subscribers that StatusCode has changed, we implement and + /// raise manually by calling . + /// + partial void OnPropertyChanged(string? propertyName); + + private void RaisePropertyChanged([CallerMemberName] string propertyName = "") + { + _propertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); + OnPropertyChanged(propertyName); + } + + private void SubscribeForNotifications() + { + Accessor.SubscribeForNotifications(RaisePropertyChanged); + } + + private void UnsubscribeFromNotifications() + { + Accessor.UnsubscribeFromNotifications(); + } + + /// + /// Converts a to . Equivalent to . + /// + /// The to convert. + /// The stored in the . + public static explicit operator Dotnet_3597?(Realms.RealmValue val) => val.Type == Realms.RealmValueType.Null ? null : val.AsRealmObject(); + + /// + /// Implicitly constructs a from . + /// + /// The value to store in the . + /// A containing the supplied . + public static implicit operator Realms.RealmValue(Dotnet_3597? val) => val == null ? Realms.RealmValue.Null : Realms.RealmValue.Object(val); + + /// + /// Implicitly constructs a from . + /// + /// The value to store in the . + /// A containing the supplied . + public static implicit operator Realms.QueryArgument(Dotnet_3597? val) => (Realms.RealmValue)val; + + /// + [EditorBrowsable(EditorBrowsableState.Never)] + public TypeInfo GetTypeInfo() => Accessor.GetTypeInfo(this); + + /// + public override bool Equals(object? obj) + { + if (obj is null) + { + return false; + } + + if (ReferenceEquals(this, obj)) + { + return true; + } + + if (obj is InvalidObject) + { + return !IsValid; + } + + if (!(obj is Realms.IRealmObjectBase iro)) + { + return false; + } + + return Accessor.Equals(iro.Accessor); + } + + /// + public override int GetHashCode() => IsManaged ? Accessor.GetHashCode() : base.GetHashCode(); + + /// + public override string? ToString() => Accessor.ToString(); + + [EditorBrowsable(EditorBrowsableState.Never), Realms.Preserve(AllMembers = true)] + private class Dotnet_3597ObjectHelper : Realms.Weaving.IRealmObjectHelper + { + public void CopyToRealm(Realms.IRealmObjectBase instance, bool update, bool skipDefaults) + { + throw new InvalidOperationException("This method should not be called for source generated classes."); + } + + public Realms.ManagedAccessor CreateAccessor() => new Dotnet_3597ManagedAccessor(); + + public Realms.IRealmObjectBase CreateInstance() => new Dotnet_3597(); + + public bool TryGetPrimaryKeyValue(Realms.IRealmObjectBase instance, out RealmValue value) + { + value = RealmValue.Null; + return false; + } + } + + [EditorBrowsable(EditorBrowsableState.Never), Realms.Preserve(AllMembers = true)] + internal interface IDotnet_3597Accessor : Realms.IRealmAccessor + { + int IntProp { get; set; } + + string FloatProp { get; set; } + + System.Collections.Generic.IList FloatList { get; } + } + + [EditorBrowsable(EditorBrowsableState.Never), Realms.Preserve(AllMembers = true)] + private class Dotnet_3597ManagedAccessor : Realms.ManagedAccessor, IDotnet_3597Accessor + { + public int IntProp + { + get => (int)GetValue("IntProp"); + set => SetValue("IntProp", value); + } + + public string FloatProp + { + get => (string)GetValue("FloatProp")!; + set => SetValue("FloatProp", value); + } + + private System.Collections.Generic.IList _floatList = null!; + public System.Collections.Generic.IList FloatList + { + get + { + if (_floatList == null) + { + _floatList = GetListValue("FloatList"); + } + + return _floatList; + } + } + } + + [EditorBrowsable(EditorBrowsableState.Never), Realms.Preserve(AllMembers = true)] + private class Dotnet_3597UnmanagedAccessor : Realms.UnmanagedAccessor, IDotnet_3597Accessor + { + public override ObjectSchema ObjectSchema => Dotnet_3597.RealmSchema; + + private int _intProp; + public int IntProp + { + get => _intProp; + set + { + _intProp = value; + RaisePropertyChanged("IntProp"); + } + } + + private string _floatProp = null!; + public string FloatProp + { + get => _floatProp; + set + { + _floatProp = value; + RaisePropertyChanged("FloatProp"); + } + } + + public System.Collections.Generic.IList FloatList { get; } = new List(); + + public Dotnet_3597UnmanagedAccessor(Type objectType) : base(objectType) + { + } + + public override Realms.RealmValue GetValue(string propertyName) + { + return propertyName switch + { + "IntProp" => _intProp, + "FloatProp" => _floatProp, + _ => throw new MissingMemberException($"The object does not have a gettable Realm property with name {propertyName}"), + }; + } + + public override void SetValue(string propertyName, Realms.RealmValue val) + { + switch (propertyName) + { + case "IntProp": + IntProp = (int)val; + return; + case "FloatProp": + FloatProp = (string)val!; + return; + default: + throw new MissingMemberException($"The object does not have a settable Realm property with name {propertyName}"); + } + } + + public override void SetValueUnique(string propertyName, Realms.RealmValue val) + { + throw new InvalidOperationException("Cannot set the value of an non primary key property with SetValueUnique"); + } + + public override IList GetListValue(string propertyName) + { + return propertyName switch + { + "FloatList" => (IList)FloatList, + _ => throw new MissingMemberException($"The object does not have a Realm list property with name {propertyName}"), + }; + } + + public override ISet GetSetValue(string propertyName) + { + throw new MissingMemberException($"The object does not have a Realm set property with name {propertyName}"); + } + + public override IDictionary GetDictionaryValue(string propertyName) + { + throw new MissingMemberException($"The object does not have a Realm dictionary property with name {propertyName}"); + } + } + + [EditorBrowsable(EditorBrowsableState.Never), Realms.Preserve(AllMembers = true)] + private class Dotnet_3597Serializer : Realms.Serialization.RealmObjectSerializerBase + { + public override string SchemaName => "Dotnet_3597"; + + protected override void SerializeValue(MongoDB.Bson.Serialization.BsonSerializationContext context, BsonSerializationArgs args, Dotnet_3597 value) + { + context.Writer.WriteStartDocument(); + + WriteValue(context, args, "IntProp", value.IntProp); + WriteValue(context, args, "FloatProp", value.FloatProp); + WriteList(context, args, "FloatList", value.FloatList); + + context.Writer.WriteEndDocument(); + } + + protected override Dotnet_3597 CreateInstance() => new Dotnet_3597(); + + protected override void ReadValue(Dotnet_3597 instance, string name, BsonDeserializationContext context) + { + switch (name) + { + case "IntProp": + instance.IntProp = BsonSerializer.LookupSerializer().Deserialize(context); + break; + case "FloatProp": + instance.FloatProp = BsonSerializer.LookupSerializer().Deserialize(context); + break; + case "FloatList": + ReadArray(instance, name, context); + break; + default: + context.Reader.SkipValue(); + break; + } + } + + protected override void ReadArrayElement(Dotnet_3597 instance, string name, BsonDeserializationContext context) + { + switch (name) + { + case "FloatList": + instance.FloatList.Add(BsonSerializer.LookupSerializer().Deserialize(context)); + break; + } + } + + protected override void ReadDocumentField(Dotnet_3597 instance, string name, string fieldName, BsonDeserializationContext context) + { + // No persisted dictionary properties to deserialize + } + } + } +} diff --git a/wrappers/src/shared_realm_cs.cpp b/wrappers/src/shared_realm_cs.cpp index 25661bfc71..8b1d6b9061 100644 --- a/wrappers/src/shared_realm_cs.cpp +++ b/wrappers/src/shared_realm_cs.cpp @@ -693,6 +693,21 @@ REALM_EXPORT Object* shared_realm_get_object_for_primary_key(SharedRealm& realm, }); } +REALM_EXPORT Object* shared_realm_get_object_for_object(SharedRealm& realm, Object& object, NativeException::Marshallable& ex) +{ + return handle_errors(ex, [&]() -> Object* { + realm->verify_thread(); + + auto table = realm->read_group().get_table(object.get_object_schema().table_key); + auto obj = table->try_get_object(object.get_obj().get_key()); + if (!obj) { + return nullptr; + } + + return new Object(realm, std::move(obj)); + }); +} + REALM_EXPORT Results* shared_realm_create_results(SharedRealm& realm, TableKey table_key, NativeException::Marshallable& ex) { return handle_errors(ex, [&]() { From 3130057c20d3f8fe195b9d2ccb90f602b38c57dd Mon Sep 17 00:00:00 2001 From: Nikola Irinchev Date: Wed, 22 May 2024 00:05:17 +0200 Subject: [PATCH 2/4] Update to Core 14.7.0 (#3605) --- CHANGELOG.md | 4 +++- wrappers/realm-core | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 8f6c064ffb..180fb03635 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,13 +4,15 @@ * Added support for `Migration.FindInNewRealm` which is a helper that allows you to lookup the object in the post-migration Realm that corresponds to an object from the pre-migration Realm. (Issue [#3600](https://github.com/realm/realm-dotnet/issues/3600)) ### Fixed +* Accessing `App.CurrentUser` from within a `User.Changed` notification would deadlock. (Core 14.7.0) +* Inserting the same link to the same key in a dictionary more than once would incorrectly create multiple backlinks to the object. This did not appear to cause any crashes later, but would have affected the value returned by `RealmObject.BacklinksCount` and queries involving backlinks counts. (Core 14.7.0) * Fixed an issue that would cause `RealmObject.DynamicApi.GetList/Set/Dictionary` to fail when the collection contains primitive values. (Issue [#3597](https://github.com/realm/realm-dotnet/issues/3597)) ### Compatibility * Realm Studio: 15.0.0 or later. ### Internal -* Using Core x.y.z. +* Using Core 14.7.0. ## 12.1.0 (2024-05-01) diff --git a/wrappers/realm-core b/wrappers/realm-core index cde3adb764..14349903d1 160000 --- a/wrappers/realm-core +++ b/wrappers/realm-core @@ -1 +1 @@ -Subproject commit cde3adb7649d3361806dbbae0cf353b8fdc4d54e +Subproject commit 14349903d1315e13758537a735a649bd1c2d2fec From 1298cb1c08d1cc239e5466f2d16f14c6f2e8db39 Mon Sep 17 00:00:00 2001 From: Nikola Irinchev Date: Wed, 22 May 2024 00:06:39 +0200 Subject: [PATCH 3/4] Revert "Hide collections in mixed from public API" (#3606) * Update to Core 14.7.0 * Revert "Hide collections in mixed from public API (#3575)" This reverts commit 7aae3581fb071459ddd8c0c82c79f129ab172779. * Fix changelog --- CHANGELOG.md | 13 + Realm/Realm/DatabaseTypes/RealmValue.cs | 48 +- .../Database/RealmValueWithCollections.cs | 2260 ++++++++--------- .../Sync/DataTypeSynchronizationTests.cs | 816 +++--- 4 files changed, 1575 insertions(+), 1562 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 180fb03635..0ce10a3bed 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,19 @@ ### Enhancements * Added support for `Migration.FindInNewRealm` which is a helper that allows you to lookup the object in the post-migration Realm that corresponds to an object from the pre-migration Realm. (Issue [#3600](https://github.com/realm/realm-dotnet/issues/3600)) +* 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)) ### Fixed * Accessing `App.CurrentUser` from within a `User.Changed` notification would deadlock. (Core 14.7.0) diff --git a/Realm/Realm/DatabaseTypes/RealmValue.cs b/Realm/Realm/DatabaseTypes/RealmValue.cs index b4a5b2f1d1..f94deaefee 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. - internal static RealmValue List(IList value) => new(value); + public 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. - internal static RealmValue Dictionary(IDictionary value) => new(value); + public 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. - internal IList AsList() + public IList AsList() { EnsureType("List", RealmValueType.List); return _listValue!; @@ -521,7 +521,7 @@ internal IList AsList() /// /// Thrown if the underlying value is not of type . /// A dictionary representing the value stored in the database. - internal IDictionary AsDictionary() + public 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 8f9381d289..436746b165 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(); - -// 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 }, -// }; + private readonly RealmValueComparer _rvComparer = new(); -// var listVal = new List { innerList, innerDict }; + public static Func> ListGenerator = i => new List { $"inner{i}", i }; + public static Func> DictGenerator = i => new Dictionary { { "s1", i }, { "s2", $"ah{i}" } }; -// var rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = listVal })); + 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)); -// _realm.Write(() => -// { -// Assert.That(rvo.RealmValueProperty.AsList().Remove(innerList), Is.False); -// Assert.That(rvo.RealmValueProperty.AsList().Remove(innerDict), Is.False); -// }); -// } + 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) }; -// [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 rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = originalList })); -// var innerDict = DictGenerator(1); + var callbacks = new List(); + using var token = rvo.RealmValueProperty.AsList().SubscribeForNotifications((_, changes) => + { + if (changes != null) + { + callbacks.Add(changes); + } + }); -// var dictVal = new Dictionary -// { -// { "s1", innerList }, -// { "s3", innerDict }, -// }; + _realm.Write(() => + { + rvo.RealmValueProperty.AsList()[0] = "mario"; + }); -// var rvo = _realm.Write(() => _realm.Add(new RealmValueObject { RealmValueProperty = dictVal })); + _realm.Refresh(); + Assert.That(callbacks.Count, Is.EqualTo(1)); + Assert.That(callbacks[0].ModifiedIndices, Is.EqualTo(new[] { 0 })); -// _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); + callbacks.Clear(); -// var rvo = _realm.Write(() => _realm.Add(new RealmValueObject())); + _realm.Write(() => + { + rvo.RealmValueProperty.AsList()[1].AsList()[0] = "luigi"; + }); -// _realm.Write(() => -// { -// rvo.DynamicApi.Set(nameof(RealmValueObject.RealmValueProperty), dictVal); -// }); + _realm.Refresh(); + Assert.That(callbacks.Count, Is.EqualTo(1)); + Assert.That(callbacks[0].ModifiedIndices, Is.EqualTo(new[] { 1 })); -// var rvp = rvo.DynamicApi.Get(nameof(RealmValueObject.RealmValueProperty)); + callbacks.Clear(); -// Assert.That(rvp.AsDictionary(), Is.EqualTo(dictVal)); -// } + _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 })); -//#if !UNITY -// [Test] -//#endif -// public void Dictionary_WhenManaged_WorksWithDynamic() -// { -// var dictVal = DictGenerator(1); - -// dynamic rvo = _realm.Write(() => _realm.Add(new RealmValueObject())); + callbacks.Clear(); + } -// _realm.Write(() => -// { -// rvo.RealmValueProperty = dictVal; -// }); - -// var rvp = rvo.RealmValueProperty; - -// Assert.That(rvp.AsDictionary(), Is.EqualTo(dictVal)); -// } + #endregion -// [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 })); + #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)); + } -// 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 + #endregion internal class RealmValueComparer : IEqualityComparer { diff --git a/Tests/Realm.Tests/Sync/DataTypeSynchronizationTests.cs b/Tests/Realm.Tests/Sync/DataTypeSynchronizationTests.cs index 43df94bb04..4d55c43431 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) { From f30ffdfb77b46d45ebc67fc155e73bf910508a66 Mon Sep 17 00:00:00 2001 From: Nikola Irinchev Date: Wed, 22 May 2024 00:08:03 +0200 Subject: [PATCH 4/4] RNET-1134: Add obfuscation attribute on generated RealmSchema (#3594) * Add obfuscation attribute on generated RealmSchema * Fix failing test --- .github/templates/test-weaver.yml | 1 + .github/workflows/test-weaver.yml | 1 + CHANGELOG.md | 1 + Realm/Realm.SourceGenerator/ClassCodeBuilder.cs | 1 + Realm/Realm.UnityUtils/Initializer.cs | 2 ++ .../Realms.SourceGenerator.RealmGenerator/A_generated.cs | 1 + .../AgedObject_generated.cs | 1 + .../AllTypesObject_generated.cs | 1 + .../AsymmetricObjectWithAllTypes_generated.cs | 1 + .../AsymmetricObjectWithEmbeddedDictionaryObject_generated.cs | 1 + .../AsymmetricObjectWithEmbeddedListObject_generated.cs | 1 + .../AsymmetricObjectWithEmbeddedRecursiveObject_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/B_generated.cs | 1 + .../BacklinkObject_generated.cs | 1 + .../Bar_DuplicateClass_generated.cs | 1 + .../BasicAsymmetricObject_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/Child_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/Cities_generated.cs | 1 + .../ClassWithUnqueryableMembers_generated.cs | 1 + .../CollectionsObject_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/Company_generated.cs | 1 + .../CompletionReport_generated.cs | 1 + .../ContainerObject_generated.cs | 1 + .../CoordinatesEmbeddedObject_generated.cs | 1 + .../CounterObject_generated.cs | 1 + .../CustomGeoPoint_generated.cs | 1 + .../DecimalsObject_generated.cs | 1 + .../DeepObject1_generated.cs | 1 + .../DeepObject2_generated.cs | 1 + .../DeepObject3_generated.cs | 1 + .../DeepObject4_generated.cs | 1 + .../DeepObject5_generated.cs | 1 + .../DictionariesObject_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/Dog_generated.cs | 1 + .../DynamicDog_generated.cs | 1 + .../DynamicOwner_generated.cs | 1 + .../DynamicSubSubTask_generated.cs | 1 + .../DynamicSubTask_generated.cs | 1 + .../DynamicTask_generated.cs | 1 + .../EmbeddedAllTypesObject_generated.cs | 1 + .../EmbeddedGuidType_generated.cs | 1 + .../EmbeddedIntPropertyObject_generated.cs | 1 + .../EmbeddedLevel1_generated.cs | 1 + .../EmbeddedLevel2_generated.cs | 1 + .../EmbeddedLevel3_generated.cs | 1 + .../ExplicitClass_generated.cs | 1 + .../Foo_DuplicateClass_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/GuidType_generated.cs | 1 + .../HugeSyncObject_generated.cs | 1 + .../IndexedDateTimeOffsetObject_generated.cs | 1 + .../IndexedRealmValueObject_generated.cs | 1 + .../IndexesClass_generated.cs | 1 + .../InitializedFieldObject_generated.cs | 1 + .../IntPrimaryKeyWithValueObject_generated.cs | 1 + .../IntPropertyObject_generated.cs | 1 + .../InternalObject_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/Level1_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/Level2_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/Level3_generated.cs | 1 + .../LinksObject_generated.cs | 1 + .../ListsObject_generated.cs | 1 + .../LoneClass_generated.cs | 1 + .../MixedProperties1_generated.cs | 1 + .../MixedProperties2_generated.cs | 1 + .../NoListProperties_generated.cs | 1 + .../NonPrimaryKeyObject_generated.cs | 1 + .../NonPrimaryKeyWithNonPKRelation_generated.cs | 1 + .../NonPrimaryKeyWithPKRelation_generated.cs | 1 + .../NullablePrimaryKeyObject_generated.cs | 1 + .../NullablesV0_generated.cs | 1 + .../NullablesV1_generated.cs | 1 + .../ObjectContainerEmbedded_generated.cs | 1 + .../ObjectContainerV1_generated.cs | 1 + .../ObjectEmbedded_generated.cs | 1 + .../ObjectIdPrimaryKeyWithValueObject_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/ObjectV1_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/ObjectV2_generated.cs | 1 + .../ObjectWithEmbeddedProperties_generated.cs | 1 + .../ObjectWithFtsIndex_generated.cs | 1 + .../ObjectWithInvalidGeoPoints_generated.cs | 1 + .../ObjectWithObjectProperties_generated.cs | 1 + .../ObjectWithPartitionValue_generated.cs | 1 + .../ObjectWithRequiredStringList_generated.cs | 1 + .../OnManagedTestClass_generated.cs | 1 + .../OneListProperty_generated.cs | 1 + .../OneNonListProperty_generated.cs | 1 + .../OnlyListProperties_generated.cs | 1 + .../OrderedContainer_generated.cs | 1 + .../OrderedObject_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/Owner_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/Parent_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/Person_generated.cs | 1 + .../PrimaryKeyByteObject_generated.cs | 1 + .../PrimaryKeyCharObject_generated.cs | 1 + .../PrimaryKeyGuidObject_generated.cs | 1 + .../PrimaryKeyInt16Object_generated.cs | 1 + .../PrimaryKeyInt32Object_generated.cs | 1 + .../PrimaryKeyInt64Object_generated.cs | 1 + .../PrimaryKeyNullableByteObject_generated.cs | 1 + .../PrimaryKeyNullableCharObject_generated.cs | 1 + .../PrimaryKeyNullableGuidObject_generated.cs | 1 + .../PrimaryKeyNullableInt16Object_generated.cs | 1 + .../PrimaryKeyNullableInt32Object_generated.cs | 1 + .../PrimaryKeyNullableInt64Object_generated.cs | 1 + .../PrimaryKeyNullableObjectIdObject_generated.cs | 1 + .../PrimaryKeyObjectIdObject_generated.cs | 1 + .../PrimaryKeyObject_generated.cs | 1 + .../PrimaryKeyStringObject_generated.cs | 1 + .../PrimaryKeyWithNoPKList_generated.cs | 1 + .../PrimaryKeyWithNonPKChildWithPKGrandChild_generated.cs | 1 + .../PrimaryKeyWithNonPKRelation_generated.cs | 1 + .../PrimaryKeyWithPKList_generated.cs | 1 + .../PrimaryKeyWithPKRelation_generated.cs | 1 + .../PrivatePrimaryKeyObject_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/Product_generated.cs | 1 + .../RealmValueObject_generated.cs | 1 + .../RecursiveBacklinksObject_generated.cs | 1 + .../RemappedPropertiesObject_generated.cs | 1 + .../RemappedTypeObject_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/Report_generated.cs | 1 + .../RequiredPrimaryKeyStringObject_generated.cs | 1 + .../RequiredPropertyClass_generated.cs | 1 + .../RequiredStringObject_generated.cs | 1 + .../SerializedObject_generated.cs | 1 + .../SomeClass_generated.cs | 1 + .../SyncAllTypesObject_generated.cs | 1 + .../SyncCollectionsObject_generated.cs | 1 + .../SyncObjectWithRequiredStringList_generated.cs | 1 + .../TestNotificationObject_generated.cs | 1 + .../ThrowsBeforeInitializer_generated.cs | 1 + .../TopLevelGeoPoint_generated.cs | 1 + .../TypeEmbeddedObject_generated.cs | 1 + .../UnqueryableBacklinks_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/Walker_generated.cs | 1 + .../AllTypesClass_generated.cs | 1 + .../AutomaticPropertiesClass_generated.cs | 1 + .../ClassWithoutParameterlessConstructor_generated.cs | 1 + .../ConfusingNamespaceClass_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/Dog_generated.cs | 1 + .../EmbeddedObj_generated.cs | 1 + .../IgnoreObjectNullabilityClass_generated.cs | 1 + .../IndexedClass_generated.cs | 1 + .../InitializerNamespaceClass_generated.cs | 1 + .../NamespaceObj_generated.cs | 1 + .../NestedClass_generated.cs | 1 + .../NoNamespaceClass_generated.cs | 1 + .../NullableClass_generated.cs | 1 + .../OtherNamespaceObj_generated.cs | 1 + .../PartialClass_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/Person_generated.cs | 1 + .../Realms.SourceGenerator.RealmGenerator/RealmObj_generated.cs | 1 + 151 files changed, 152 insertions(+) diff --git a/.github/templates/test-weaver.yml b/.github/templates/test-weaver.yml index 9194d124ca..06377ba431 100644 --- a/.github/templates/test-weaver.yml +++ b/.github/templates/test-weaver.yml @@ -12,6 +12,7 @@ env: jobs: run-tests-weaver: strategy: + fail-fast: false matrix: os: - runner: windows-latest diff --git a/.github/workflows/test-weaver.yml b/.github/workflows/test-weaver.yml index e14e5aeca5..d4b21050e7 100755 --- a/.github/workflows/test-weaver.yml +++ b/.github/workflows/test-weaver.yml @@ -7,6 +7,7 @@ env: jobs: run-tests-weaver: strategy: + fail-fast: false matrix: os: - runner: windows-latest diff --git a/CHANGELOG.md b/CHANGELOG.md index 0ce10a3bed..796f5ece1a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,7 @@ ### Enhancements * Added support for `Migration.FindInNewRealm` which is a helper that allows you to lookup the object in the post-migration Realm that corresponds to an object from the pre-migration Realm. (Issue [#3600](https://github.com/realm/realm-dotnet/issues/3600)) +* Added `[System.Reflection.Obfuscation]` on the generated `RealmSchema` field to improve compatibility with obfuscation tools that change field and property names of generated classes. (Issue [#3574](https://github.com/realm/realm-dotnet/issues/3574)) * 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 diff --git a/Realm/Realm.SourceGenerator/ClassCodeBuilder.cs b/Realm/Realm.SourceGenerator/ClassCodeBuilder.cs index 7522b79795..24b30ae249 100644 --- a/Realm/Realm.SourceGenerator/ClassCodeBuilder.cs +++ b/Realm/Realm.SourceGenerator/ClassCodeBuilder.cs @@ -253,6 +253,7 @@ private string GeneratePartialClass() var schema = @$"/// /// Defines the schema for the class. /// +[System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder(""{_classInfo.MapTo ?? _classInfo.Name}"", {objectTypeString}) {{ {schemaProperties.Indent(trimNewLines: true)} diff --git a/Realm/Realm.UnityUtils/Initializer.cs b/Realm/Realm.UnityUtils/Initializer.cs index c7847692e0..e7f317b93f 100644 --- a/Realm/Realm.UnityUtils/Initializer.cs +++ b/Realm/Realm.UnityUtils/Initializer.cs @@ -16,6 +16,7 @@ // //////////////////////////////////////////////////////////////////////////// +using System.Reflection; using System.Threading; using Realms; using Realms.PlatformHelpers; @@ -23,6 +24,7 @@ namespace UnityUtils { + [Obfuscation(ApplyToMembers = true, Exclude = true)] internal static class Initializer { private static int _isInitialized; diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/A_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/A_generated.cs index 6f8eb19745..cf02c99802 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/A_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/A_generated.cs @@ -36,6 +36,7 @@ static A() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("A", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Value", Realms.RealmValueType.Bool, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Value"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AgedObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AgedObject_generated.cs index 5667140798..7313517ea4 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AgedObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AgedObject_generated.cs @@ -34,6 +34,7 @@ static AgedObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("AgedObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Birthday", Realms.RealmValueType.Date, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Birthday"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AllTypesObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AllTypesObject_generated.cs index 962aba5b08..e059446d0d 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AllTypesObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AllTypesObject_generated.cs @@ -36,6 +36,7 @@ static AllTypesObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("AllTypesObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("CharProperty", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "CharProperty"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AsymmetricObjectWithAllTypes_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AsymmetricObjectWithAllTypes_generated.cs index a405fd0412..1fa4e687e6 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AsymmetricObjectWithAllTypes_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AsymmetricObjectWithAllTypes_generated.cs @@ -40,6 +40,7 @@ static AsymmetricObjectWithAllTypes() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("AsymmetricObjectWithAllTypes", ObjectSchema.ObjectType.AsymmetricObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.ObjectId, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AsymmetricObjectWithEmbeddedDictionaryObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AsymmetricObjectWithEmbeddedDictionaryObject_generated.cs index 55211b6e06..72670c36ac 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AsymmetricObjectWithEmbeddedDictionaryObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AsymmetricObjectWithEmbeddedDictionaryObject_generated.cs @@ -40,6 +40,7 @@ static AsymmetricObjectWithEmbeddedDictionaryObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("AsymmetricObjectWithEmbeddedDictionaryObject", ObjectSchema.ObjectType.AsymmetricObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.ObjectId, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AsymmetricObjectWithEmbeddedListObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AsymmetricObjectWithEmbeddedListObject_generated.cs index 69cf02291c..1baada5cd8 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AsymmetricObjectWithEmbeddedListObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AsymmetricObjectWithEmbeddedListObject_generated.cs @@ -40,6 +40,7 @@ static AsymmetricObjectWithEmbeddedListObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("AsymmetricObjectWithEmbeddedListObject", ObjectSchema.ObjectType.AsymmetricObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.ObjectId, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AsymmetricObjectWithEmbeddedRecursiveObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AsymmetricObjectWithEmbeddedRecursiveObject_generated.cs index 970fae0187..42ac6f9489 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AsymmetricObjectWithEmbeddedRecursiveObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AsymmetricObjectWithEmbeddedRecursiveObject_generated.cs @@ -40,6 +40,7 @@ static AsymmetricObjectWithEmbeddedRecursiveObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("AsymmetricObjectWithEmbeddedRecursiveObject", ObjectSchema.ObjectType.AsymmetricObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.ObjectId, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/B_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/B_generated.cs index ea12514e85..3a84acc10d 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/B_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/B_generated.cs @@ -36,6 +36,7 @@ static B() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("B", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Object("C", "IntPropertyObject", managedName: "C"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/BacklinkObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/BacklinkObject_generated.cs index 4eea676d67..197f7fc959 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/BacklinkObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/BacklinkObject_generated.cs @@ -34,6 +34,7 @@ static BacklinkObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("BacklinkObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("BeforeBacklinks", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "BeforeBacklinks"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Bar_DuplicateClass_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Bar_DuplicateClass_generated.cs index 455edaef53..222e79edc9 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Bar_DuplicateClass_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Bar_DuplicateClass_generated.cs @@ -36,6 +36,7 @@ static DuplicateClass() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("DuplicateClass", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("StringValue", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "StringValue"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/BasicAsymmetricObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/BasicAsymmetricObject_generated.cs index 9c8d4dd9c3..f78f33d175 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/BasicAsymmetricObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/BasicAsymmetricObject_generated.cs @@ -40,6 +40,7 @@ static BasicAsymmetricObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("BasicAsymmetricObject", ObjectSchema.ObjectType.AsymmetricObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.ObjectId, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Child_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Child_generated.cs index a0a0ebac7a..efc2fc8460 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Child_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Child_generated.cs @@ -36,6 +36,7 @@ static Child() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Child", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Cities_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Cities_generated.cs index c04f180785..cf12d73081 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Cities_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Cities_generated.cs @@ -34,6 +34,7 @@ static Cities() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Cities", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Name", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "Name"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ClassWithUnqueryableMembers_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ClassWithUnqueryableMembers_generated.cs index 7acd155459..adaaef4bdb 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ClassWithUnqueryableMembers_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ClassWithUnqueryableMembers_generated.cs @@ -36,6 +36,7 @@ static ClassWithUnqueryableMembers() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("ClassWithUnqueryableMembers", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("RealPropertyToSatisfyWeaver", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "RealPropertyToSatisfyWeaver"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CollectionsObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CollectionsObject_generated.cs index ffb3cd6f71..572baad0b5 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CollectionsObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CollectionsObject_generated.cs @@ -36,6 +36,7 @@ static CollectionsObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("CollectionsObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.PrimitiveSet("CharSet", Realms.RealmValueType.Int, areElementsNullable: false, managedName: "CharSet"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Company_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Company_generated.cs index 53983ea4d4..0d0d6a9165 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Company_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Company_generated.cs @@ -38,6 +38,7 @@ static Company() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Company", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.ObjectId, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CompletionReport_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CompletionReport_generated.cs index e50edd8f58..f661e54ba3 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CompletionReport_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CompletionReport_generated.cs @@ -34,6 +34,7 @@ static CompletionReport() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("CompletionReport", ObjectSchema.ObjectType.EmbeddedObject) { Realms.Schema.Property.Primitive("CompletionDate", Realms.RealmValueType.Date, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "CompletionDate"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ContainerObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ContainerObject_generated.cs index ab01142566..cde09bf778 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ContainerObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ContainerObject_generated.cs @@ -36,6 +36,7 @@ static ContainerObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("ContainerObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.ObjectList("Items", "IntPropertyObject", managedName: "Items"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CoordinatesEmbeddedObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CoordinatesEmbeddedObject_generated.cs index 7908a4a939..409fd4dd1d 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CoordinatesEmbeddedObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CoordinatesEmbeddedObject_generated.cs @@ -38,6 +38,7 @@ static CoordinatesEmbeddedObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("CoordinatesEmbeddedObject", ObjectSchema.ObjectType.EmbeddedObject) { Realms.Schema.Property.PrimitiveList("coordinate", Realms.RealmValueType.Double, areElementsNullable: false, managedName: "Coordinates"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CounterObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CounterObject_generated.cs index 6549a6d389..6643e55f39 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CounterObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CounterObject_generated.cs @@ -36,6 +36,7 @@ static CounterObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("CounterObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CustomGeoPoint_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CustomGeoPoint_generated.cs index 4d8aa4c46d..cbb0e1f3f8 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CustomGeoPoint_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/CustomGeoPoint_generated.cs @@ -38,6 +38,7 @@ static CustomGeoPoint() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("CustomGeoPoint", ObjectSchema.ObjectType.EmbeddedObject) { Realms.Schema.Property.PrimitiveList("coordinates", Realms.RealmValueType.Double, areElementsNullable: false, managedName: "Coordinates"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DecimalsObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DecimalsObject_generated.cs index c65239e529..30143263dd 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DecimalsObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DecimalsObject_generated.cs @@ -36,6 +36,7 @@ static DecimalsObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("DecimalsObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("DecimalValue", Realms.RealmValueType.Decimal128, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "DecimalValue"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject1_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject1_generated.cs index 40a88b97d8..2dd3ff4f53 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject1_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject1_generated.cs @@ -37,6 +37,7 @@ static DeepObject1() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("DeepObject1", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("StringValue", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "StringValue"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject2_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject2_generated.cs index d97dccd7d1..04456a898c 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject2_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject2_generated.cs @@ -37,6 +37,7 @@ static DeepObject2() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("DeepObject2", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("StringValue", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "StringValue"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject3_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject3_generated.cs index e252614c41..937395b7c0 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject3_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject3_generated.cs @@ -37,6 +37,7 @@ static DeepObject3() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("DeepObject3", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("StringValue", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "StringValue"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject4_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject4_generated.cs index 949b186836..b29d9a2260 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject4_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject4_generated.cs @@ -37,6 +37,7 @@ static DeepObject4() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("DeepObject4", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("StringValue", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "StringValue"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject5_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject5_generated.cs index c92b2a4f6a..ae0c50bbfa 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject5_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DeepObject5_generated.cs @@ -37,6 +37,7 @@ static DeepObject5() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("DeepObject5", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("StringValue", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "StringValue"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DictionariesObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DictionariesObject_generated.cs index ce3f884913..f62d34e928 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DictionariesObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DictionariesObject_generated.cs @@ -36,6 +36,7 @@ static DictionariesObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("DictionariesObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.PrimitiveDictionary("CharDictionary", Realms.RealmValueType.Int, areElementsNullable: false, managedName: "CharDictionary"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Dog_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Dog_generated.cs index 07c3590306..b4003b2c98 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Dog_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Dog_generated.cs @@ -36,6 +36,7 @@ static Dog() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Dog", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Name", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "Name"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicDog_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicDog_generated.cs index a9ed46fa31..e810f891d0 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicDog_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicDog_generated.cs @@ -33,6 +33,7 @@ static DynamicDog() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("DynamicDog", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Name", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "Name"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicOwner_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicOwner_generated.cs index aaa629a4fb..c6678a17cc 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicOwner_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicOwner_generated.cs @@ -33,6 +33,7 @@ static DynamicOwner() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("DynamicOwner", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Name", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "Name"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicSubSubTask_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicSubSubTask_generated.cs index 7dd24e61df..f7eb811aa1 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicSubSubTask_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicSubSubTask_generated.cs @@ -34,6 +34,7 @@ static DynamicSubSubTask() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("DynamicSubSubTask", ObjectSchema.ObjectType.EmbeddedObject) { Realms.Schema.Property.Primitive("Summary", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "Summary"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicSubTask_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicSubTask_generated.cs index aafd341465..f09325170e 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicSubTask_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicSubTask_generated.cs @@ -34,6 +34,7 @@ static DynamicSubTask() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("DynamicSubTask", ObjectSchema.ObjectType.EmbeddedObject) { Realms.Schema.Property.Primitive("Summary", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "Summary"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicTask_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicTask_generated.cs index 30ec6ad1bd..ba8c693ffd 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicTask_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/DynamicTask_generated.cs @@ -34,6 +34,7 @@ static DynamicTask() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("DynamicTask", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.String, isPrimaryKey: true, indexType: IndexType.None, isNullable: true, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedAllTypesObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedAllTypesObject_generated.cs index d6f1aac70d..8bf6d14cec 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedAllTypesObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedAllTypesObject_generated.cs @@ -36,6 +36,7 @@ static EmbeddedAllTypesObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("EmbeddedAllTypesObject", ObjectSchema.ObjectType.EmbeddedObject) { Realms.Schema.Property.Primitive("CharProperty", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "CharProperty"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedGuidType_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedGuidType_generated.cs index a96ea485ad..c96482794d 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedGuidType_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedGuidType_generated.cs @@ -37,6 +37,7 @@ static EmbeddedGuidType() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("EmbeddedGuidType", ObjectSchema.ObjectType.EmbeddedObject) { Realms.Schema.Property.Primitive("RegularProperty", Realms.RealmValueType.Guid, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "RegularProperty"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedIntPropertyObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedIntPropertyObject_generated.cs index 52a7f6c98a..9ebf55a052 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedIntPropertyObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedIntPropertyObject_generated.cs @@ -36,6 +36,7 @@ static EmbeddedIntPropertyObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("EmbeddedIntPropertyObject", ObjectSchema.ObjectType.EmbeddedObject) { Realms.Schema.Property.Primitive("Int", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Int"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedLevel1_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedLevel1_generated.cs index 958faa0bd1..ef6b33a33d 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedLevel1_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedLevel1_generated.cs @@ -36,6 +36,7 @@ static EmbeddedLevel1() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("EmbeddedLevel1", ObjectSchema.ObjectType.EmbeddedObject) { Realms.Schema.Property.Primitive("String", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "String"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedLevel2_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedLevel2_generated.cs index 5d80776ebf..dbd5ad8614 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedLevel2_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedLevel2_generated.cs @@ -36,6 +36,7 @@ static EmbeddedLevel2() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("EmbeddedLevel2", ObjectSchema.ObjectType.EmbeddedObject) { Realms.Schema.Property.Primitive("String", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "String"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedLevel3_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedLevel3_generated.cs index 74875158d3..2a88955ff8 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedLevel3_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedLevel3_generated.cs @@ -36,6 +36,7 @@ static EmbeddedLevel3() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("EmbeddedLevel3", ObjectSchema.ObjectType.EmbeddedObject) { Realms.Schema.Property.Primitive("String", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "String"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ExplicitClass_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ExplicitClass_generated.cs index 16db19bce0..a3959e1de2 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ExplicitClass_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ExplicitClass_generated.cs @@ -34,6 +34,7 @@ static ExplicitClass() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("ExplicitClass", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Foo", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Foo"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Foo_DuplicateClass_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Foo_DuplicateClass_generated.cs index 584ce3e51b..ff6b451658 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Foo_DuplicateClass_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Foo_DuplicateClass_generated.cs @@ -36,6 +36,7 @@ static DuplicateClass() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("DuplicateClass", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("IntValue", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "IntValue"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/GuidType_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/GuidType_generated.cs index 03aefc4712..85a68ed3d6 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/GuidType_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/GuidType_generated.cs @@ -37,6 +37,7 @@ static GuidType() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("GuidType", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.Guid, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/HugeSyncObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/HugeSyncObject_generated.cs index 04cf875995..d1a178155e 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/HugeSyncObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/HugeSyncObject_generated.cs @@ -36,6 +36,7 @@ static HugeSyncObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("HugeSyncObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.ObjectId, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IndexedDateTimeOffsetObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IndexedDateTimeOffsetObject_generated.cs index d450cbdd72..f8e2730620 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IndexedDateTimeOffsetObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IndexedDateTimeOffsetObject_generated.cs @@ -35,6 +35,7 @@ static IndexedDateTimeOffsetObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("IndexedDateTimeOffsetObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("DateTimeOffset", Realms.RealmValueType.Date, isPrimaryKey: false, indexType: IndexType.General, isNullable: false, managedName: "DateTimeOffset"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IndexedRealmValueObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IndexedRealmValueObject_generated.cs index 01d1413ac1..c481faabd8 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IndexedRealmValueObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IndexedRealmValueObject_generated.cs @@ -36,6 +36,7 @@ static IndexedRealmValueObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("IndexedRealmValueObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IndexesClass_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IndexesClass_generated.cs index eb8382d926..726b13ce26 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IndexesClass_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IndexesClass_generated.cs @@ -34,6 +34,7 @@ static IndexesClass() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("IndexesClass", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.ObjectId, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/InitializedFieldObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/InitializedFieldObject_generated.cs index 7ddc85cdd6..a3a1d242f0 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/InitializedFieldObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/InitializedFieldObject_generated.cs @@ -31,6 +31,7 @@ static InitializedFieldObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("InitializedFieldObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IntPrimaryKeyWithValueObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IntPrimaryKeyWithValueObject_generated.cs index 366c85dcc9..73e789d57b 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IntPrimaryKeyWithValueObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IntPrimaryKeyWithValueObject_generated.cs @@ -36,6 +36,7 @@ static IntPrimaryKeyWithValueObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("IntPrimaryKeyWithValueObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IntPropertyObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IntPropertyObject_generated.cs index 8e618dbc03..93c7aa3ad3 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IntPropertyObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IntPropertyObject_generated.cs @@ -36,6 +36,7 @@ static IntPropertyObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("IntPropertyObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.ObjectId, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/InternalObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/InternalObject_generated.cs index 8ab9c7a455..33b75ad9ed 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/InternalObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/InternalObject_generated.cs @@ -34,6 +34,7 @@ static InternalObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("InternalObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("IntProperty", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "IntProperty"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Level1_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Level1_generated.cs index 485dabbd6d..347515e7cf 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Level1_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Level1_generated.cs @@ -34,6 +34,7 @@ static Level1() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Level1", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("StringValue", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "StringValue"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Level2_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Level2_generated.cs index 75914b78ba..596789d1c0 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Level2_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Level2_generated.cs @@ -34,6 +34,7 @@ static Level2() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Level2", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("IntValue", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "IntValue"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Level3_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Level3_generated.cs index 30381b70b6..4c5754d47c 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Level3_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Level3_generated.cs @@ -34,6 +34,7 @@ static Level3() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Level3", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("DateValue", Realms.RealmValueType.Date, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "DateValue"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/LinksObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/LinksObject_generated.cs index 18e19cedfc..81d6a49945 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/LinksObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/LinksObject_generated.cs @@ -36,6 +36,7 @@ static LinksObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("LinksObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.String, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ListsObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ListsObject_generated.cs index a157ee34e0..d68dc694c7 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ListsObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ListsObject_generated.cs @@ -36,6 +36,7 @@ static ListsObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("ListsObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.PrimitiveList("CharList", Realms.RealmValueType.Int, areElementsNullable: false, managedName: "CharList"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/LoneClass_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/LoneClass_generated.cs index ef1975c0cb..a5763ad75e 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/LoneClass_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/LoneClass_generated.cs @@ -40,6 +40,7 @@ static LoneClass() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("LoneClass", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Name", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "Name"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/MixedProperties1_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/MixedProperties1_generated.cs index 4ca8533512..05a529b9da 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/MixedProperties1_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/MixedProperties1_generated.cs @@ -33,6 +33,7 @@ static MixedProperties1() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("MixedProperties1", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Name", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "Name"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/MixedProperties2_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/MixedProperties2_generated.cs index 73a1a088fd..d02d5971a9 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/MixedProperties2_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/MixedProperties2_generated.cs @@ -33,6 +33,7 @@ static MixedProperties2() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("MixedProperties2", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.ObjectList("Friends", "Person", managedName: "Friends"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NoListProperties_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NoListProperties_generated.cs index d62f88aa2a..f58473e872 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NoListProperties_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NoListProperties_generated.cs @@ -33,6 +33,7 @@ static NoListProperties() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("NoListProperties", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Name", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "Name"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NonPrimaryKeyObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NonPrimaryKeyObject_generated.cs index 2a909d5fb3..5333121b5a 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NonPrimaryKeyObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NonPrimaryKeyObject_generated.cs @@ -36,6 +36,7 @@ static NonPrimaryKeyObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("NonPrimaryKeyObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("StringValue", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "StringValue"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NonPrimaryKeyWithNonPKRelation_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NonPrimaryKeyWithNonPKRelation_generated.cs index 87e7db3a91..befdc3c597 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NonPrimaryKeyWithNonPKRelation_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NonPrimaryKeyWithNonPKRelation_generated.cs @@ -36,6 +36,7 @@ static NonPrimaryKeyWithNonPKRelation() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("NonPrimaryKeyWithNonPKRelation", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("StringValue", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "StringValue"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NonPrimaryKeyWithPKRelation_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NonPrimaryKeyWithPKRelation_generated.cs index 599be93357..e50235785d 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NonPrimaryKeyWithPKRelation_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NonPrimaryKeyWithPKRelation_generated.cs @@ -36,6 +36,7 @@ static NonPrimaryKeyWithPKRelation() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("NonPrimaryKeyWithPKRelation", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("StringValue", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "StringValue"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NullablePrimaryKeyObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NullablePrimaryKeyObject_generated.cs index f2fe05ccce..e5ed955c20 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NullablePrimaryKeyObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NullablePrimaryKeyObject_generated.cs @@ -36,6 +36,7 @@ static NullablePrimaryKeyObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("NullablePrimaryKeyObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: true, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NullablesV0_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NullablesV0_generated.cs index cef4fc9ffc..f55e1a2f55 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NullablesV0_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NullablesV0_generated.cs @@ -37,6 +37,7 @@ static NullablesV0() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Nullables", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.ObjectId, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NullablesV1_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NullablesV1_generated.cs index eb08403524..b23eb0f95d 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NullablesV1_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NullablesV1_generated.cs @@ -37,6 +37,7 @@ static NullablesV1() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Nullables", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.ObjectId, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectContainerEmbedded_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectContainerEmbedded_generated.cs index 9abed4cec2..d6228f6900 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectContainerEmbedded_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectContainerEmbedded_generated.cs @@ -36,6 +36,7 @@ static ObjectContainerEmbedded() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("ObjectContainer", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Value", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "Value"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectContainerV1_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectContainerV1_generated.cs index aefe1cd9fa..7656573817 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectContainerV1_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectContainerV1_generated.cs @@ -36,6 +36,7 @@ static ObjectContainerV1() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("ObjectContainer", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Value", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "Value"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectEmbedded_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectEmbedded_generated.cs index a2913a6431..11e876025b 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectEmbedded_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectEmbedded_generated.cs @@ -36,6 +36,7 @@ static ObjectEmbedded() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Object", ObjectSchema.ObjectType.EmbeddedObject) { Realms.Schema.Property.Primitive("Value", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "Value"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectIdPrimaryKeyWithValueObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectIdPrimaryKeyWithValueObject_generated.cs index dfdd6cf666..b07baec92d 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectIdPrimaryKeyWithValueObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectIdPrimaryKeyWithValueObject_generated.cs @@ -36,6 +36,7 @@ static ObjectIdPrimaryKeyWithValueObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("ObjectIdPrimaryKeyWithValueObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.ObjectId, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectV1_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectV1_generated.cs index 3bad07355b..4e8763e513 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectV1_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectV1_generated.cs @@ -36,6 +36,7 @@ static ObjectV1() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Object", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectV2_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectV2_generated.cs index 1a8f6f2e58..aaa7305408 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectV2_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectV2_generated.cs @@ -36,6 +36,7 @@ static ObjectV2() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Object", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.String, isPrimaryKey: true, indexType: IndexType.None, isNullable: true, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithEmbeddedProperties_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithEmbeddedProperties_generated.cs index 2517f1030a..8b2ebb92c5 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithEmbeddedProperties_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithEmbeddedProperties_generated.cs @@ -36,6 +36,7 @@ static ObjectWithEmbeddedProperties() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("ObjectWithEmbeddedProperties", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.ObjectId, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "PrimaryKey"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithFtsIndex_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithFtsIndex_generated.cs index 3978e81148..938c952404 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithFtsIndex_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithFtsIndex_generated.cs @@ -36,6 +36,7 @@ static ObjectWithFtsIndex() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("ObjectWithFtsIndex", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Title", Realms.RealmValueType.String, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Title"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithInvalidGeoPoints_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithInvalidGeoPoints_generated.cs index 97679d1d00..a74fa1c834 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithInvalidGeoPoints_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithInvalidGeoPoints_generated.cs @@ -38,6 +38,7 @@ static ObjectWithInvalidGeoPoints() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("ObjectWithInvalidGeoPoints", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Object("CoordinatesEmbedded", "CoordinatesEmbeddedObject", managedName: "CoordinatesEmbedded"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithObjectProperties_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithObjectProperties_generated.cs index 6d3116be49..b415e4c459 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithObjectProperties_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithObjectProperties_generated.cs @@ -36,6 +36,7 @@ static ObjectWithObjectProperties() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("ObjectWithObjectProperties", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Object("StandaloneObject", "IntPropertyObject", managedName: "StandaloneObject"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithPartitionValue_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithPartitionValue_generated.cs index b1b2795ff5..e42f14d20f 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithPartitionValue_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithPartitionValue_generated.cs @@ -46,6 +46,7 @@ static ObjectWithPartitionValue() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("ObjectWithPartitionValue", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.String, isPrimaryKey: true, indexType: IndexType.None, isNullable: true, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithRequiredStringList_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithRequiredStringList_generated.cs index e9ec1680c6..b3125f6d45 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithRequiredStringList_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ObjectWithRequiredStringList_generated.cs @@ -36,6 +36,7 @@ static ObjectWithRequiredStringList() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("ObjectWithRequiredStringList", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.PrimitiveList("Strings", Realms.RealmValueType.String, areElementsNullable: false, managedName: "Strings"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OnManagedTestClass_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OnManagedTestClass_generated.cs index 447d0d15ce..5ee3e39e9e 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OnManagedTestClass_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OnManagedTestClass_generated.cs @@ -38,6 +38,7 @@ static OnManagedTestClass() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("OnManagedTestClass", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OneListProperty_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OneListProperty_generated.cs index d8d859a245..c898820c58 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OneListProperty_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OneListProperty_generated.cs @@ -33,6 +33,7 @@ static OneListProperty() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("OneListProperty", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.ObjectList("People", "Person", managedName: "People"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OneNonListProperty_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OneNonListProperty_generated.cs index 526983e873..111a1edae4 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OneNonListProperty_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OneNonListProperty_generated.cs @@ -33,6 +33,7 @@ static OneNonListProperty() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("OneNonListProperty", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Name", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "Name"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OnlyListProperties_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OnlyListProperties_generated.cs index 0cc16c1c0c..18fbf2fb8a 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OnlyListProperties_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OnlyListProperties_generated.cs @@ -33,6 +33,7 @@ static OnlyListProperties() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("OnlyListProperties", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.ObjectList("Friends", "Person", managedName: "Friends"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OrderedContainer_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OrderedContainer_generated.cs index 2f5bb21817..f919824681 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OrderedContainer_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OrderedContainer_generated.cs @@ -37,6 +37,7 @@ static OrderedContainer() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("OrderedContainer", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.ObjectList("Items", "OrderedObject", managedName: "Items"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OrderedObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OrderedObject_generated.cs index ec0e648288..c2d192b787 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OrderedObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OrderedObject_generated.cs @@ -37,6 +37,7 @@ static OrderedObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("OrderedObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Order", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Order"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Owner_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Owner_generated.cs index 4e6bde1f0a..cafac1bd9a 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Owner_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Owner_generated.cs @@ -36,6 +36,7 @@ static Owner() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Owner", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Name", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "Name"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Parent_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Parent_generated.cs index 5e4933b1b5..689b69bd90 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Parent_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Parent_generated.cs @@ -36,6 +36,7 @@ static Parent() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Parent", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Person_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Person_generated.cs index a13b606a6a..174a31d421 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Person_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Person_generated.cs @@ -32,6 +32,7 @@ static Person() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Person", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("FirstName", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "FirstName"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyByteObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyByteObject_generated.cs index 65b42ab439..812b93f044 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyByteObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyByteObject_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyByteObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyByteObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyCharObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyCharObject_generated.cs index 1d6586b99d..2417aa674f 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyCharObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyCharObject_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyCharObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyCharObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyGuidObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyGuidObject_generated.cs index 3460d293a5..fe0c026f50 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyGuidObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyGuidObject_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyGuidObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyGuidObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.Guid, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyInt16Object_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyInt16Object_generated.cs index cfd5a9ab7a..f1b7f2f79a 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyInt16Object_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyInt16Object_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyInt16Object() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyInt16Object", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyInt32Object_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyInt32Object_generated.cs index 38e23493ce..c24e1ce8ce 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyInt32Object_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyInt32Object_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyInt32Object() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyInt32Object", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyInt64Object_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyInt64Object_generated.cs index af9476e3e7..eb8328aaea 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyInt64Object_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyInt64Object_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyInt64Object() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyInt64Object", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableByteObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableByteObject_generated.cs index 8eb699fca7..12c3a45229 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableByteObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableByteObject_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyNullableByteObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyNullableByteObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: true, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableCharObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableCharObject_generated.cs index 5e1b0ca1eb..d26a3cc39b 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableCharObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableCharObject_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyNullableCharObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyNullableCharObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: true, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableGuidObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableGuidObject_generated.cs index 59c736dab6..0cb88c6c73 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableGuidObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableGuidObject_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyNullableGuidObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyNullableGuidObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.Guid, isPrimaryKey: true, indexType: IndexType.None, isNullable: true, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableInt16Object_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableInt16Object_generated.cs index 084301b3d2..9f820f65c4 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableInt16Object_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableInt16Object_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyNullableInt16Object() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyNullableInt16Object", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: true, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableInt32Object_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableInt32Object_generated.cs index 3d849c63c3..976819c208 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableInt32Object_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableInt32Object_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyNullableInt32Object() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyNullableInt32Object", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: true, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableInt64Object_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableInt64Object_generated.cs index e6780f803d..ef41d6e5b4 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableInt64Object_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableInt64Object_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyNullableInt64Object() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyNullableInt64Object", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: true, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableObjectIdObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableObjectIdObject_generated.cs index 0f6342ae87..279ddd18ac 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableObjectIdObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyNullableObjectIdObject_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyNullableObjectIdObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyNullableObjectIdObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.ObjectId, isPrimaryKey: true, indexType: IndexType.None, isNullable: true, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyObjectIdObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyObjectIdObject_generated.cs index 29acda9afb..a58d78148d 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyObjectIdObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyObjectIdObject_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyObjectIdObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyObjectIdObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.ObjectId, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyObject_generated.cs index 8c482f1b43..e1f5606163 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyObject_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyStringObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyStringObject_generated.cs index 8ced58a1fa..8fa84f9328 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyStringObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyStringObject_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyStringObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyStringObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.String, isPrimaryKey: true, indexType: IndexType.None, isNullable: true, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithNoPKList_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithNoPKList_generated.cs index c9c5bb34d9..cdc7eeaa3b 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithNoPKList_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithNoPKList_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyWithNoPKList() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyWithNoPKList", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithNonPKChildWithPKGrandChild_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithNonPKChildWithPKGrandChild_generated.cs index 6bb74fd106..aa32eafb43 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithNonPKChildWithPKGrandChild_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithNonPKChildWithPKGrandChild_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyWithNonPKChildWithPKGrandChild() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyWithNonPKChildWithPKGrandChild", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithNonPKRelation_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithNonPKRelation_generated.cs index 3cfd78b40d..f55be95eb5 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithNonPKRelation_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithNonPKRelation_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyWithNonPKRelation() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyWithNonPKRelation", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithPKList_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithPKList_generated.cs index aa9ebe729f..35e250ac38 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithPKList_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithPKList_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyWithPKList() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyWithPKList", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithPKRelation_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithPKRelation_generated.cs index 5f8ce4c839..b920280aba 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithPKRelation_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrimaryKeyWithPKRelation_generated.cs @@ -36,6 +36,7 @@ static PrimaryKeyWithPKRelation() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrimaryKeyWithPKRelation", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrivatePrimaryKeyObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrivatePrimaryKeyObject_generated.cs index b1d40a357f..0570d73de7 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrivatePrimaryKeyObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PrivatePrimaryKeyObject_generated.cs @@ -36,6 +36,7 @@ static PrivatePrimaryKeyObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PrivatePrimaryKeyObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.String, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Product_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Product_generated.cs index 722bcca639..9f6c9c20f0 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Product_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Product_generated.cs @@ -33,6 +33,7 @@ static Product() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Product", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RealmValueObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RealmValueObject_generated.cs index 0ab5c34dfa..e8daefafe5 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RealmValueObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RealmValueObject_generated.cs @@ -36,6 +36,7 @@ static RealmValueObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("RealmValueObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RecursiveBacklinksObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RecursiveBacklinksObject_generated.cs index 70564955cd..5e41ab41e8 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RecursiveBacklinksObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RecursiveBacklinksObject_generated.cs @@ -36,6 +36,7 @@ static RecursiveBacklinksObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("RecursiveBacklinksObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RemappedPropertiesObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RemappedPropertiesObject_generated.cs index e5cef173ae..5e4c36c348 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RemappedPropertiesObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RemappedPropertiesObject_generated.cs @@ -36,6 +36,7 @@ static RemappedPropertiesObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("RemappedPropertiesObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RemappedTypeObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RemappedTypeObject_generated.cs index 9ddf62f4dc..3a4f16019b 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RemappedTypeObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RemappedTypeObject_generated.cs @@ -36,6 +36,7 @@ static RemappedTypeObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("__RemappedTypeObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Report_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Report_generated.cs index d763c18eb5..e5ac8925cd 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Report_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Report_generated.cs @@ -33,6 +33,7 @@ static Report() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Report", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RequiredPrimaryKeyStringObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RequiredPrimaryKeyStringObject_generated.cs index 2ae34c74ff..e735bdd674 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RequiredPrimaryKeyStringObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RequiredPrimaryKeyStringObject_generated.cs @@ -36,6 +36,7 @@ static RequiredPrimaryKeyStringObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("RequiredPrimaryKeyStringObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.String, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RequiredPropertyClass_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RequiredPropertyClass_generated.cs index 86db6ff97d..b73a5c9719 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RequiredPropertyClass_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RequiredPropertyClass_generated.cs @@ -34,6 +34,7 @@ static RequiredPropertyClass() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("RequiredPropertyClass", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("FooRequired", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "FooRequired"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RequiredStringObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RequiredStringObject_generated.cs index e0c541b1a1..3b2a74276b 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RequiredStringObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RequiredStringObject_generated.cs @@ -36,6 +36,7 @@ static RequiredStringObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("RequiredStringObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("String", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "String"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SerializedObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SerializedObject_generated.cs index b9a207144a..861b86c81b 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SerializedObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SerializedObject_generated.cs @@ -38,6 +38,7 @@ static SerializedObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("SerializedObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("IntValue", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "IntValue"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SomeClass_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SomeClass_generated.cs index 5c83b24782..2968e11ccb 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SomeClass_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SomeClass_generated.cs @@ -34,6 +34,7 @@ static SomeClass() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("SomeClass", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Object("BacklinkObject", "BacklinkObject", managedName: "BacklinkObject"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SyncAllTypesObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SyncAllTypesObject_generated.cs index f7bef1315d..43e759683f 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SyncAllTypesObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SyncAllTypesObject_generated.cs @@ -36,6 +36,7 @@ static SyncAllTypesObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("SyncAllTypesObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.ObjectId, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SyncCollectionsObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SyncCollectionsObject_generated.cs index 8c04e1d818..1d5fba36f3 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SyncCollectionsObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SyncCollectionsObject_generated.cs @@ -36,6 +36,7 @@ static SyncCollectionsObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("SyncCollectionsObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.ObjectId, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SyncObjectWithRequiredStringList_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SyncObjectWithRequiredStringList_generated.cs index 4d82bc34b0..6a17d53644 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SyncObjectWithRequiredStringList_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/SyncObjectWithRequiredStringList_generated.cs @@ -46,6 +46,7 @@ static SyncObjectWithRequiredStringList() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("SyncObjectWithRequiredStringList", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("_id", Realms.RealmValueType.String, isPrimaryKey: true, indexType: IndexType.None, isNullable: true, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/TestNotificationObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/TestNotificationObject_generated.cs index 7c6833aa97..9575cfa3dd 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/TestNotificationObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/TestNotificationObject_generated.cs @@ -32,6 +32,7 @@ static TestNotificationObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("TestNotificationObject", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("StringProperty", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "StringProperty"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ThrowsBeforeInitializer_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ThrowsBeforeInitializer_generated.cs index 42fab3048b..0694ff19bd 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ThrowsBeforeInitializer_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ThrowsBeforeInitializer_generated.cs @@ -38,6 +38,7 @@ static ThrowsBeforeInitializer() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("ThrowsBeforeInitializer", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/TopLevelGeoPoint_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/TopLevelGeoPoint_generated.cs index 8a03ad708a..5651bed38b 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/TopLevelGeoPoint_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/TopLevelGeoPoint_generated.cs @@ -38,6 +38,7 @@ static TopLevelGeoPoint() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("TopLevelGeoPoint", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.PrimitiveList("coordinates", Realms.RealmValueType.Double, areElementsNullable: false, managedName: "Coordinates"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/TypeEmbeddedObject_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/TypeEmbeddedObject_generated.cs index a18e0c6475..ab38ad749d 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/TypeEmbeddedObject_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/TypeEmbeddedObject_generated.cs @@ -38,6 +38,7 @@ static TypeEmbeddedObject() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("TypeEmbeddedObject", ObjectSchema.ObjectType.EmbeddedObject) { Realms.Schema.Property.Primitive("type", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Type"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/UnqueryableBacklinks_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/UnqueryableBacklinks_generated.cs index 15bb7d7e0b..52ee731ffb 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/UnqueryableBacklinks_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/UnqueryableBacklinks_generated.cs @@ -36,6 +36,7 @@ static UnqueryableBacklinks() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("UnqueryableBacklinks", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Object("Parent", "ClassWithUnqueryableMembers", managedName: "Parent"), diff --git a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Walker_generated.cs b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Walker_generated.cs index 37872a7bb2..9bf650543b 100644 --- a/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Walker_generated.cs +++ b/Tests/Realm.Tests/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Walker_generated.cs @@ -36,6 +36,7 @@ static Walker() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Walker", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Name", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "Name"), diff --git a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AllTypesClass_generated.cs b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AllTypesClass_generated.cs index d8771fe7ff..2f3bb1d45f 100644 --- a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AllTypesClass_generated.cs +++ b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AllTypesClass_generated.cs @@ -32,6 +32,7 @@ static AllTypesClass() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("AllTypesClass", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("CharProperty", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "CharProperty"), diff --git a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AutomaticPropertiesClass_generated.cs b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AutomaticPropertiesClass_generated.cs index c6d390d8d3..03b60fb3bb 100644 --- a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AutomaticPropertiesClass_generated.cs +++ b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/AutomaticPropertiesClass_generated.cs @@ -31,6 +31,7 @@ static AutomaticPropertiesClass() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("AutomaticPropertiesClass", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ClassWithoutParameterlessConstructor_generated.cs b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ClassWithoutParameterlessConstructor_generated.cs index f8f0cf270b..60184167cf 100644 --- a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ClassWithoutParameterlessConstructor_generated.cs +++ b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ClassWithoutParameterlessConstructor_generated.cs @@ -31,6 +31,7 @@ static ClassWithoutParameterlessConstructor() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("ClassWithoutParameterlessConstructor", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Name", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Name"), diff --git a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ConfusingNamespaceClass_generated.cs b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ConfusingNamespaceClass_generated.cs index 48764d25a1..45504bb9e3 100644 --- a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ConfusingNamespaceClass_generated.cs +++ b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/ConfusingNamespaceClass_generated.cs @@ -31,6 +31,7 @@ static ConfusingNamespaceClass() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("ConfusingNamespaceClass", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Dog_generated.cs b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Dog_generated.cs index 0f0c7dcb34..c887fac813 100644 --- a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Dog_generated.cs +++ b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Dog_generated.cs @@ -31,6 +31,7 @@ static Dog() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Dog", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Name", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: true, managedName: "Name"), diff --git a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedObj_generated.cs b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedObj_generated.cs index 04809f7e15..b0d89d0218 100644 --- a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedObj_generated.cs +++ b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/EmbeddedObj_generated.cs @@ -31,6 +31,7 @@ static EmbeddedObj() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("EmbeddedObj", ObjectSchema.ObjectType.EmbeddedObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IgnoreObjectNullabilityClass_generated.cs b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IgnoreObjectNullabilityClass_generated.cs index a165833295..ab144e024f 100644 --- a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IgnoreObjectNullabilityClass_generated.cs +++ b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IgnoreObjectNullabilityClass_generated.cs @@ -31,6 +31,7 @@ static IgnoreObjectNullabilityClass() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("IgnoreObjectNullabilityClass", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Object("NullableObject", "IgnoreObjectNullabilityClass", managedName: "NullableObject"), diff --git a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IndexedClass_generated.cs b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IndexedClass_generated.cs index b3b103a98b..373ba76a0b 100644 --- a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IndexedClass_generated.cs +++ b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/IndexedClass_generated.cs @@ -31,6 +31,7 @@ static IndexedClass() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("IndexedClass", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/InitializerNamespaceClass_generated.cs b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/InitializerNamespaceClass_generated.cs index bfb74e3888..383fd0f324 100644 --- a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/InitializerNamespaceClass_generated.cs +++ b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/InitializerNamespaceClass_generated.cs @@ -32,6 +32,7 @@ static InitializerNamespaceClass() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("InitializerNamespaceClass", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NamespaceObj_generated.cs b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NamespaceObj_generated.cs index e68191ecac..f20b09b6bf 100644 --- a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NamespaceObj_generated.cs +++ b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NamespaceObj_generated.cs @@ -32,6 +32,7 @@ static NamespaceObj() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("NamespaceObj", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NestedClass_generated.cs b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NestedClass_generated.cs index 396f84f2df..d2fa29dc87 100644 --- a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NestedClass_generated.cs +++ b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NestedClass_generated.cs @@ -33,6 +33,7 @@ static NestedClass() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("NestedClass", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NoNamespaceClass_generated.cs b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NoNamespaceClass_generated.cs index 968447da42..daa9c1b5c8 100644 --- a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NoNamespaceClass_generated.cs +++ b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NoNamespaceClass_generated.cs @@ -28,6 +28,7 @@ static NoNamespaceClass() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("NoNamespaceClass", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Name", Realms.RealmValueType.String, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Name"), diff --git a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NullableClass_generated.cs b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NullableClass_generated.cs index bdac71037c..a7785c86be 100644 --- a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NullableClass_generated.cs +++ b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/NullableClass_generated.cs @@ -31,6 +31,7 @@ static NullableClass() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("NullableClass", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("NonNullableInt", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "NonNullableInt"), diff --git a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OtherNamespaceObj_generated.cs b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OtherNamespaceObj_generated.cs index 70adecb238..cd6278e7b3 100644 --- a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OtherNamespaceObj_generated.cs +++ b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/OtherNamespaceObj_generated.cs @@ -31,6 +31,7 @@ static OtherNamespaceObj() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("OtherNamespaceObj", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PartialClass_generated.cs b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PartialClass_generated.cs index 1907fce8a9..f288e5162f 100644 --- a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PartialClass_generated.cs +++ b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/PartialClass_generated.cs @@ -31,6 +31,7 @@ static PartialClass() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("PartialClass", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Person_generated.cs b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Person_generated.cs index 9f82d005a6..9ff54c1f27 100644 --- a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Person_generated.cs +++ b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/Person_generated.cs @@ -31,6 +31,7 @@ static Person() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("Person", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Guid, isPrimaryKey: true, indexType: IndexType.None, isNullable: false, managedName: "Id"), diff --git a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RealmObj_generated.cs b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RealmObj_generated.cs index bcc61e1923..eb6f62e320 100644 --- a/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RealmObj_generated.cs +++ b/Tests/SourceGenerators/SourceGeneratorAssemblyToProcess/Generated/Realm.SourceGenerator/Realms.SourceGenerator.RealmGenerator/RealmObj_generated.cs @@ -31,6 +31,7 @@ static RealmObj() /// /// Defines the schema for the class. /// + [System.Reflection.Obfuscation] public static Realms.Schema.ObjectSchema RealmSchema = new Realms.Schema.ObjectSchema.Builder("RealmObj", ObjectSchema.ObjectType.RealmObject) { Realms.Schema.Property.Primitive("Id", Realms.RealmValueType.Int, isPrimaryKey: false, indexType: IndexType.None, isNullable: false, managedName: "Id"),