Improve option parsing to fix #11 and #12 (#14)

* Introduce dependency on System.AutoValue used by subsequent commits

* Refactor msg-content-map-item parsing to use ParseItem method

Issue #12 was caused by the fact that automatic casts
 were not performed by the orignal implementation of
 the msg-content-map-item parsing code.

When call to AutoCast is added to ParseItem in a subsequent
commit, that fixes the issue.

* Fix parsing of key=~1 style of argument in test_direct_transient_list_message

* Refactor SenderOptions.ParseItem and add additional tests

* Refactor msg-annotation option parsing using ParseItem method

This fixes #12

* Refactor msg-property option parsing using ParseItem method

* Migrate msg-content-list-item to ParseValue and AutoCast methods

Previously, all list items were sent as strings. This change adds
automatic type cast there.

This fixes #11

Author: jiridanek

src/dotNet/ClientLib/ClientLib.csproj

@@ -53,6 +53,10 @@
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Transactions" />
+    <Reference Include="System.ValueTuple, Version=4.0.3.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51">
+      <HintPath>..\..\..\packages\System.ValueTuple.4.5.0\lib\netstandard1.0\System.ValueTuple.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="Microsoft.CSharp" />

src/dotNet/ClientLib/OptionsParser.cs

@@ -302,35 +302,8 @@ public SenderOptions() : base()
                 (string subject) => { this.Subject = subject; });
             this.Add("msg-property=", "specify reply-to property",
                 (string property) => {
-                    char[] delimiters = { '=', '~' };
-                    string[] pair = property.Split(delimiters);
-                    int valueIndex = pair.Length == 2 ? 1 : 2;
-                    if (pair.Length == 2 || pair.Length == 3)
-                    {
-                        double doubleVal;
-                        int intVal;
-                        bool boolVal;
-                        if (int.TryParse(pair[valueIndex], out intVal))
-                        {
-                            this.Properties.Add(pair[0], intVal);
-                        }
-                        else if (double.TryParse(pair[valueIndex], out doubleVal))
-                        {
-                            this.Properties.Add(pair[0], doubleVal);
-                        }
-                        else if (Boolean.TryParse(pair[valueIndex], out boolVal))
-                        {
-                            this.Properties.Add(pair[0], boolVal);
-                        }
-                        else
-                        {
-                            this.Properties.Add(pair[0], pair[valueIndex]);
-                        }
-                    }
-                    else
-                    {
-                        throw new ArgumentException();
-                    }
+                    var (key, value) = ParseItem(property);
+                    this.Properties.Add(key, value);
                 });
             this.Add("property-type=", "specify message property type (overrides auto-cast feature)",
                 (string propertyType) => { this.PropertyType = propertyType; });
@@ -364,54 +337,80 @@ public SenderOptions() : base()
                 (string content) => { this.Content = content; });
             this.Add("L|msg-content-list-item=", "specify a multiple entries content",
                 (string listItem) => {
-                    this.ListContent.Add(listItem);
+                    this.ListContent.Add(ParseValue(listItem));
                 });
             this.Add("M|msg-content-map-item=", "KEY=VALUE specify a map content",
                 (string mapItem) => {
-                    char[] delimiters = { '=', '~' };
-                    string[] pair = mapItem.Split(delimiters);
-                    if (pair.Length == 2)
-                    {
-                        this.MapContent.Add(pair[0], pair[1]);
-                    }
-                    else if (pair.Length == 3)
-                    {
-                        this.MapContent.Add(pair[0], pair[2]);
-                    }
-                    else
-                    {
-                        throw new ArgumentException();
-                    }
+                    var (key, value) = ParseItem(mapItem);
+                    this.MapContent.Add(key, value);
                 });
             this.Add("msg-content-from-file=", "specify file name to load the content from",
                 (string path) => { this.ContentFromFile = ReadInputFile(path); });
             this.Add("msg-annotation=", "specify amqp properties",
                 (string annotation) => {
-                    char[] delimiters = { '=', '~' };
-                    string[] pair = annotation.Split(delimiters);
-                    if (pair.Length == 2)
-                    {
-                        double doubleVal;
-                        bool boolVal;
-                        if (double.TryParse(pair[1], out doubleVal))
-                        {
-                            this.MessageAnnotations[new Symbol(pair[0])] = doubleVal;
-                        }
-                        else if (Boolean.TryParse(pair[1], out boolVal))
-                        {
-                            this.MessageAnnotations[new Symbol(pair[0])] = boolVal;
-                        }
-                        else
-                        {
-                            this.MessageAnnotations[new Symbol(pair[0])] = pair[1];
-                        }
-                    }
-                    else
-                    {
-                        throw new ArgumentException();
-                    }
+                    var (key, value) = ParseItem(annotation);
+                    this.MessageAnnotations[new Symbol(key)] = value;
                 });
         }
