Some improvements

Add tests for UsesXunitForTestsFormattingRule.
Add command line option to specify which source files to process.

Author: dsplaisted

src/CodeFormatter/Program.cs

@@ -2,11 +2,11 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
-using System.ComponentModel.Composition.Hosting;
+using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-
 using Microsoft.CodeAnalysis.MSBuild;
 using Microsoft.DotNet.CodeFormatting;
 
@@ -16,9 +16,9 @@ internal static class Program
     {
         private static int Main(string[] args)
         {
-            if (args.Length != 1)
+            if (args.Length < 1)
             {
-                Console.Error.WriteLine("CodeFormatter <solution>");
+                Console.Error.WriteLine("CodeFormatter <solution> [<rule types>] [/file <filename>]");
                 return -1;
             }
 
@@ -29,22 +29,44 @@ private static int Main(string[] args)
                 return -1;
             }
 
+            List<string> ruleTypes = new List<string>();
+            List<string> filenames = new List<string>();
+
+            for (int i=1; i<args.Length; i++)
+            {
+                string arg = args[i];
+                if (arg.Equals("/file", StringComparison.InvariantCultureIgnoreCase))
+                {
+                    if (i + 1 < args.Length)
+                    {
+                        string param = args[i + 1];
+                        filenames.Add(param);
+                        i++;
+                    }
+                }
+                else
+                {
+                    ruleTypes.Add(arg);
+                }
+            }
+
+
             var cts = new CancellationTokenSource();
             var ct = cts.Token;
 
             Console.CancelKeyPress += delegate { cts.Cancel(); };
 
-            RunAsync(solutionPath, ct).Wait(ct);
+            RunAsync(solutionPath, ruleTypes, filenames, ct).Wait(ct);
             Console.WriteLine("Completed formatting.");
             return 0;
         }
 
-        private static async Task RunAsync(string solutionFilePath, CancellationToken cancellationToken)
+        private static async Task RunAsync(string solutionFilePath, IEnumerable<string> ruleTypes, IEnumerable<string> filenames, CancellationToken cancellationToken)
         {
             var workspace = MSBuildWorkspace.Create();
             await workspace.OpenSolutionAsync(solutionFilePath, cancellationToken);
 
-            var engine = FormattingEngine.Create();
+            var engine = FormattingEngine.Create(ruleTypes, filenames);
             await engine.RunAsync(workspace, cancellationToken);
         }
     }

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

@@ -32,17 +32,22 @@ internal static IFormattingRule GetDefaultVSFormatter()
             return new Rules.IsFormattedFormattingRule();
         }
 
-        private static Solution CreateSolution(string[] sources, string language = LanguageNames.CSharp)
+        protected virtual IEnumerable<MetadataReference> GetSolutionMetadataReferences()
+        {
+            yield return s_CorlibReference;
+            yield return s_SystemCoreReference;
+            yield return s_CodeFormatterReference;
+        }
+
+        private Solution CreateSolution(string[] sources, string language = LanguageNames.CSharp)
         {
             string fileExtension = language == LanguageNames.CSharp ? CSharpFileExtension : VBFileExtension;
             var projectId = ProjectId.CreateNewId(TestProjectName);
 
             var solution = new CustomWorkspace()
                 .CurrentSolution
                 .AddProject(projectId, TestProjectName, TestProjectName, language)
-                .AddMetadataReference(projectId, s_CorlibReference)
-                .AddMetadataReference(projectId, s_SystemCoreReference)
-                .AddMetadataReference(projectId, s_CodeFormatterReference);
+                .AddMetadataReferences(projectId, GetSolutionMetadataReferences());
 
             int count = 0;
             foreach (var source in sources)
@@ -94,7 +99,7 @@ private static void AssertSolutionEqual(Solution expectedSolution, Solution actu
             }
         }
 
