Microsoft Mvvm Toolkit support

DevExpress.Mvvm.CodeGenerators.Tests/FrameworkTests/FrameworkTests.csproj

@@ -20,15 +20,17 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DefineConstants>DEBUG;TRACE;FRAMEWORK</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <WarningsAsErrors />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
+    <DefineConstants>TRACE;FRAMEWORK</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
@@ -48,6 +50,9 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="DevExpressMvvm" Version="20.2.3" />
+    <PackageReference Include="Microsoft.Toolkit.Mvvm">
+      <Version>7.1.2</Version>
+    </PackageReference>
     <PackageReference Include="MvvmLightLibsStd10" Version="5.4.1.1" />
     <PackageReference Include="Prism.Wpf" Version="8.1.97" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.9.0" />

DevExpress.Mvvm.CodeGenerators.Tests/NetCoreTests/NetCoreTests.csproj

@@ -6,7 +6,7 @@
     <AssemblyName>DevExpress.Mvvm.CodeGenerators.NetCoreTests</AssemblyName>
     <LangVersion>9</LangVersion>
     <IncludePackageReferencesDuringMarkupCompilation>true</IncludePackageReferencesDuringMarkupCompilation>
-    <WarningsAsErrors>8618,8604</WarningsAsErrors>
+    <TreatWarningsAsErrors>True</TreatWarningsAsErrors>
     <UseWPF>true</UseWPF>
   </PropertyGroup>
 
@@ -15,6 +15,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.Toolkit.Mvvm" Version="7.1.2" />
     <PackageReference Include="DevExpressMvvm" Version="20.2.3" />
     <PackageReference Include="MvvmLightLibsStd10" Version="5.4.1.1" />
     <PackageReference Include="Prism.Wpf" Version="8.1.97" />

DevExpress.Mvvm.CodeGenerators.Tests/SharedTests/DxTest/NullableAnnotationTests.cs

@@ -36,6 +36,7 @@ void NonNullableParameter1(string str) { }
         int? nullableInt2;
         [GenerateProperty]
         string string2;
+#pragma warning disable 8632
         [GenerateProperty]
         string? nullableString2;
 
@@ -48,6 +49,7 @@ void NonNullableParameter2(string str) { }
         [GenerateCommand]
         Task NonNullableParameterAsync2(string str) => Task.CompletedTask;
 
-        void OnString1Changed(string str) { }
+        void OnString1Changed(string str) { }
+#pragma warning restore 8632
     }
 }

DevExpress.Mvvm.CodeGenerators.Tests/SharedTests/DxTest/PropertyGenerationTests.cs

@@ -26,7 +26,7 @@ partial class WithTwoMvvmAttribute {
         [Prism.GenerateProperty]
         int prismProperty;
         [Prism.GenerateCommand]
-        void PrismMethod() { }
+        void PrismMethod() { prismProperty++; }
     }
 
     [TestFixture]

DevExpress.Mvvm.CodeGenerators.Tests/SharedTests/DxTest/UsingRaiseMethodTests.cs

@@ -20,6 +20,11 @@ partial class ChildWithParentsGeneratedRaiseMethod : ParentWithGeneraetedRaiseMe
     class ParentWithoutRaiseMethod : INotifyPropertyChanged, INotifyPropertyChanging {
         public event PropertyChangedEventHandler PropertyChanged;
         public event PropertyChangingEventHandler PropertyChanging;
+        public ParentWithoutRaiseMethod() {
+            //avoid warnings
+            PropertyChanged?.Invoke(null, null);
+            PropertyChanging?.Invoke(null, null);
+        }
     }
     [GenerateViewModel(ImplementINotifyPropertyChanging = true)]
     partial class ChildWithoutRaiseMethod : ParentWithoutRaiseMethod {

DevExpress.Mvvm.CodeGenerators.Tests/SharedTests/MvvmLightTest/InterfacesTests.cs

@@ -18,7 +18,7 @@ partial class NotImplementICU { }
     [GenerateViewModel(ImplementICleanup = true)]
     partial class ImplementICUParent { }
     [GenerateViewModel(ImplementICleanup = true)]
-    partial class ImplementICUChild { }
+    partial class ImplementICUChild : ImplementICUParent { }
 
     [GenerateViewModel(ImplementINotifyPropertyChanging = true,
     ImplementICleanup = true)]

DevExpress.Mvvm.CodeGenerators.Tests/SharedTests/MvvmLightTest/NullableAnnotationTests.cs

@@ -34,6 +34,7 @@ void NonNullableParameter1(string str) { }
         int? nullableInt2;
         [GenerateProperty]
         string string2;
+#pragma warning disable 8632
         [GenerateProperty]
         string? nullableString2;
 
@@ -47,5 +48,6 @@ void NonNullableParameter2(string str) { }
         Task NonNullableParameterAsync2(string str) => Task.CompletedTask;
 
         void OnString1Changed(string str) { }
+#pragma warning restore 8632
     }
 }

