Add negative tests for CommandOptionInputConverter

CliFx.Tests/CommandOptionInputConverterTests.Types.cs

@@ -46,4 +46,18 @@ namespace CliFx.Tests
                 new TestStringParseableWithFormatProvider(value + " " + formatProvider);
         }
     }
+
+    // Negative
+    public partial class CommandOptionInputConverterTests
+    {
+        private class NonStringParseable
+        {
+            public int Value { get; }
+
+            public NonStringParseable(int value)
+            {
+                Value = value;
+            }
+        }
+    }
 }

CliFx.Tests/CommandOptionInputConverterTests.cs

@@ -2,6 +2,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Globalization;
+using CliFx.Exceptions;
 using CliFx.Models;
 using CliFx.Services;
 using FluentAssertions;
@@ -261,19 +262,44 @@ namespace CliFx.Tests
             );
         }
 
+        private static IEnumerable<TestCaseData> GetTestCases_ConvertOptionInput_Negative()
+        {
+            yield return new TestCaseData(
+                new CommandOptionInput("option", "1234.5"),
+                typeof(int)
+            );
+
+            yield return new TestCaseData(
+                new CommandOptionInput("option", "123"),
+                typeof(NonStringParseable)
+            );
+        }
+
         [Test]
         [TestCaseSource(nameof(GetTestCases_ConvertOptionInput))]
         public void ConvertOptionInput_Test(CommandOptionInput optionInput, Type targetType, object expectedConvertedValue)
         {
             // Arrange
-            var converter = new CommandOptionInputConverter();
+            var commandOptionInputConverter = new CommandOptionInputConverter();
 
             // Act
-            var convertedValue = converter.ConvertOptionInput(optionInput, targetType);
+            var convertedValue = commandOptionInputConverter.ConvertOptionInput(optionInput, targetType);
 
             // Assert
             convertedValue.Should().BeEquivalentTo(expectedConvertedValue);
             convertedValue?.Should().BeAssignableTo(targetType);
         }
+
+        [Test]
+        [TestCaseSource(nameof(GetTestCases_ConvertOptionInput_Negative))]
+        public void ConvertOptionInput_Negative_Test(CommandOptionInput optionInput, Type targetType)
+        {
+            // Arrange
+            var commandOptionInputConverter = new CommandOptionInputConverter();
+
+            // Act & Assert
+            commandOptionInputConverter.Invoking(c => c.ConvertOptionInput(optionInput, targetType)).Should()
+                .ThrowExactly<InvalidCommandOptionInputException>();
+        }
     }
 }

CliFx.Tests/CommandSchemaResolverTests.Commands.cs

@@ -10,8 +10,6 @@ namespace CliFx.Tests
         [Command("cmd", Description = "NormalCommand1 description.")]
         private class NormalCommand1 : ICommand
         {
-            public string NotAnOption { get; set; }
-
             [CommandOption("option-a", 'a')]
             public int OptionA { get; set; }
 
@@ -30,10 +28,13 @@ namespace CliFx.Tests
             [CommandOption("option-d", 'd')]
             public DateTimeOffset OptionD { get; set; }
 
+            public string NotAnOption { get; set; }
+
             public Task ExecuteAsync(IConsole console) => Task.CompletedTask;
         }
     }
 
+    // Negative
     public partial class CommandSchemaResolverTests
     {
         [Command("conflict")]

CliFx.Tests/CommandSchemaResolverTests.cs

@@ -87,7 +87,8 @@ namespace CliFx.Tests
             var commandSchemaResolver = new CommandSchemaResolver();
 
             // Act & Assert
-            commandSchemaResolver.Invoking(r => r.GetCommandSchemas(commandTypes)).Should().ThrowExactly<InvalidCommandSchemaException>();
+            commandSchemaResolver.Invoking(r => r.GetCommandSchemas(commandTypes)).Should()
+                .ThrowExactly<InvalidCommandSchemaException>();
         }
     }
 }