-        private static void Verify(string[] sources, string[] expected, IFormattingRule rule, bool runFormatter)
+        private void Verify(string[] sources, string[] expected, IFormattingRule rule, bool runFormatter)
         {
             var inputSolution = CreateSolution(sources);
             var expectedSolution = CreateSolution(expected);

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

@@ -67,6 +67,7 @@
     <Reference Include="Microsoft.CodeAnalysis.Workspaces.Desktop">
       <HintPath>..\packages\Microsoft.CodeAnalysis.Workspaces.Common.1.0.0-beta1-20141031-01\lib\net45\Microsoft.CodeAnalysis.Workspaces.Desktop.dll</HintPath>
     </Reference>
+    <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
     <Reference Include="System" />
     <Reference Include="System.Collections.Immutable, Version=1.1.32.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
@@ -108,6 +109,7 @@
     <Compile Include="Rules\HasNoNewLineBeforeEndBraceFormattingRuleTests.cs" />
     <Compile Include="Rules\HasPrivateAccessorOnFieldNamesFormattingRuleTests.cs" />
     <Compile Include="Rules\HasUnderScoreInPrivateFieldNamesFormattingRuleTests.cs" />
+    <Compile Include="Rules\UsesXunitForTestsFormattingRuleTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <Folder Include="Properties\" />
@@ -124,6 +126,12 @@
   <ItemGroup>
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
+  <ItemGroup>
+    <Content Include="..\CodeFormatter\MSTestNamespaces.txt">
+      <Link>MSTestNamespaces.txt</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
     <PropertyGroup>

src/Microsoft.DotNet.CodeFormatting.Tests/Rules/UsesXunitForTestsFormattingRuleTests.cs

@@ -0,0 +1,207 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Xunit;
+
+namespace Microsoft.DotNet.CodeFormatting.Tests
+{
+    
+    public class UsesXunitForTestsFormattingRuleTests : CodeFormattingTestBase
+    {
+        [Fact]
+        public void TestUpdatesUsingStatements()
+        {
+            var text = @"
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace System.Composition.UnitTests
+{
+}
+";
+
+            var expected = @"
+using System;
+using Xunit;
+
+namespace System.Composition.UnitTests
+{
+}
+";
+            Verify(text, expected);
+        }
+
+        [Fact]
+        public void TestUpdatesUsingStatementsWithIfDefs()
+        {
+            var text = @"
+using System;
+#if NETFX_CORE
+using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
+#elif PORTABLE_TESTS
+using Microsoft.Bcl.Testing;
+#else
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+#endif
+namespace System.Composition.UnitTests
+{
+}
+";
+
+            var expected = @"
+using System;
+using Xunit;
+
+namespace System.Composition.UnitTests
+{
+}
+";
+            Verify(text, expected);
+        }
+
+        [Fact]
+        public void TestRemovesTestClassAttributes()
+        {
+            var text = @"
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace System.Composition.UnitTests
+{
+    [TestClass]
+    public class MyTestClass
+    {
+    }
+}
+";
+
+            var expected = @"
+using System;
+using Xunit;
+
+namespace System.Composition.UnitTests
+{
+    public class MyTestClass
+    {
+    }
+}
+";
+            Verify(text, expected);
+        }
+
+        [Fact]
+        public void TestUpdatesTestMethodAttributes()
+        {
+            var text = @"
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace System.Composition.UnitTests
+{
+    public class MyTestClass
+    {
+        [TestMethod]
+        public void MyTestMethod()
+        {
+        }
+    }
+}
+";
+
+            var expected = @"
+using System;
+using Xunit;
+
+namespace System.Composition.UnitTests
+{
+    public class MyTestClass
+    {
+        [Fact]
+        public void MyTestMethod()
+        {
+        }
+    }
+}
+";
+            Verify(text, expected);
+        }
+
+        [Fact]
+        public void TestUpdatesAsserts()
+        {
+            var text = @"
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace System.Composition.UnitTests
+{
+    public class MyTestClass
+    {
+        public void MyTestMethod()
+        {
+            object obj = new object();
+
+            Assert.AreEqual(1, 1);
+            Assert.AreNotEqual(1, 2);
+            Assert.IsNull(null);
+            Assert.IsNotNull(obj);
+            Assert.AreSame(obj, obj);
+            Assert.AreNotSame(obj, new object());
+            Assert.IsTrue(true);
+            Assert.IsFalse(false);
+            Assert.IsInstanceOfType(string.Empty, typeof(String));
+        }
+    }
+}
+";
+
+            var expected = @"
+using System;
+using Xunit;
+
+namespace System.Composition.UnitTests
+{
+    public class MyTestClass
+    {
+        public void MyTestMethod()
+        {
+            object obj = new object();
+
+            Assert.Equal(1, 1);
+            Assert.NotEqual(1, 2);
+            Assert.Null(null);
+            Assert.NotNull(obj);
+            Assert.Same(obj, obj);
+            Assert.NotSame(obj, new object());
+            Assert.True(true);
+            Assert.False(false);
+            Assert.IsAssignableFrom(typeof(String), string.Empty);
+        }
+    }
+}
+";
+            Verify(text, expected);
+        }
+
+        private static readonly MetadataReference s_MSTestReference = MetadataReference.CreateFromAssembly(typeof(VisualStudio.TestTools.UnitTesting.TestMethodAttribute).Assembly);
+        private static readonly MetadataReference s_XunitReference = MetadataReference.CreateFromAssembly(typeof(FactAttribute).Assembly);
+
+        protected override IEnumerable<MetadataReference> GetSolutionMetadataReferences()
+        {
+            return base.GetSolutionMetadataReferences()
+                .Concat(new[] {
+                    s_MSTestReference,
+                    s_XunitReference
+                });
+        }
+
+        internal override IFormattingRule GetFormattingRule()
+        {
+            return new Rules.UsesXunitForTestsFormattingRule();
+        }
+    }
+}

src/Microsoft.DotNet.CodeFormatting/Filters/FilenameFilter.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+
+namespace Microsoft.DotNet.CodeFormatting.Filters
+{
+    internal sealed class FilenameFilter : IFormattingFilter
+    {
+        IEnumerable<string> _filenames;
+
+        public FilenameFilter(IEnumerable<string> filenames)
+        {
+            _filenames = filenames;
+        }
+
+        public Task<bool> ShouldBeProcessedAsync(Document document)
+        {
+            if (!_filenames.Any())
+            {
+                return Task.FromResult(true);
+            }
+
+            string docFilename = Path.GetFileName(document.FilePath);
+
+            foreach (var filename in _filenames)
+            {
+                if (filename.Equals(docFilename, StringComparison.InvariantCultureIgnoreCase))
+                {
+                    return Task.FromResult(true);
+                }
+            }
+
+            return Task.FromResult(false);
+        }
+    }
+}