+
+        public static (string, object) ParseItem(string mapItem)
+        {
+            char[] delimiters = {'=', '~'};
+            int i = mapItem.IndexOfAny(delimiters);
+
+            if (i == -1)
+            {
+                throw new ArgumentException();
+            }
+
+            var key = mapItem.Substring(0, i);
+            var value = mapItem.Substring(i+1);
+
+            if (mapItem[i] == '~')
+            {
+                return (key, AutoCast(value));
+            }
+            return (key, value);
+        }
+
+        public static object ParseValue(string value)
+        {
+            if (value.Length >= 1 && value[0] == '~')
+            {
+                return AutoCast(value.Substring(1));
+            }
+
+            return value;
+        }
+
+        private static object AutoCast(string value)
+        {
+            int intVal;
+            double doubleVal;
+            bool boolVal;
+
+            if (int.TryParse(value, out intVal))
+            {
+                return intVal;
+            }
+
+            if (double.TryParse(value, out doubleVal))
+            {
+                return doubleVal;
+            }
+
+            if (Boolean.TryParse(value, out boolVal))
+            {
+                return boolVal;
+            }
+
+            if (value == string.Empty)
+            {
+                return null;
+            }
+
+            return value;
+        }
     }
 
     /// <summary>

src/dotNet/ClientLib/packages.config

@@ -2,4 +2,5 @@
 <packages>
   <package id="AMQPNetLite" version="2.1.3" targetFramework="net45" />
   <package id="Newtonsoft.Json" version="11.0.2" targetFramework="net45" />
+  <package id="System.ValueTuple" version="4.5.0" targetFramework="net45" />
 </packages>

test/ClientUnitTests/ClientUnitTests.csproj

@@ -52,6 +52,10 @@
       <HintPath>..\..\packages\NUnit.3.10.1\lib\net45\nunit.framework.dll</HintPath>
     </Reference>
     <Reference Include="System" />
+    <Reference Include="System.ValueTuple, Version=4.0.3.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51">
+      <HintPath>..\..\packages\System.ValueTuple.4.5.0\lib\netstandard1.0\System.ValueTuple.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
   </ItemGroup>
   <Choose>
     <When Condition="('$(VisualStudioVersion)' == '10.0' or '$(VisualStudioVersion)' == '') and '$(TargetFrameworkVersion)' == 'v3.5'">
@@ -64,6 +68,7 @@
   <ItemGroup>
     <Compile Include="BasicBinTests.cs" />
     <Compile Include="ClientRunner.cs" />
+    <Compile Include="OptionParserTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SendReceiveTests.cs" />
   </ItemGroup>

test/ClientUnitTests/OptionParserTests.cs

