Multi-value argument fixes WIP

Author: jpdillingham

Utility.CommandLine.Arguments.Tests/Arguments.cs

@@ -450,7 +450,9 @@ public void ParseValueWithQuotedPeriod()
         [Fact]
         public void Populate()
         {
-            CommandLine.Arguments.Populate("-b");
+            Exception ex = Record.Exception(() => CommandLine.Arguments.Populate("-b"));
+
+            Assert.Null(ex);
         }
 
         /// <summary>
@@ -743,6 +745,22 @@ public void PopulateSingle()
             Assert.Equal("one", Array[0]);
         }
 
+        /// <summary>
+        ///     Tests the <see cref="Utility.CommandLine.Arguments.Populate(Type, string)"/> method with an explicit string
+        ///     containing multiple instances of an array-backed argument, and containing a change from short to long names and back.
+        /// </summary>
+        [Fact]
+        public void PopulateWithNameChange()
+        {
+            Exception ex = Record.Exception(() => CommandLine.Arguments.Populate(GetType(), "-a one --array two -a three"));
+
+            Assert.Null(ex);
+            Assert.Equal(3, Array.Length);
+            Assert.Equal("one", Array[0]);
+            Assert.Equal("two", Array[1]);
+            Assert.Equal("three", Array[2]);
+        }
+
         #endregion Public Methods
     }
 
@@ -830,6 +848,22 @@ public void PopulateSingle()
             Assert.Equal("one", List[0]);
         }
 
+        /// <summary>
+        ///     Tests the <see cref="Utility.CommandLine.Arguments.Populate(Type, string)"/> method with an explicit string
+        ///     containing multiple instances of a list-backed argument, and containing a change from short to long names and back.
+        /// </summary>
+        [Fact]
+        public void PopulateWithNameChange()
+        {
+            Exception ex = Record.Exception(() => CommandLine.Arguments.Populate(GetType(), "-l one --list two -l three"));
+
+            Assert.Null(ex);
+            Assert.Equal(3, List.Count);
+            Assert.Equal("one", List[0]);
+            Assert.Equal("two", List[1]);
+            Assert.Equal("three", List[2]);
+        }
+
         #endregion Public Methods
     }
 

Utility.CommandLine.Arguments/Arguments.cs

@@ -312,7 +312,7 @@ public static void Populate(Dictionary<string, object> argumentDictionary)
         /// <summary>
         ///     Populates the properties in the specified Type marked with the
         ///     <see cref="ArgumentAttribute"/><see cref="Attribute"/> with the values specified in the specified argument
-        ///     dictionary, if present.
+        ///     dictionary, if present. All property values are set to null at the start of the routine.
         /// </summary>
         /// <param name="type">
         ///     The Type for which the static properties matching the list of command line arguments are to be populated.
@@ -323,9 +323,11 @@ public static void Populate(Dictionary<string, object> argumentDictionary)
         /// </param>
         public static void Populate(Type type, Arguments arguments)
         {
-            // fetch any properties in the specified type marked with the ArgumentAttribute attribute
+            // fetch any properties in the specified type marked with the ArgumentAttribute attribute and clear them
             Dictionary<string, PropertyInfo> properties = GetArgumentProperties(type);
 
+            ClearProperties(properties);
+
             foreach (string propertyName in properties.Keys)
             {
                 // if the argument dictionary contains a matching argument
@@ -338,7 +340,7 @@ public static void Populate(Type type, Arguments arguments)
                     // retrieve the value from the argument dictionary
                     object value = arguments.ArgumentDictionary[propertyName];
 
-                    bool valueIsArrayOrList = value.GetType().IsGenericType && value.GetType().GetGenericTypeDefinition() == typeof(List<>);
+                    bool valueIsList = value.GetType().IsGenericType && value.GetType().GetGenericTypeDefinition() == typeof(List<>);
 
                     object convertedValue;
 
@@ -352,7 +354,7 @@ public static void Populate(Type type, Arguments arguments)
                     {
                         // if the property is an array or list, convert the value to an array or list of the matching type. start
                         // by converting atomic values to a list containing a single value, just to simplify processing.
-                        if (valueIsArrayOrList)
+                        if (valueIsList)
                         {
                             convertedValue = value;
                         }
@@ -405,7 +407,7 @@ public static void Populate(Type type, Arguments arguments)
                     {
                         // if the target property Type is an atomic (non-array or list) Type, convert the value and populate it,
                         // but not if the value is an array or list.
-                        if (valueIsArrayOrList)
+                        if (valueIsList)
                         {
                             throw new InvalidCastException($"Multiple values were specified for argument '{propertyName}', however it is not backed by an array or List<T>.  Specify only one value.");
                         }
@@ -414,7 +416,7 @@ public static void Populate(Type type, Arguments arguments)
                     }
 
                     // set the target properties' value to the converted value from the argument string
-                    property.SetValue(null, convertedValue);
+                    AppendPropertyValue(property, convertedValue);
                 }
             }
 
@@ -439,6 +441,23 @@ public static void Populate(Type type, Arguments arguments)
 
         #region Private Methods
 
+        /// <summary>
+        ///     Appends the value of the specified property with the specified value.
+        /// </summary>
+        /// <remarks>Assumes that only static properties are to be set.</remarks>
+        /// <param name="property">The property for which the value is to be set.</param>
+        /// <param name="value">The value to set.</param>
+        private static void AppendPropertyValue(PropertyInfo property, object value)
+        {
+            object currentValue = property.GetValue(null);
+
+            if (property.GetType() != typeof(bool))
+            {
+            }
+
+            property.SetValue(null, value);
+        }
+
         /// <summary>
         ///     Converts the specified value for the specified argument to the specified Type.
         /// </summary>
@@ -462,6 +481,18 @@ private static object ChangeType(object value, string argument, Type toType)
             }
         }
 
+        /// <summary>
+        ///     Sets the value of each property in the specified dictionary to null.
+        /// </summary>
+        /// <param name="properties">The dictionary containing the properties to clear.</param>
+        private static void ClearProperties(Dictionary<string, PropertyInfo> properties)
+        {
+            foreach (string key in properties.Keys)
+            {
+                properties[key].SetValue(null, null);
+            }
+        }
+
         /// <summary>
         ///     Populates and returns a dictionary containing the values specified in the command line arguments with which the
         ///     application was started, keyed by argument name.