Adds support for float and double types

atruskie · natemcmaster · commit 276391cb099f · 2018-02-15T23:08:20.000-08:00
This commit allows the CommandLineUtils to parse:

- doubles
- floats
- and nullable variants of both

It also infers the CommandOptionType in the same manner that is done
for integers.
diff --git a/src/CommandLineUtils/Internal/CommandOptionTypeMapper.cs b/src/CommandLineUtils/Internal/CommandOptionTypeMapper.cs
@@ -62,7 +62,9 @@ public CommandOptionType GetOptionType(Type clrType)
                 || typeof(long) == clrType
                 || typeof(ushort) == clrType
                 || typeof(uint) == clrType
-                || typeof(ulong) == clrType)
+                || typeof(ulong) == clrType
+                || typeof(float) == clrType
+                || typeof(double) == clrType)
             {
                 return CommandOptionType.SingleValue;
             }
diff --git a/src/CommandLineUtils/Internal/ValueParserProvider.cs b/src/CommandLineUtils/Internal/ValueParserProvider.cs
@@ -22,6 +22,8 @@ internal class ValueParserProvider
             { typeof(ushort), UInt16ValueParser.Singleton },
             { typeof(uint), UInt32ValueParser.Singleton },
             { typeof(ulong), UInt64ValueParser.Singleton },
+            { typeof(float), FloatValueParser.Singleton },
+            { typeof(double), DoubleValueParser.Singleton },
         };
 
         private ValueParserProvider()
diff --git a/src/CommandLineUtils/Internal/ValueParsers/DoubleValueParser.cs b/src/CommandLineUtils/Internal/ValueParsers/DoubleValueParser.cs
@@ -0,0 +1,22 @@
+﻿// Copyright (c) Nate McMaster.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace McMaster.Extensions.CommandLineUtils.ValueParsers
+{
+    internal class DoubleValueParser : IValueParser
+    {
+        private DoubleValueParser()
+        { }
+
+        public static DoubleValueParser Singleton { get; } = new DoubleValueParser();
+
+        public object Parse(string argName, string value)
+        {
+            if (!double.TryParse(value, out var result))
+            {
+                throw new CommandParsingException(null, $"Invalid value specified for {argName}. '{value}' is not a valid floating-point number.");
+            }
+            return result;
+        }
+    }
+}
diff --git a/src/CommandLineUtils/Internal/ValueParsers/FloatValueParser.cs b/src/CommandLineUtils/Internal/ValueParsers/FloatValueParser.cs
@@ -0,0 +1,22 @@
+﻿// Copyright (c) Nate McMaster.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace McMaster.Extensions.CommandLineUtils.ValueParsers
+{
+    internal class FloatValueParser : IValueParser
+    {
+        private FloatValueParser()
+        { }
+
+        public static FloatValueParser Singleton { get; } = new FloatValueParser();
+
+        public object Parse(string argName, string value)
+        {
+            if (!float.TryParse(value, out var result))
+            {
+                throw new CommandParsingException(null, $"Invalid value specified for {argName}. '{value}' is not a valid floating-point number.");
+            }
+            return result;
+        }
+    }
+}
diff --git a/test/CommandLineUtils.Tests/CommandOptionTypeMapperTests.cs b/test/CommandLineUtils.Tests/CommandOptionTypeMapperTests.cs
@@ -19,13 +19,17 @@ public class CommandOptionTypeMapperTests
         [InlineData(typeof(uint), CommandOptionType.SingleValue)]
         [InlineData(typeof(ulong), CommandOptionType.SingleValue)]
         [InlineData(typeof(ushort), CommandOptionType.SingleValue)]
+        [InlineData(typeof(float), CommandOptionType.SingleValue)]
+        [InlineData(typeof(double), CommandOptionType.SingleValue)]
         [InlineData(typeof(byte?), CommandOptionType.SingleValue)]
         [InlineData(typeof(short?), CommandOptionType.SingleValue)]
         [InlineData(typeof(int?), CommandOptionType.SingleValue)]
         [InlineData(typeof(long?), CommandOptionType.SingleValue)]
         [InlineData(typeof(ushort?), CommandOptionType.SingleValue)]
         [InlineData(typeof(uint?), CommandOptionType.SingleValue)]
         [InlineData(typeof(ulong?), CommandOptionType.SingleValue)]
+        [InlineData(typeof(float?), CommandOptionType.SingleValue)]
+        [InlineData(typeof(double?), CommandOptionType.SingleValue)]
         [InlineData(typeof(string), CommandOptionType.SingleValue)]
         [InlineData(typeof(byte[]), CommandOptionType.MultipleValue)]
         [InlineData(typeof(short[]), CommandOptionType.MultipleValue)]