@@ -0,0 +1,124 @@
+using System;
+using ClientLib;
+using NUnit.Framework;
+
+namespace ClientUnitTests
+{
+    // https://haacked.com/archive/2012/01/02/structuring-unit-tests.aspx/
+    public class TheSenderOptionsItemParser
+    {
+        [Test]
+        public void ThrowsOnEmptyString()
+        {
+            Assert.Throws<ArgumentException>(() => SenderOptions.ParseItem(""));
+        }
+        
+        [Test]
+        public void ParsesEqualsStringAsString()
+        {
+            Assert.AreEqual(ValueTuple.Create("key", "aString"), SenderOptions.ParseItem("key=aString"));
+        }
+
+        [Test]
+        public void ParsesEqualsIntAsString()
+        {
+            Assert.AreEqual(ValueTuple.Create("key", "42"), SenderOptions.ParseItem("key=42"));
+        }
+
+        [Test]
+        public void ParsesEqualsTildeAsString()
+        {
+            Assert.AreEqual(ValueTuple.Create("key", "~1"), SenderOptions.ParseItem("key=~1"));
+        }
+
+        [Test]
+        public void ParsesDoubleTildeAsString()
+        {
+            Assert.AreEqual(ValueTuple.Create("key", "~1"), SenderOptions.ParseItem("key~~1"));
+        }
+
+        [Test]
+        public void ParsesDoubleEqualsAsString()
+        {
+            Assert.AreEqual(ValueTuple.Create("key", "=1"), SenderOptions.ParseItem("key==1"));
+        }
+
+        [Test]
+        public void ParsesTildeStringAsString()
+        {
+            Assert.AreEqual(ValueTuple.Create("key", "aString"), SenderOptions.ParseItem("key~aString"));
+        }
+
+        [Test]
+        public void ParsesEqualsEmptyAsEmptyString()
+        {
+            Assert.AreEqual(ValueTuple.Create("key", ""), SenderOptions.ParseItem("key="));
+        }
+
+        /// <summary>
+        /// Note: null key is not supported py ParseItem
+        /// </summary>
+        [Test]
+        public void ParsesEmptyEqualsAsEmptyStringKey()
+        {
+            Assert.AreEqual(ValueTuple.Create("", "aString"), SenderOptions.ParseItem("=aString"));
+        }
+        
+        [Test]
+        public void ParsesTildeEmptyAsNull()
+        {
+            Assert.AreEqual(ValueTuple.Create("key", (String) null), SenderOptions.ParseItem("key~"));
+        }
+
+        [Test]
+        public void ParsesTildeDoubleAsDouble()
+        {
+            Assert.AreEqual(ValueTuple.Create("key", 3.14d), SenderOptions.ParseItem("key~3.14"));
+        }
+
+        [Test]
+        public void ParsesTildeBoolAsBool()
+        {
+            Assert.AreEqual(ValueTuple.Create("key", false), SenderOptions.ParseItem("key~False"));
+        }
+
+        [Test]
+        public void ParseTildeStringAsString()
+        {
+            Assert.AreEqual(ValueTuple.Create("key", "aString"), SenderOptions.ParseItem("key~aString"));
+        }
+
+        [Test]
+        public void ParsesTildeIntAsInt()
+        {
+            Assert.AreEqual(ValueTuple.Create("key", 42), SenderOptions.ParseItem("key~42"));
+        }
+    }
+
+    public class TheSenderOptionsValueParser
+    {
+        [Test]
+        public void ParsesEmtpyStringAsEmptyString()
+        {
+            Assert.AreEqual(string.Empty, SenderOptions.ParseValue(""));
+        }
+
+        [Test]
+        public void ParsesTildeAsNull()
+        {
+            Assert.AreEqual(null, SenderOptions.ParseValue("~"));
+        }
+
+        [Test]
+        public void ParsesDoubleTildeAsString()
+        {
+            Assert.AreEqual("~", SenderOptions.ParseValue("~~"));
+        }
+
+        [Test]
+        public void ParsesTildeIntAsInt()
+        {
+            Assert.AreEqual(42, SenderOptions.ParseValue("~42"));
+        }
+    }
+}

test/ClientUnitTests/packages.config

@@ -3,4 +3,5 @@
   <package id="NUnit" version="3.10.1" targetFramework="net45" />
   <package id="NUnit3TestAdapter" version="3.10.0" targetFramework="net45" />
   <package id="NUnitTestAdapter" version="2.1.1" targetFramework="net45" />
+  <package id="System.ValueTuple" version="4.5.0" targetFramework="net45" />
 </packages>