Add unit tests

Author: Sergio0694

tests/CommunityToolkit.Mvvm.UnitTests/Test_ObservablePropertyAttribute.cs

@@ -418,6 +418,105 @@ private void Test_AlsoBroadcastChange_Test<T>(Func<IMessenger, T> factory, Actio
         Assert.AreEqual(propertyName, messages[0].Message.PropertyName);
     }
 
+#if NET6_0_OR_GREATER
+    // See https://github.com/CommunityToolkit/dotnet/issues/155
+    [TestMethod]
+    public void Test_ObservableProperty_NullabilityAnnotations_Simple()
+    {
+        // List<string?>?
+        NullabilityInfoContext context = new();
+        NullabilityInfo info = context.Create(typeof(NullableRepro).GetProperty(nameof(NullableRepro.NullableList))!);
+
+        Assert.AreEqual(typeof(List<string>), info.Type);
+        Assert.AreEqual(NullabilityState.Nullable, info.ReadState);
+        Assert.AreEqual(NullabilityState.Nullable, info.WriteState);
+        Assert.AreEqual(1, info.GenericTypeArguments.Length);
+
+        NullabilityInfo elementInfo = info.GenericTypeArguments[0];
+
+        Assert.AreEqual(typeof(string), elementInfo.Type);
+        Assert.AreEqual(NullabilityState.Nullable, elementInfo.ReadState);
+        Assert.AreEqual(NullabilityState.Nullable, elementInfo.WriteState);
+    }
+
+    // See https://github.com/CommunityToolkit/dotnet/issues/155
+    [TestMethod]
+    public void Test_ObservableProperty_NullabilityAnnotations_Complex()
+    {
+        // Foo<Foo<string?, int>.Bar<object?>?, StrongBox<Foo<int, string?>.Bar<object>?>?>?
+        NullabilityInfoContext context = new();
+        NullabilityInfo info = context.Create(typeof(NullableRepro).GetProperty(nameof(NullableRepro.NullableMess))!);
+
+        Assert.AreEqual(typeof(Foo<Foo<string?, int>.Bar<object?>?, StrongBox<Foo<int, string?>.Bar<object>?>?>), info.Type);
+        Assert.AreEqual(NullabilityState.Nullable, info.ReadState);
+        Assert.AreEqual(NullabilityState.Nullable, info.WriteState);
+        Assert.AreEqual(2, info.GenericTypeArguments.Length);
+
+        NullabilityInfo leftInfo = info.GenericTypeArguments[0];
+
+        Assert.AreEqual(typeof(Foo<string?, int>.Bar<object?>), leftInfo.Type);
+        Assert.AreEqual(NullabilityState.Nullable, leftInfo.ReadState);
+        Assert.AreEqual(NullabilityState.Nullable, leftInfo.WriteState);
+        Assert.AreEqual(3, leftInfo.GenericTypeArguments.Length);
+
+        NullabilityInfo leftInfo0 = leftInfo.GenericTypeArguments[0];
+
+        Assert.AreEqual(typeof(string), leftInfo0.Type);
+        Assert.AreEqual(NullabilityState.Nullable, leftInfo0.ReadState);
+        Assert.AreEqual(NullabilityState.Nullable, leftInfo0.WriteState);
+
+        NullabilityInfo leftInfo1 = leftInfo.GenericTypeArguments[1];
+
+        Assert.AreEqual(typeof(int), leftInfo1.Type);
+        Assert.AreEqual(NullabilityState.NotNull, leftInfo1.ReadState);
+        Assert.AreEqual(NullabilityState.NotNull, leftInfo1.WriteState);
+
+        NullabilityInfo leftInfo2 = leftInfo.GenericTypeArguments[2];
+
+        Assert.AreEqual(typeof(object), leftInfo2.Type);
+        Assert.AreEqual(NullabilityState.Nullable, leftInfo2.ReadState);
+        Assert.AreEqual(NullabilityState.Nullable, leftInfo2.WriteState);
+
+        NullabilityInfo rightInfo = info.GenericTypeArguments[1];
+
+        Assert.AreEqual(typeof(StrongBox<Foo<int, string?>.Bar<object>?>), rightInfo.Type);
+        Assert.AreEqual(NullabilityState.Nullable, rightInfo.ReadState);
+        Assert.AreEqual(NullabilityState.Nullable, rightInfo.WriteState);
+        Assert.AreEqual(1, rightInfo.GenericTypeArguments.Length);
+
+        NullabilityInfo rightInnerInfo = rightInfo.GenericTypeArguments[0];
+
+        Assert.AreEqual(typeof(Foo<int, string?>.Bar<object>), rightInnerInfo.Type);
+        Assert.AreEqual(NullabilityState.Nullable, rightInnerInfo.ReadState);
+        Assert.AreEqual(NullabilityState.Nullable, rightInnerInfo.WriteState);
+        Assert.AreEqual(3, rightInnerInfo.GenericTypeArguments.Length);
+
+        NullabilityInfo rightInfo0 = rightInnerInfo.GenericTypeArguments[0];
+
+        Assert.AreEqual(typeof(int), rightInfo0.Type);
+        Assert.AreEqual(NullabilityState.NotNull, rightInfo0.ReadState);
+        Assert.AreEqual(NullabilityState.NotNull, rightInfo0.WriteState);
+
+        NullabilityInfo rightInfo1 = rightInnerInfo.GenericTypeArguments[1];
+
+        Assert.AreEqual(typeof(string), rightInfo1.Type);
+        Assert.AreEqual(NullabilityState.Nullable, rightInfo1.ReadState);
+        Assert.AreEqual(NullabilityState.Nullable, rightInfo1.WriteState);
+
+        NullabilityInfo rightInfo2 = rightInnerInfo.GenericTypeArguments[2];
+
+        Assert.AreEqual(typeof(object), rightInfo2.Type);
+        //Assert.AreEqual(NullabilityState.NotNull, rightInfo2.ReadState);
+        //Assert.AreEqual(NullabilityState.NotNull, rightInfo2.WriteState);
+
+        // The commented out lines are to work around a weird behavior of the NullabilityInfo API there.
+        // Arguably we're pushing them a bit far here, but it's fine. Even with those cases commented out,
+        // the test is already more than enough, plus we can also double check the behavior by looking at
+        // the generated code. Thoe lines can be uncommented once the behavior is either clarified, or if
+        // it happens to be a bug which is then fixed in a future version of .NET, once we upgrade as well.
+    }
+#endif
+
     public partial class SampleModel : ObservableObject
     {
         /// <summary>
@@ -705,4 +804,22 @@ public BroadcastingViewModelWithInheritedAttribute(IMessenger messenger)
         [AlsoBroadcastChange]
         private string? name2;
     }
+
+#if NET6_0_OR_GREATER
+    private partial class NullableRepro : ObservableObject
+    {
+        [ObservableProperty]
+        private List<string?>? nullableList;
+
+        [ObservableProperty]
+        private Foo<Foo<string?, int>.Bar<object?>?, StrongBox<Foo<int, string?>.Bar<object>?>?>? nullableMess;
+    }
+
+    private class Foo<T1, T2>
+    {
+        public class Bar<T>
+        {
+        }
+    }
+#endif
 }