21.2.2 mvvm light support (#12)

* Add_MvvmLight_Support

* Add mvvm light tests + fix relayCommand namespace

* remove KeepTargetAlive command property + refactoring

* Refactoring

* fix format

Author: BelousovSer

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

@@ -48,6 +48,7 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="DevExpressMvvm" Version="20.2.3" />
+    <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" />
     <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.2" />

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

@@ -16,6 +16,7 @@
 
   <ItemGroup>
     <PackageReference Include="DevExpressMvvm" Version="20.2.3" />
+    <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" />
     <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.2" />

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

@@ -0,0 +1,86 @@
+using NUnit.Framework;
+using System;
+using System.Reflection;
+using System.Threading.Tasks;
+using DevExpress.Mvvm.CodeGenerators.MvvmLight;
+using GalaSoft.MvvmLight.Helpers;
+#if NETCOREAPP
+using GalaSoft.MvvmLight.Command;
+#else
+using GalaSoft.MvvmLight.CommandWpf;
+#endif
+namespace MvvmLight.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<WeakAction<int>, RelayCommand<int>>(generated.MyAsyncCommand, "_execute");
+            StringAssert.Contains("MyAsyncCommand", method.MethodName);
+
+            var canMethod = GetFieldValue<WeakFunc<int, bool>, RelayCommand<int>>(generated.MyAsyncCommand, "_canExecute");
+            var expectedCanMethod = generated.GetType().GetMethod("CanDoIt").Name;
+            Assert.AreEqual(expectedCanMethod, canMethod.MethodName);
+
+            var canExecuteMethod = GetFieldValue<WeakFunc<int, bool>, 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/MvvmLightTest/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.MvvmLight;
+
+namespace MvvmLight.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);
+        }
+    }
+}

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

@@ -0,0 +1,115 @@
+using NUnit.Framework;
+using System;
+using System.Reflection;
+using DevExpress.Mvvm.CodeGenerators.MvvmLight;
+using GalaSoft.MvvmLight.Helpers;
+#if NETCOREAPP
+using GalaSoft.MvvmLight.Command;
+#else
+using GalaSoft.MvvmLight.CommandWpf;
+#endif
+
+namespace MvvmLight.Mvvm.Tests {
+    [GenerateViewModel]
+    partial class GenerateCommands {
+        [GenerateCommand]
+        public void WithNoArg() { }
+        [GenerateCommand]
+        public void WithArg(int arg) { }
+        [GenerateCommand]
+        public void WithNullableArg(int? arg) { }
+        public void SomeMethod() { }
+        public void With2Args(int a, string str) { }
+
+        [GenerateCommand(Name = "Command", CanExecuteMethod = "CanDoIt")]
+        public void Method(int arg) { }
+        public bool CanDoIt(int arg) => arg > 0;
+
+#nullable enable
+        [GenerateCommand]
+        void WithNullableString1(string? str) { }
+        [GenerateCommand]
+        void WithNullableString2(string str) { }
+        [GenerateCommand]
+        void WithNullableString3(string? str) { }
+        bool CanWithNullableString3(string str) => str.Length > 0;
+        bool CanWithNullableString4(string? str) => str?.Length > 0;
+#nullable disable
+        [GenerateCommand]
+        void WithNullableString4(string str) { }
+        bool CanWithNullableString1(string str) => str?.Length > 0;
+        bool CanWithNullableString2(string str) => str.Length > 0;
+    }
+
+    [TestFixture]
+    public class CommandGenerationTests {
+        [Test]
+        public void CommandImplementation() {
+            var generated = new GenerateCommands();
+
+            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("ReturnNoVoidCommand"));
+            Assert.IsNull(generated.GetType().GetProperty("SomeMethodCommand"));
+        }
+
+        [Test]
+        public void CallRequiredMethodForCommand() {
+            var generated = new GenerateCommands();
+
+            var expectedExecuteMethodWithNoArg = generated.GetType().GetMethod("WithNullableArg");
+            var executeMethodWithNoArg = GetFieldValueMethod<MethodInfo, RelayCommand<int?>, WeakAction<int?>>(generated.WithNullableArgCommand, "_execute");
+            Assert.AreEqual(expectedExecuteMethodWithNoArg, executeMethodWithNoArg);
+
+            var method = GetFieldValueMethod<MethodInfo, RelayCommand<int>, WeakAction<int>>(generated.Command, "_execute");
+            var expectedMethod = generated.GetType().GetMethod("Method");
+            Assert.AreEqual(expectedMethod, method);
+
+            var canMethod = GetFieldValueMethod<MethodInfo, RelayCommand<int>, WeakFunc<bool>>(generated.Command, "_canExecute");
+            var expectedCanMethod = generated.GetType().GetMethod("CanDoIt");
+            Assert.AreEqual(expectedCanMethod, canMethod);
+        }
+        static TResult GetFieldValueMethod<TResult, TCommand, T>(TCommand source, string fieldName) {
+            var fieldInfo = source.GetType().GetField(fieldName, BindingFlags.NonPublic | BindingFlags.Instance);
+            Assert.IsNotNull(fieldInfo);
+            var fieldInsance = fieldInfo.GetValue(source);
+            var weakMethod = typeof(T).GetProperty("Method", BindingFlags.NonPublic | BindingFlags.Instance);
+            return (TResult)weakMethod.GetValue(fieldInsance);
+        }
+        [Test]
+        public void ArgumentTypeForCommand() {
+            var generated = new GenerateCommands();
+
+            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);
+        }
+
+        [Test]
+        public void NullableReferenceType() {
+            var generated = new GenerateCommands();
+
+            Assert.IsTrue(generated.WithNullableString1Command.CanExecute("1"));
+            Assert.IsTrue(generated.WithNullableString2Command.CanExecute("1"));
+            Assert.IsTrue(generated.WithNullableString3Command.CanExecute("1"));
+            Assert.IsTrue(generated.WithNullableString4Command.CanExecute("1"));
+
+            Assert.IsFalse(generated.WithNullableString1Command.CanExecute(null));
+            Assert.IsFalse(generated.WithNullableString2Command.CanExecute(""));
+            Assert.IsTrue(generated.WithNullableString3Command.CanExecute(""));
+            Assert.IsFalse(generated.WithNullableString4Command.CanExecute(null));
+        }
+    }
+}

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

