Merge pull request #358 from anthonylangsworth/type_conversion

Fix for invalid cast when specifying true or false for int option (#339)

Author: nemec

.gitignore

@@ -41,4 +41,5 @@ artifacts/*
 *.nuget.targets
 *.lock.json
 *.nuget.props
+*.DotSettings.user
 

src/CommandLine/Core/TypeConverter.cs

@@ -84,7 +84,7 @@ private static Result<object, Exception> ChangeTypeScalarImpl(string value, Type
 return(value==null)?empty():withValue();
 };
 
-returnvalue.IsBooleanString()
+returnvalue.IsBooleanString()&&conversionType==typeof(bool)
 ?value.ToBoolean():conversionType.GetTypeInfo().IsEnum
 ?value.ToEnum(conversionType,ignoreValueCase):safeChangeType();
 };

tests/CommandLine.Tests/CommandLine.Tests.csproj

@@ -112,6 +112,7 @@
  <SubType>Code</SubType>
  </Compile>
  <CompileInclude="Unit\Core\TokenTests.cs" />
+ <CompileInclude="Unit\Core\TypeConverterTests.cs" />
  <CompileInclude="Unit\Infrastructure\FSharpOptionHelperTests.cs" />
  <CompileInclude="Unit\Core\ReflectionExtensions.cs" />
  <CompileInclude="Unit\ParserResultExtensionsTests.cs" />

tests/CommandLine.Tests/Unit/Core/TypeConverterTests.cs

@@ -0,0 +1,111 @@
+usingSystem;
+usingSystem.CodeDom;
+usingSystem.Collections.Generic;
+usingSystem.Dynamic;
+usingSystem.Globalization;
+usingSystem.Linq;
+usingSystem.Text;
+usingSystem.Threading.Tasks;
+usingCommandLine.Core;
+usingCSharpx;
+usingFluentAssertions;
+usingXunit;
+
+namespaceCommandLine.Tests.Unit.Core
+{
+publicclassTypeConverterTests
+{
+enumTestEnum
+{
+ValueA=1,
+ValueB=2
+}
+
+[Theory]
+[MemberData("ChangeType_scalars_source")]
+publicvoidChangeType_scalars(stringtestValue,TypedestinationType,boolexpectFail,objectexpectedResult)
+{
+Maybe<object>result=TypeConverter.ChangeType(new[]{testValue},destinationType,true,CultureInfo.InvariantCulture,true);
+
+if(expectFail)
+{
+result.MatchNothing().Should().BeTrue("should fail parsing");
+}
+else
+{
+objectmatchedValue;
+
+result.MatchJust(outmatchedValue).Should().BeTrue("should parse successfully");
+Assert.Equal(matchedValue,expectedResult);
+}
+}
+
+publicstaticIEnumerable<object[]>ChangeType_scalars_source
+{
+get
+{
+returnnew[]
+{
+newobject[]{"1",typeof(int),false,1},
+newobject[]{"0",typeof(int),false,0},
+newobject[]{"-1",typeof(int),false,-1},
+newobject[]{"abcd",typeof(int),true,null},
+newobject[]{"1.0",typeof(int),true,null},
+newobject[]{int.MaxValue.ToString(),typeof(int),false,int.MaxValue},
+newobject[]{int.MinValue.ToString(),typeof(int),false,int.MinValue},
+newobject[]{((long)int.MaxValue+1).ToString(),typeof(int),true,null},
+newobject[]{((long)int.MinValue-1).ToString(),typeof(int),true,null},
+
+newobject[]{"1",typeof(uint),false,(uint)1},
+newobject[]{"0",typeof(uint),false,(uint)0},
+newobject[]{"-1",typeof(uint),true,null},
+newobject[]{uint.MaxValue.ToString(),typeof(uint),false,uint.MaxValue},
+newobject[]{uint.MinValue.ToString(),typeof(uint),false,uint.MinValue},
+newobject[]{((long)uint.MaxValue+1).ToString(),typeof(uint),true,null},
+newobject[]{((long)uint.MinValue-1).ToString(),typeof(uint),true,null},
+
+newobject[]{"true",typeof(bool),false,true},
+newobject[]{"True",typeof(bool),false,true},
+newobject[]{"TRUE",typeof(bool),false,true},
+newobject[]{"false",typeof(bool),false,false},
+newobject[]{"False",typeof(bool),false,false},
+newobject[]{"FALSE",typeof(bool),false,false},
+newobject[]{"abcd",typeof(bool),true,null},
+newobject[]{"0",typeof(bool),true,null},
+newobject[]{"1",typeof(bool),true,null},
+
+newobject[]{"1.0",typeof(float),false,1.0f},
+newobject[]{"0.0",typeof(float),false,0.0f},
+newobject[]{"-1.0",typeof(float),false,-1.0f},
+newobject[]{"abcd",typeof(float),true,null},
+
+newobject[]{"1.0",typeof(double),false,1.0},
+newobject[]{"0.0",typeof(double),false,0.0},
+newobject[]{"-1.0",typeof(double),false,-1.0},
+newobject[]{"abcd",typeof(double),true,null},
+
+newobject[]{"1.0",typeof(decimal),false,1.0m},
+newobject[]{"0.0",typeof(decimal),false,0.0m},
+newobject[]{"-1.0",typeof(decimal),false,-1.0m},
+newobject[]{"-1.123456",typeof(decimal),false,-1.123456m},
+newobject[]{"abcd",typeof(decimal),true,null},
+
+newobject[]{"",typeof(string),false,""},
+newobject[]{"abcd",typeof(string),false,"abcd"},
+
+newobject[]{"ValueA",typeof(TestEnum),false,TestEnum.ValueA},
+newobject[]{"VALUEA",typeof(TestEnum),false,TestEnum.ValueA},
+newobject[]{"ValueB",typeof(TestEnum),false,TestEnum.ValueB},
+newobject[]{((int)TestEnum.ValueA).ToString(),typeof(TestEnum),false,TestEnum.ValueA},
+newobject[]{((int)TestEnum.ValueB).ToString(),typeof(TestEnum),false,TestEnum.ValueB},
+newobject[]{((int)TestEnum.ValueB+1).ToString(),typeof(TestEnum),true,null},
+newobject[]{((int)TestEnum.ValueA-1).ToString(),typeof(TestEnum),true,null},
+
+// Failed before #339
+newobject[]{"false",typeof(int),true,0},
+newobject[]{"true",typeof(int),true,0}
+};
+}
+}
+}
+}