Merge pull request #9 from jpdillingham/dev

Corrected an issue passing a null or empty value to Parse(), enabled Public properties to be used as the target of Populate()

Author: jpdillingham

Utility.CommandLine.Arguments.Tests/Arguments.cs

@@ -167,24 +167,6 @@ public void Parse()
             Assert.NotEmpty(test);
         }
 
-        /// <summary>
-        ///     Tests the <see cref="Utility.CommandLine.Arguments.Parse(string)"/> method with an explicit operand delimiter.
-        /// </summary>
-        [Fact]
-        public void ParseStrictOperands()
-        {
-            CommandLine.Arguments test = CommandLine.Arguments.Parse("--test one two -- three -four --five /six \"seven eight\" 'nine ten'");
-
-            Assert.Equal(7, test.OperandList.Count);
-            Assert.Equal("two", test.OperandList[0]);
-            Assert.Equal("three", test.OperandList[1]);
-            Assert.Equal("-four", test.OperandList[2]);
-            Assert.Equal("--five", test.OperandList[3]);
-            Assert.Equal("/six", test.OperandList[4]);
-            Assert.Equal("\"seven eight\"", test.OperandList[5]);
-            Assert.Equal("'nine ten'", test.OperandList[6]);
-        }
-
         /// <summary>
         ///     Tests the <see cref="Utility.CommandLine.Arguments.Parse(string)"/> method with an explicit command line string
         ///     containing a mixture of upper and lower case arguments.
@@ -207,6 +189,17 @@ public void ParseCaseSensitive()
             Assert.False(test.ContainsKey("C"));
         }
 
+        /// <summary>
+        ///     Tests the <see cref="Utility.CommandLine.Arguments.Parse(string)"/> method with an empty string.
+        /// </summary>
+        [Fact]
+        public void ParseEmpty()
+        {
+            Exception ex = Record.Exception(() => CommandLine.Arguments.Parse(string.Empty));
+
+            Assert.Null(ex);
+        }
+
         /// <summary>
         ///     Tests the <see cref="Utility.CommandLine.Arguments.Parse(string)"/> method with an explicit command line string
         ///     containing values with inner quoted strings.
@@ -265,6 +258,17 @@ public void ParseMultipleQuotes()
             Assert.Equal("4", test["test4"]);
         }
 
+        /// <summary>
+        ///     Tests the <see cref="Utility.CommandLine.Arguments.Parse(string)"/> method with a null argument.
+        /// </summary>
+        [Fact]
+        public void ParseNull()
+        {
+            Exception ex = Record.Exception(() => CommandLine.Arguments.Parse(null));
+
+            Assert.Null(ex);
+        }
+
         /// <summary>
         ///     Tests the <see cref="Utility.CommandLine.Arguments.Parse(string)"/> method with a string containing only a series
         ///     of operands.
@@ -324,6 +328,37 @@ public void ParseShorts()
             Assert.Equal("hello world", test["c"]);
         }
 
+        /// <summary>
+        ///     Tests the <see cref="Utility.CommandLine.Arguments.Parse(string)"/> method with an explicit operand delimiter.
+        /// </summary>
+        [Fact]
+        public void ParseStrictOperands()
+        {
+            CommandLine.Arguments test = CommandLine.Arguments.Parse("--test one two -- three -four --five /six \"seven eight\" 'nine ten'");
+
+            Assert.Equal(7, test.OperandList.Count);
+            Assert.Equal("two", test.OperandList[0]);
+            Assert.Equal("three", test.OperandList[1]);
+            Assert.Equal("-four", test.OperandList[2]);
+            Assert.Equal("--five", test.OperandList[3]);
+            Assert.Equal("/six", test.OperandList[4]);
+            Assert.Equal("\"seven eight\"", test.OperandList[5]);
+            Assert.Equal("'nine ten'", test.OperandList[6]);
+        }
+
+        /// <summary>
+        ///     Tests the <see cref="Utility.CommandLine.Arguments.Parse(string)"/> method with an explicit operand delimiter, and
+        ///     nothing after the delimiter.
+        /// </summary>
+        [Fact]
+        public void ParseStrictOperandsEmpty()
+        {
+            CommandLine.Arguments test = CommandLine.Arguments.Parse("--test one two -- ");
+
+            Assert.Equal(1, test.OperandList.Count);
+            Assert.Equal("two", test.OperandList[0]);
+        }
+
         /// <summary>
         ///     Tests the <see cref="Utility.CommandLine.Arguments.Parse(string)"/> method with an explicit command line string
         ///     containing only long parameters.
@@ -459,6 +494,20 @@ public void PopulateTypeMismatch()
             Assert.IsType<ArgumentException>(ex);
         }
 
+        /// <summary>
+        ///     Tests the <see cref="Utility.CommandLine.Arguments.Populate(Type, string)"/> method with a Type external to the
+        ///     calling class and with an explicit string.
+        /// </summary>
+        [Fact]
+        public void PopulateExternalClass()
+        {
+            CommandLine.Arguments.Populate(typeof(TestClassPublicProperties), "--test test! operand1 operand2");
+
+            Assert.Equal("test!", TestClassPublicProperties.Test);
+            Assert.Equal("operand1", TestClassPublicProperties.Operands[0]);
+            Assert.Equal("operand2", TestClassPublicProperties.Operands[1]);
+        }
+
         #endregion Public Methods
     }
 
