Added command line parsing unit tests

Author: jaredpar

src/CodeFormatter/CommandLineParser.cs

@@ -3,6 +3,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -62,6 +63,56 @@ public CommandLineOptions(
         }
     }
 
+    public sealed class CommandLineParseResult
+    {
+        private readonly CommandLineOptions _options;
+        private readonly string _error;
+
+        public bool IsSuccess
+        {
+            get { return _options != null; }
+        }
+
+        public bool IsError
+        {
+            get { return !IsSuccess; }
+        }
+
+        public CommandLineOptions Options
+        {
+            get
+            {
+                Debug.Assert(IsSuccess);
+                return _options;
+            }
+        }
+
+        public string Error
+        {
+            get
+            {
+                Debug.Assert(IsError);
+                return _error;
+            }
+        }
+
+        private CommandLineParseResult(CommandLineOptions options = null, string error = null)
+        {
+            _options = options;
+            _error = error;
+        }
+
+        public static CommandLineParseResult CreateSuccess(CommandLineOptions options)
+        {
+            return new CommandLineParseResult(options: options);
+        }
+
+        public static CommandLineParseResult CreateError(string error)
+        {
+            return new CommandLineParseResult(error: error);
+        }
+    }
+
     public static class CommandLineParser
     {
         private const string FileSwitch = "/file:";
@@ -71,10 +122,7 @@ public static class CommandLineParser
         private const string RuleEnabledSwitch1 = "/rule+:";
         private const string RuleEnabledSwitch2 = "/rule:";
         private const string RuleDisabledSwitch = "/rule-:";
-
-        public static void PrintUsage()
-        {
-            Console.WriteLine(
+        private const string Usage = 
 @"CodeFormatter [/file:<filename>] [/lang:<language>] [/c:<config>[,<config>...]>]
     [/copyright:<file> | /nocopyright] [/tables] [/nounicode] 
     [/rule(+|-):rule1,rule2,...]  [/verbose]
@@ -94,19 +142,24 @@ Use ConvertTests to convert MSTest tests to xUnit.
     /rule(+|-)   - Enable (default) or disable the specified rule
     /rules       - List the available rules
     /verbose     - Verbose output
-");
+";
+
+        public static void PrintUsage()
+        {
+            Console.WriteLine(Usage);
         }
 
         public static bool TryParse(string[] args, out CommandLineOptions options)
         {
-            if (args.Length < 1)
-            {
-                PrintUsage();
-                options = null;
-                return false;
-            }
+            var result = Parse(args);
+            options = result.IsSuccess ? result.Options : null;
+            return result.IsSuccess;
+        }
 
+        public static CommandLineParseResult Parse(string[] args)
+        {
             var comparer = StringComparer.OrdinalIgnoreCase;
+            var comparison = StringComparison.OrdinalIgnoreCase;
             var formatTargets = new List<string>();
             var fileNames = new List<string>();
             var configBuilder = ImmutableArray.CreateBuilder<string[]>();
@@ -116,7 +169,7 @@ public static bool TryParse(string[] args, out CommandLineOptions options)
             var allowTables = false;
             var verbose = false;
 
-            for (int i = 1; i < args.Length; i++)
+            for (int i = 0; i < args.Length; i++)
             {
                 string arg = args[i];
                 if (arg.StartsWith(ConfigSwitch, StringComparison.OrdinalIgnoreCase))
@@ -134,10 +187,11 @@ public static bool TryParse(string[] args, out CommandLineOptions options)
                     }
                     catch (Exception ex)
                     {
-                        Console.Error.WriteLine("Could not read {0}", fileName);
-                        Console.Error.WriteLine(ex.Message);
-                        options = null;
-                        return false;
+                        string error = string.Format("Could not read {0}{1}{2}",
+                           fileName,
+                           Environment.NewLine,
+                           ex.Message);
+                        return CommandLineParseResult.CreateError(error);
                     }
                 }
                 else if (arg.StartsWith(LanguageSwitch, StringComparison.OrdinalIgnoreCase))
@@ -156,19 +210,19 @@ public static bool TryParse(string[] args, out CommandLineOptions options)
                 {
                     verbose = true;
                 }
-                else if (comparer.Equals(arg, FileSwitch))
+                else if (arg.StartsWith(FileSwitch, comparison))
                 {
                     fileNames.Add(arg.Substring(FileSwitch.Length));
                 }
-                else if (comparer.Equals(arg, RuleEnabledSwitch1))
+                else if (arg.StartsWith(RuleEnabledSwitch1, comparison))
                 {
                     UpdateRuleMap(ref ruleMap, arg.Substring(RuleEnabledSwitch1.Length), enabled: true);
                 }
-                else if (comparer.Equals(arg, RuleEnabledSwitch2))
+                else if (arg.StartsWith(RuleEnabledSwitch2, comparison))
                 {
                     UpdateRuleMap(ref ruleMap, arg.Substring(RuleEnabledSwitch2.Length), enabled: true);
                 }
-                else if (comparer.Equals(arg, RuleDisabledSwitch))
+                else if (arg.StartsWith(RuleDisabledSwitch, comparison))
                 {
                     UpdateRuleMap(ref ruleMap, arg.Substring(RuleDisabledSwitch.Length), enabled: false);
                 }
@@ -178,16 +232,20 @@ public static bool TryParse(string[] args, out CommandLineOptions options)
                 }
                 else if (comparer.Equals(arg, "/rules"))
                 {
-                    options = CommandLineOptions.ListRules;
-                    return true;
+                    return CommandLineParseResult.CreateSuccess(CommandLineOptions.ListRules);
                 }
                 else
                 {
                     formatTargets.Add(arg);
                 }
             }
 
-            options = new CommandLineOptions(
+            if (formatTargets.Count == 0)
+            {
+                return CommandLineParseResult.CreateError("Must specify at least one project / solution / rsp to format");
+            }
+
+            var options = new CommandLineOptions(
                 Operation.Format,
                 configBuilder.ToImmutableArray(),
                 copyrightHeader,
@@ -197,7 +255,7 @@ public static bool TryParse(string[] args, out CommandLineOptions options)
                 language,
                 allowTables,
                 verbose);
-            return true;
+            return CommandLineParseResult.CreateSuccess(options);
         }
 
         private static void UpdateRuleMap(ref ImmutableDictionary<string, bool> ruleMap, string data, bool enabled)

src/CodeFormatter/Program.cs

@@ -18,12 +18,15 @@ internal static class Program
     {
         private static int Main(string[] args)
         {
-            CommandLineOptions options;
-            if (!CommandLineParser.TryParse(args, out options))
+            var result = CommandLineParser.Parse(args);
+            if (result.IsError)
             {
+                Console.Error.WriteLine(result.Error);
+                CommandLineParser.PrintUsage();
                 return -1;
             }
 
+            var options = result.Options;
             int exitCode;
             switch (options.Operation)
             {

src/Microsoft.DotNet.CodeFormatting.Tests/CommandLineParserTests.cs

@@ -0,0 +1,94 @@
+using CodeFormatter;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Microsoft.DotNet.CodeFormatting.Tests
+{
+    public class CommandLineParserTests
+    {
+        private CommandLineOptions Parse(params string[] args)
+        {
+            CommandLineOptions options;
+            Assert.True(CommandLineParser.TryParse(args, out options));
+            return options;
+        }
+
+        [Fact]
+        public void Rules()
+        {
+            var options = Parse("/rules");
+            Assert.Equal(Operation.ListRules, options.Operation);
+        }
+
+        [Fact]
+        public void Rules1()
+        {
+            var options = Parse("/rule:r1", "test.csproj");
+            Assert.True(options.RuleMap["r1"]);
+            Assert.Equal(new[] { "test.csproj" }, options.FormatTargets);
+        }
+
+        [Fact]
+        public void Rules2()
+        {
+            var options = Parse("/rule+:r1", "test.csproj");
+            Assert.True(options.RuleMap["r1"]);
+            Assert.Equal(new[] { "test.csproj" }, options.FormatTargets);
+        }
+
+        [Fact]
+        public void Rules3()
+        {
+            var options = Parse("/rule-:r1", "test.csproj");
+            Assert.False(options.RuleMap["r1"]);
+            Assert.Equal(new[] { "test.csproj" }, options.FormatTargets);
+        }
+
+        [Fact]
+        public void Rules4()
+        {
+            var options = Parse("/rule:r1,r2,r3", "test.csproj");
+            Assert.True(options.RuleMap["r1"]);
+            Assert.True(options.RuleMap["r2"]);
+            Assert.True(options.RuleMap["r3"]);
+            Assert.Equal(new[] { "test.csproj" }, options.FormatTargets);
+        }
+
+        [Fact]
+        public void Rules5()
+        {
+            var options = Parse("/rule-:r1,r2,r3", "test.csproj");
+            Assert.False(options.RuleMap["r1"]);
+            Assert.False(options.RuleMap["r2"]);
+            Assert.False(options.RuleMap["r3"]);
+            Assert.Equal(new[] { "test.csproj" }, options.FormatTargets);
+        }
+
+        [Fact]
+        public void NeedAtLeastOneTarget()
+        {
+            CommandLineOptions options;
+            Assert.False(CommandLineParser.TryParse(new[] { "/rule:foo" }, out options));
+        }
+
+        [Fact]
+        public void NoUnicode()
+        {
+            var options = Parse("/nounicode", "test.csproj");
+            Assert.False(options.RuleMap[FormattingDefaults.UnicodeLiteralsRuleName]);
+            Assert.Equal(new[] { "test.csproj" }, options.FormatTargets);
+        }
+
+        [Fact]
+        public void NoCopyright()
+        {
+            var options = Parse("/nocopyright", "test.csproj");
+            Assert.False(options.RuleMap[FormattingDefaults.CopyrightRuleName]);
+            Assert.Equal(new[] { "test.csproj" }, options.FormatTargets);
+        }
+    }
+}

src/Microsoft.DotNet.CodeFormatting.Tests/Microsoft.DotNet.CodeFormatting.Tests.csproj

@@ -105,6 +105,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="CodeFormattingTestBase.cs" />
+    <Compile Include="CommandLineParserTests.cs" />
     <Compile Include="Rules\BracesRuleTests.cs" />
     <Compile Include="Rules\CombinationTest.cs" />
     <Compile Include="Rules\CopyrightHeaderRuleTests.cs" />
@@ -130,6 +131,10 @@
     </None>
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\CodeFormatter\CodeFormatter.csproj">
+      <Project>{b0e1a988-f762-459d-ad0d-56a3cf4fff3f}</Project>
+      <Name>CodeFormatter</Name>
+    </ProjectReference>
     <ProjectReference Include="..\Microsoft.DotNet.CodeFormatting\Microsoft.DotNet.CodeFormatting.csproj">
       <Project>{d535641f-a2d7-481c-930d-96c02f052b95}</Project>
       <Name>Microsoft.DotNet.CodeFormatting</Name>