DevExpress.Mvvm.CodeGenerators.Tests/SharedTests/MvvmLightTest/PropertyGenerationTests.cs

@@ -13,7 +13,7 @@ partial class WithTwoMvvmAttribute {
         [DevExpress.Mvvm.CodeGenerators.GenerateProperty]
         int dxProperty;
         [DevExpress.Mvvm.CodeGenerators.GenerateCommand]
-        void DxMethod() { }
+        void DxMethod() { dxProperty++; }
     }
 
     [TestFixture]

DevExpress.Mvvm.CodeGenerators.Tests/SharedTests/MvvmLightTest/UsingRaiseMethodTests.cs

@@ -3,6 +3,7 @@
 using System.ComponentModel;
 using DevExpress.Mvvm.CodeGenerators.MvvmLight;
 using GalaSoft.MvvmLight;
+using DevExpress.Mvvm.CodeGenerators.Tests;
 
 namespace MvvmLight.Mvvm.Tests {
     [GenerateViewModel(ImplementINotifyPropertyChanging = true)]
@@ -22,6 +23,11 @@ partial class ChildWithParentsGeneratedRaiseMethod : ParentWithGeneraetedRaiseMe
     class ParentWithoutRaiseMethod : INotifyPropertyChanged, INotifyPropertyChanging {
         public event PropertyChangedEventHandler PropertyChanged;
         public event PropertyChangingEventHandler PropertyChanging;
+        public ParentWithoutRaiseMethod() {
+            //avoid warnings
+            PropertyChanged?.Invoke(null, null);
+            PropertyChanging?.Invoke(null, null);
+        }
     }
     [GenerateViewModel(ImplementINotifyPropertyChanging = true)]
     partial class ChildWithoutRaiseMethod : ParentWithoutRaiseMethod {

DevExpress.Mvvm.CodeGenerators.Tests/SharedTests/MvvmToolkit/AsyncCommandGenerationTests.cs

@@ -0,0 +1,82 @@
+using NUnit.Framework;
+using System;
+using System.Reflection;
+using System.Threading.Tasks;
+using DevExpress.Mvvm.CodeGenerators.MvvmToolkit;
+using Microsoft.Toolkit.Mvvm.Input;
+
+namespace MvvmToolkit.Mvvm.Tests {
+    [GenerateViewModel]
+    partial class GenerateAsyncCommands {
+        readonly Task<int> task = new(() => 1);
+        [GenerateCommand]
+        public Task WithNoArg() => Task.CompletedTask;
+        [GenerateCommand]
+        public Task WithArg(int arg) => Task.CompletedTask;
+        [GenerateCommand]
+        public Task WithNullableArg(int? arg) => Task.CompletedTask;
+        public Task SomeMethod() => Task.CompletedTask;
+
+        [GenerateCommand(Name = "MyAsyncCommand", CanExecuteMethod = "CanDoIt")]
+        public Task Method(int arg) => Task.CompletedTask;
+        public bool CanDoIt(int arg) => arg > 0;
+
+        [GenerateCommand]
+        public Task<int> GenericTask() => task;
+    }
+
+    [TestFixture]
+    public class AsyncCommandGenerationTests {
+        [Test]
+        public void CallRequiredMethodForAsyncCommand() {
+            var generated = new GenerateAsyncCommands();
+
+            var method = GetFieldValue<Action<int>, RelayCommand<int>>(generated.MyAsyncCommand, "execute");
+            StringAssert.Contains("MyAsyncCommand", method.Method.Name);
+
+            var canMethod = GetFieldValue<Predicate<int>, RelayCommand<int>>(generated.MyAsyncCommand, "canExecute");
+            var expectedCanMethod = generated.GetType().GetMethod("CanDoIt").Name;
+            Assert.AreEqual(expectedCanMethod, canMethod.Method.Name);
+
+            var canExecuteMethod = GetFieldValue<Predicate<int>, RelayCommand>(generated.GenericTaskCommand, "canExecute");
+            Assert.IsNull(canExecuteMethod);
+        }
+
+        static TResult GetFieldValue<TResult, T>(T source, string fieldName) {
+            var fieldInfo = source.GetType().GetField(fieldName, BindingFlags.NonPublic | BindingFlags.Instance);
+            Assert.IsNotNull(fieldInfo);
+
+            return (TResult)fieldInfo.GetValue(source);
+        }
+        [Test]
+        public void AsyncCommandImplementation() {
+            var generated = new GenerateAsyncCommands();
+
+            Assert.IsNotNull(generated.GetType().GetProperty("WithNoArgCommand"));
+            Assert.IsNotNull(generated.GetType().GetProperty("WithArgCommand"));
+            Assert.IsNotNull(generated.GetType().GetProperty("WithNullableArgCommand"));
+
+            Assert.IsNull(generated.GetType().GetProperty("With2ArgsCommand"));
+            Assert.IsNull(generated.GetType().GetProperty("ReturnNoTaskCommand"));
+            Assert.IsNull(generated.GetType().GetProperty("SomeMethodCommand"));
+        }
+
+        [Test]
+        public void ArgumentTypeForAsyncCommand() {
+            var generated = new GenerateAsyncCommands();
+
+            var noArgumentType = generated.WithNoArgCommand.GetType();
+            Assert.IsEmpty(noArgumentType.GetGenericArguments());
+            var expectedType = typeof(RelayCommand);
+            Assert.AreEqual(expectedType, noArgumentType);
+
+            var intArgumentType = generated.WithArgCommand.GetType().GetGenericArguments()[0];
+            var intExpectedType = typeof(int);
+            Assert.AreEqual(intExpectedType, intArgumentType);
+
+            var nullableIntArgumentType = generated.WithNullableArgCommand.GetType().GetGenericArguments()[0];
+            var nullableIntExpectedType = typeof(int?);
+            Assert.AreEqual(nullableIntExpectedType, nullableIntArgumentType);
+        }
+    }
+}

DevExpress.Mvvm.CodeGenerators.Tests/SharedTests/MvvmToolkit/AttributeTransferTests.cs

@@ -0,0 +1,51 @@
+using DevExpress.Mvvm.CodeGenerators.Tests.Included;
+using NUnit.Framework;
+using System;
+using System.ComponentModel;
+using System.ComponentModel.DataAnnotations;
+using DevExpress.Mvvm.CodeGenerators.MvvmToolkit;
+
+namespace MvvmToolkit.Mvvm.Tests {
+    class MyCustomAttribute : Attribute {
+        public MyCustomAttribute(int value, string str, bool condition, TestEnum testEnum) { }
+    }
+    namespace Included {
+        enum TestEnum {
+            Num = 1,
+            String = 2
+        }
+    }
+    [GenerateViewModel]
+    partial class AttributeTransfer {
+        const int number = 1;
+
+        [GenerateProperty]
+        int noAttribute;
+
+        [GenerateProperty, System.ComponentModel.DataAnnotations.Range(0, 1)]
+        [Required, MyCustom(number,
+                            "Some string",
+                            true, TestEnum.Num)]
+        int withMultipleAttributes;
+    }
+
+    [TestFixture]
+    public class AttributeTransferTests {
+        [Test]
+        public void AttributeTransfer() {
+            var noAttributeProperty = typeof(AttributeTransfer).GetProperty("NoAttribute");
+            var attributes = Attribute.GetCustomAttributes(noAttributeProperty);
+            var expectedAttributes = new Attribute[] { };
+            Assert.AreEqual(expectedAttributes, attributes);
+
+            var withMultipleAttributesProperty = typeof(AttributeTransfer).GetProperty("WithMultipleAttributes");
+            attributes = Attribute.GetCustomAttributes(withMultipleAttributesProperty);
+            expectedAttributes = new Attribute[] {
+                new System.ComponentModel.DataAnnotations.RangeAttribute(0, 1),
+                new RequiredAttribute(),
+                new MyCustomAttribute(1, "Some string", true, TestEnum.Num)
+            };
+            Assert.AreEqual(expectedAttributes, attributes);
+        }
+    }
+}