@@ -0,0 +1,64 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using NUnit.Framework;
+using System;
+using System.ComponentModel;
+using DevExpress.Mvvm.CodeGenerators.MvvmLight;
+
+namespace MvvmLight.Mvvm.Tests {
+    static class DoWith {
+        static void EventCore<TSender, THandler, TArgs>(
+            TSender sender,
+            Action action,
+            Action<TArgs> eventAction,
+            Func<TSender, EventHandler<TArgs>, THandler> subscribe,
+            Action<TSender, THandler> unsubscribe,
+            int expectedFireCount = 1)
+            where TArgs : EventArgs {
+
+            var fireCount = 0;
+            EventHandler<TArgs> handler = (o, e) => {
+                Assert.AreSame(o, sender);
+                eventAction(e);
+                fireCount++;
+            };
+
+            var h = subscribe(sender, handler);
+            try {
+                action();
+            } finally {
+                unsubscribe(sender, h);
+            }
+            Assert.AreEqual(expectedFireCount, fireCount);
+        }
+
+        public static void PropertyChangedEvent(INotifyPropertyChanged inpc, Action action, Action<PropertyChangedEventArgs> eventAction, int fireCount = 1) {
+            EventCore(
+                inpc,
+                action,
+                eventAction,
+                (o, handler) => {
+                    PropertyChangedEventHandler x = (sender, args) => handler(sender, args);
+                    inpc.PropertyChanged += x;
+                    return x;
+                },
+                (o, handler) => inpc.PropertyChanged -= handler,
+                fireCount
+            );
+        }
+        public static void PropertyChangingEvent(INotifyPropertyChanging inpc, Action action, Action<PropertyChangingEventArgs> eventAction, int fireCount = 1) {
+            EventCore(
+                inpc,
+                action,
+                eventAction,
+                (o, handler) => {
+                    PropertyChangingEventHandler x = (sender, args) => handler(sender, args);
+                    inpc.PropertyChanging += x;
+                    return x;
+                },
+                (o, handler) => inpc.PropertyChanging -= handler,
+                fireCount
+            );
+        }
+    }
+}