@@ -497,7 +546,7 @@ public class TestClassWithArrayOperands
         ///     Gets or sets a test property.
         /// </summary>
         [CommandLine.Operands]
-        private static string[] Operands { get; set; }
+        public static string[] Operands { get; set; }
 
         #endregion Private Properties
 
@@ -581,4 +630,23 @@ public void Populate()
 
         #endregion Public Methods
     }
+
+    /// <summary>
+    ///     Unit tests for the <see cref="CommandLine.Arguments"/> class.
+    /// </summary>
+    /// <remarks>Used to facilitate testing of a class with public properties.</remarks>
+    public class TestClassPublicProperties
+    {
+        /// <summary>
+        ///     Gets or sets a test property.
+        /// </summary>
+        [CommandLine.Argument('t', "test")]
+        public static string Test { get; set; }
+
+        /// <summary>
+        ///     Gets or sets a test property.
+        /// </summary>
+        [CommandLine.Operands]
+        public static string[] Operands { get; set; }
+    }
 }

Utility.CommandLine.Arguments/Arguments.cs

@@ -137,6 +137,11 @@ public class Arguments
         /// </summary>
         private const string GroupRegEx = "^-[^-]+";
 
+        /// <summary>
+        ///     The regular expression with which to parse strings strictly containing operands.
+        /// </summary>
+        private const string OperandRegEx = "([^ ([^'\\\"]+|\\\"[^\\\"]+\\\"|\\\'[^']+\\\')";
+
         /// <summary>
         ///     The regular expression with which to split the command line string explicitly among argument/value pairs and
         ///     operands, and strictly operands.
@@ -147,11 +152,6 @@ public class Arguments
         /// </remarks>
         private const string StrictOperandSplitRegEx = "(.*?)[^\\\"\\\']\\B-{2}\\B[^\\\"\\\'](.*)";
 
-        /// <summary>
-        ///     The regular expression with which to parse strings strictly containing operands.
-        /// </summary>
-        private const string OperandRegEx = "([^ ([^'\\\"]+|\\\"[^\\\"]+\\\"|\\\'[^']+\\\')";
-
         #endregion Private Fields
 
         #region Private Constructors
@@ -217,9 +217,9 @@ public string this[string index]
         ///     The dictionary containing the arguments and values specified in the command line arguments with which the
         ///     application was started.
         /// </returns>
-        public static Arguments Parse(string commandLineString = "")
+        public static Arguments Parse(string commandLineString = default(string))
         {
-            commandLineString = commandLineString.Equals(string.Empty) ? Environment.CommandLine : commandLineString;
+            commandLineString = commandLineString == default(string) || commandLineString == string.Empty ? Environment.CommandLine : commandLineString;
 
             Dictionary<string, string> argumentDictionary;
             List<string> operandList;
@@ -237,7 +237,7 @@ public static Arguments Parse(string commandLineString = "")
 
                 // the first group of the second match will contain everything in the string after the strict operand delimiter, so
                 // extract the operands from that string using the strict method.
-                if (matches[0].Groups.Count > 1)
+                if (matches[0].Groups[2].Value != string.Empty)
                 {
                     List<string> operandListStrict = GetOperandListStrict(matches[0].Groups[2].Value);
 
@@ -260,10 +260,8 @@ public static Arguments Parse(string commandLineString = "")
         ///     arguments, if present.
         /// </summary>
         /// <param name="commandLineString">The command line arguments with which the application was started.</param>
-        public static void Populate(string commandLineString = "")
+        public static void Populate(string commandLineString = default(string))
         {
-            commandLineString = commandLineString.Equals(string.Empty) ? Environment.CommandLine : commandLineString;
-
             Populate(new StackFrame(1).GetMethod().DeclaringType, Parse(commandLineString));
         }
 
@@ -276,10 +274,8 @@ public static void Populate(string commandLineString = "")
         ///     The Type for which the static properties matching the list of command line arguments are to be populated.
         /// </param>
         /// <param name="commandLineString">The command line arguments with which the application was started.</param>
-        public static void Populate(Type type, string commandLineString = "")
+        public static void Populate(Type type, string commandLineString = default(string))
         {
-            commandLineString = commandLineString.Equals(string.Empty) ? Environment.CommandLine : commandLineString;
-
             Populate(type, Parse(commandLineString));
         }
 
@@ -438,7 +434,7 @@ private static Dictionary<string, PropertyInfo> GetArgumentProperties(Type type)
         {
             Dictionary<string, PropertyInfo> properties = new Dictionary<string, PropertyInfo>();
 
-            foreach (PropertyInfo property in type.GetProperties(BindingFlags.NonPublic | BindingFlags.Static))
+            foreach (PropertyInfo property in type.GetProperties(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static))
             {
                 // attempt to fetch the ArgumentAttribute of the property
                 CustomAttributeData attribute = property.CustomAttributes.Where(a => a.AttributeType.Name == typeof(ArgumentAttribute).Name).FirstOrDefault();
@@ -525,7 +521,7 @@ private static List<string> GetOperandListStrict(string operandListString)
         /// </exception>
         private static PropertyInfo GetOperandsProperty(Type type)
         {
-            PropertyInfo property = type.GetProperties(BindingFlags.NonPublic | BindingFlags.Static)
+            PropertyInfo property = type.GetProperties(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static)
                 .Where(p => p.CustomAttributes
                     .Any(a => a.AttributeType.Name == typeof(OperandsAttribute).Name))
                         .FirstOrDefault();