diff --git a/test/CommandLineUtils.Tests/ValueParserProviderTests.cs b/test/CommandLineUtils.Tests/ValueParserProviderTests.cs
@@ -6,6 +6,8 @@
 
 namespace McMaster.Extensions.CommandLineUtils.Tests
 {
+    using System.Globalization;
+
     public class ValueParserProviderTests
     {
         public enum Color
@@ -29,6 +31,12 @@ private class Program
             [Option("--int64")]
             public long Int64 { get; }
 
+            [Option("--float")]
+            public float Float { get; }
+
+            [Option("--double")]
+            public double Double { get; }
+
             [Option("--bool", CommandOptionType.SingleValue)]
             public bool Bool { get; }
 
@@ -41,6 +49,12 @@ private class Program
             [Option("--int64-opt")]
             public long? Int64Opt { get; }
 
+            [Option("--float-opt")]
+            public float? FloatOpt { get; }
+
+            [Option("--double-opt")]
+            public double? DoubleOpt { get; }
+
             [Option("--uint32")]
             public uint UInt32 { get; }
 
@@ -66,6 +80,17 @@ private class Program
             public Color ColorOption { get; }
         }
 
+        public static IEnumerable<object[]> GetFloatingPointSymbolsData()
+        {
+            var format = CultureInfo.CurrentCulture.NumberFormat;
+            return new[]
+                   {
+                       new object[] { format.PositiveInfinitySymbol, float.PositiveInfinity },
+                       new object[] { format.NegativeInfinitySymbol, float.NegativeInfinity },
+                       new object[] { format.NaNSymbol, float.NaN},
+                   };
+        }
+
         [Theory]
         [InlineData("255", byte.MaxValue)]
         [InlineData("1", 1)]
@@ -130,6 +155,56 @@ public void ParsesLongNullable(string arg, long? result)
             Assert.Equal(result, parsed.Int64Opt);
         }
 
+        [Theory]
+        [InlineData("0.0", 0.0f)]
+        [InlineData("123456789.987654321", 123456789.987654321f)]
+        [InlineData("-123.456", -123.456f)]
+        [InlineData("-1E10", -1E10f)]
+        [MemberData(nameof(GetFloatingPointSymbolsData))]
+        public void ParsesFloat(string arg, float result)
+        {
+            var parsed = CommandLineParser.ParseArgs<Program>("--float", arg);
+            Assert.Equal(result, parsed.Float);
+        }
+
+        [Theory]
+        [InlineData("0.0", 0.0)]
+        [InlineData("123456789.987654321", 123456789.987654321)]
+        [InlineData("-123.456", -123.456)]
+        [InlineData("-1E10", -1E10)]
+        [MemberData(nameof(GetFloatingPointSymbolsData))]
+        public void ParsesDouble(string arg, double result)
+        {
+            var parsed = CommandLineParser.ParseArgs<Program>("--double", arg);
+            Assert.Equal(result, parsed.Double);
+        }
+
+        [Theory]
+        [InlineData("0.0", 0.0f)]
+        [InlineData("123456789.987654321", 123456789.987654321f)]
+        [InlineData("-123.456", -123.456f)]
+        [InlineData("-1E10", -1E10f)]
+        [MemberData(nameof(GetFloatingPointSymbolsData))]
+        [InlineData("", null)]
+        public void ParsesFloatNullable(string arg, float? result)
+        {
+            var parsed = CommandLineParser.ParseArgs<Program>("--float-opt", arg);
+            Assert.Equal(result, parsed.FloatOpt);
+        }
+
+        [Theory]
+        [InlineData("0.0", 0.0)]
+        [InlineData("123456789.987654321", 123456789.987654321)]
+        [InlineData("-123.456", -123.456)]
+        [InlineData("-1E10", -1E10)]
+        [MemberData(nameof(GetFloatingPointSymbolsData))]
+        [InlineData("", null)]
+        public void ParsesDoubleNullable(string arg, double? result)
+        {
+            var parsed = CommandLineParser.ParseArgs<Program>("--double-opt", arg);
+            Assert.Equal(result, parsed.DoubleOpt);
+        }
+
         [Theory]
         [InlineData("true", true)]
         [InlineData("True", true)]

Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,9 @@ public CommandOptionType GetOptionType(Type clrType)`
`62`	`62`	`\|\| typeof(long) == clrType`
`63`	`63`	`\|\| typeof(ushort) == clrType`
`64`	`64`	`\|\| typeof(uint) == clrType`
`65`		`- \|\| typeof(ulong) == clrType)`
	`65`	`+ \|\| typeof(ulong) == clrType`
	`66`	`+ \|\| typeof(float) == clrType`
	`67`	`+ \|\| typeof(double) == clrType)`
`66`	`68`	`{`
`67`	`69`	`return CommandOptionType.SingleValue;`
`68`	`70`	`}`