Update version 1.0.8. (#16)

* Update version 1.0.8.
* Refactor test framework.

Author: maroontress-tomohisa

README.md

@@ -20,6 +20,7 @@ It is supposed to be used with StyleCop Analyzers.
 - Remove unnecessary using directives.
 - Use `T` as a type parameter name if the type parameter is single.
 - Move type parameters from the static class to its methods if possible.
+- Avoid thoughtless names for the identifer of local variables.
 
 ## Configuration
 

StyleChecker/StyleChecker.Test/Cleaning/UnusedUsing/AnalyzerTest.cs

@@ -6,20 +6,20 @@ namespace StyleChecker.Test.Cleaning.UnusedUsing
     using Microsoft.CodeAnalysis.Diagnostics;
     using Microsoft.VisualStudio.TestTools.UnitTesting;
     using StyleChecker.Cleaning.UnusedUsing;
-    using TestHelper;
+    using StyleChecker.Test.Framework;
 
     [TestClass]
-    public sealed class AnalyzerTest : CodeFixVerifier
+    public sealed class AnalyzerTest : DiagnosticVerifier
     {
-        protected override DiagnosticAnalyzer CSharpDiagnosticAnalyzer
+        protected override DiagnosticAnalyzer DiagnosticAnalyzer
             => new Analyzer();
 
         protected override string BaseDir
             => Path.Combine("Cleaning", "UnusedUsing");
 
         [TestMethod]
         public void Empty()
-            => VerifyCSharpDiagnostic(@"", Environment.Default);
+            => VerifyDiagnostic(@"", Environment.Default);
 
         [TestMethod]
         public void Code()
@@ -35,7 +35,7 @@ DiagnosticResult Expected(int row, int col)
                 Locations = SingleLocation(startOffset + row, col),
             };
             var ignoreIds = ImmutableArray.Create("CS8019");
-            VerifyCSharpDiagnostic(
+            VerifyDiagnostic(
                 code,
                 Environment.Default.WithExcludeIds(ignoreIds),
                 Expected(0, 5));

StyleChecker/StyleChecker.Test/Framework/Arrays.cs

@@ -0,0 +1,25 @@
+namespace StyleChecker.Test.Framework
+{
+    /// <summary>
+    /// Provides the utility methods for arrays.
+    /// </summary>
+    public static class Arrays
+    {
+        /// <summary>
+        /// Returns a new array containing only the specified object.
+        /// </summary>
+        /// <typeparam name="T">
+        /// The type of the element.
+        /// </typeparam>
+        /// <param name="element">
+        /// An element that the array contains.
+        /// </param>
+        /// <returns>
+        /// A new array containing only the specified object.
+        /// </returns>
+        public static T[] Singleton<T>(T element)
+        {
+            return new T[] { element };
+        }
+    }
+}

…/StyleChecker.Test/Helpers/CodeChange.cs …tyleChecker.Test/Framework/CodeChange.csStyleChecker/StyleChecker.Test/Helpers/CodeChange.cs renamed to StyleChecker/StyleChecker.Test/Framework/CodeChange.cs StyleChecker/StyleChecker.Test/Helpers/CodeChange.cs renamed to StyleChecker/StyleChecker.Test/Framework/CodeChange.cs

@@ -1,4 +1,4 @@
-namespace TestHelper
+namespace StyleChecker.Test.Framework
 {
     /// <summary>
     /// Represents two codes.

…hecker.Test/Verifiers/CodeFixVerifier.cs …hecker.Test/Framework/CodeFixVerifier.csStyleChecker/StyleChecker.Test/Verifiers/CodeFixVerifier.cs renamed to StyleChecker/StyleChecker.Test/Framework/CodeFixVerifier.cs StyleChecker/StyleChecker.Test/Verifiers/CodeFixVerifier.cs renamed to StyleChecker/StyleChecker.Test/Framework/CodeFixVerifier.cs

@@ -1,17 +1,18 @@
-namespace TestHelper
+namespace StyleChecker.Test.Framework
 {
     using System.Collections.Generic;
     using System.Linq;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CodeFixes;
     using Microsoft.CodeAnalysis.Formatting;
+    using Microsoft.CodeAnalysis.Simplification;
     using Microsoft.VisualStudio.TestTools.UnitTesting;
 
     /// <summary>
     /// Superclass of all Unit tests made for diagnostics with CodeFixes.
     /// Contains methods used to verify correctness of CodeFixes.
     /// </summary>
-    public abstract partial class CodeFixVerifier : DiagnosticVerifier
+    public abstract class CodeFixVerifier : DiagnosticVerifier
     {
         /// <summary>
         /// Gets the CodeFix being tested (C#) - to be implemented in
@@ -20,24 +21,7 @@ public abstract partial class CodeFixVerifier : DiagnosticVerifier
         /// <returns>
         /// The CodeFixProvider to be used for CSharp code.
         /// </returns>
-        protected virtual CodeFixProvider CSharpCodeFixProvider => null;
-
-        /// <summary>
-        /// Returns a new array of <c>DiagnosticResultLocation</c> containing
-        /// the single element representing the specified line and column.
-        /// </summary>
-        /// <param name="line">The line.</param>
-        /// <param name="column">The column.</param>
-        /// <returns>
-        /// A new array of <c>DiagnosticResultLocation</c> containing
-        /// the single element representing the specified line and column.
-        /// </returns>
-        protected static DiagnosticResultLocation[] SingleLocation(
-            int line, int column)
-        {
-            return Singleton(
-                new DiagnosticResultLocation("Test0.cs", line, column));
-        }
+        protected abstract CodeFixProvider CodeFixProvider { get; }
 
         /// <summary>
         /// Creates a new <c>CodeChange</c> from entire texts representing for
@@ -72,62 +56,64 @@ protected CodeChange ReadCodeChange(string name)
         /// it.
         /// </param>
         /// <param name="allowNewCompilerDiagnostics">
-        /// A bool controlling whether or not the test will fail if the CodeFix
-        /// introduces other warnings after being applied.
+        /// A <c>bool</c> controlling whether or not the test will fail if the
+        /// CodeFix introduces other warnings after being applied.
         /// </param>
-        protected void VerifyCSharpFix(
+        protected void VerifyFix(
             string oldSource,
             string newSource,
             bool allowNewCompilerDiagnostics = false)
         {
-            var codeChanges = Singleton(new CodeChange(oldSource, newSource));
+            var codeChanges = Arrays.Singleton(
+                new CodeChange(oldSource, newSource));
             VerifyFix(codeChanges, allowNewCompilerDiagnostics);
         }
 
         /// <summary>
-        /// Verifies the result of <c>CodeFix</c>es. Creates a <c>Document</c>s
+        /// Verifies the result of CodeFixes. Creates a <c>Document</c>s
         /// from the <c>CodeChange</c>s, then gets diagnostics on it and
-        /// applies the relevant <c>CodeFix</c>es. Then gets the string after
-        /// the <c>CodeFix</c> is applied and compares it with the expected
-        /// result. Note: If any <c>CodeFix</c> causes new diagnostics to show
+        /// applies the relevant CodeFixes. Then gets the string after
+        /// the CodeFix is applied and compares it with the expected
+        /// result. Note: If any CodeFix causes new diagnostics to show
         /// up, the test fails unless
         /// <paramref name="allowNewCompilerDiagnostics"/> is set to true.
         /// </summary>
         /// <param name="codeChanges">
-        /// The sources in the form of a string before/after the <c>CodeFix</c>
+        /// The sources in the form of a string before/after the CodeFix
         /// was applied to it.
         /// </param>
         /// <param name="allowNewCompilerDiagnostics">
-        /// A bool controlling whether or not the test will fail if the
-        /// <c>CodeFix</c> introduces other warnings after being applied.
+        /// A <c>bool</c> controlling whether or not the test will fail if the
+        /// CodeFix introduces other warnings after being applied.
         /// </param>
         protected void VerifyFix(
             IEnumerable<CodeChange> codeChanges,
             bool allowNewCompilerDiagnostics = false)
         {
-            var analyzer = CSharpDiagnosticAnalyzer;
-            var codeFixProvider = CSharpCodeFixProvider;
-            var verifier = new Verifier(analyzer, codeFixProvider);
+            var analyzer = DiagnosticAnalyzer;
+            var codeFixProvider = CodeFixProvider;
+            var applier = new FixApplier(analyzer, codeFixProvider);
 
             var codeChangeArray = codeChanges.ToArray();
             var expectedMap = new Dictionary<DocumentId, string>();
-            var project = CreateProject(
+            var project = Projects.Of(
                 codeChanges,
                 (id, c) => expectedMap[id] = c.After);
             var documents = project.Documents.ToArray();
-            var firstVerifyContext = verifier.AnalyzeDocuments(documents);
-            var maxTryCount = firstVerifyContext.AnalyzerDiagnostics.Length;
+            var firstApplierContext = applier.Analyze(documents);
+            var maxTryCount = firstApplierContext.AnalyzerDiagnostics.Length;
             Assert.IsTrue(maxTryCount > 0);
 
-            var verifyContext = firstVerifyContext;
-            var newDocumentMap = verifier.ModifyDocuments(verifyContext);
+            var verifyContext = firstApplierContext;
+            var newDocumentMap = applier.Modify(verifyContext);
             for (var k = 0; k < maxTryCount; ++k)
             {
                 var newDocuments = newDocumentMap.Values.ToArray();
-                var newVerifyContext = verifier.AnalyzeDocuments(newDocuments);
-                var newCompilerDiagnostics = newVerifyContext.CompilerDiagnostics;
-                var diagnosticsDelta = GetNewDiagnostics(
-                    firstVerifyContext.CompilerDiagnostics,
+                var newApplierContext = applier.Analyze(newDocuments);
+                var newCompilerDiagnostics
+                    = newApplierContext.CompilerDiagnostics;
+                var diagnosticsDelta = Diagnostics.GetNewDelta(
+                    firstApplierContext.CompilerDiagnostics,
                     newCompilerDiagnostics);
 
                 // Checks if applying the code fix introduced any new compiler
@@ -138,44 +124,45 @@ protected void VerifyFix(
                         newDocuments, newCompilerDiagnostics);
                 }
 
-                verifyContext = newVerifyContext;
+                verifyContext = newApplierContext;
                 if (!verifyContext.AnalyzerDiagnostics.Any())
                 {
                     break;
                 }
-                newDocumentMap = verifier.ModifyDocuments(verifyContext);
+                newDocumentMap = applier.Modify(verifyContext);
             }
             Assert.IsTrue(!verifyContext.AnalyzerDiagnostics.Any());
 
             foreach (var id in project.DocumentIds)
             {
-                var actual = GetStringFromDocument(newDocumentMap[id]);
+                var actual = ToString(newDocumentMap[id]);
                 var expected = expectedMap[id];
                 Compare(id, actual, expected);
             }
         }
 
-        private void FailFixIntroducedNewCompilerDiagnostics(
-            Document[] newDocuments, Diagnostic[] compilerDiagnostics)
+        private static void FailFixIntroducedNewCompilerDiagnostics(
+            IEnumerable<Document> newDocuments,
+            IEnumerable<Diagnostic> compilerDiagnostics)
         {
             // Format and get the compiler diagnostics again so that
             // the locations make sense in the output.
-            var formatteDocuments = newDocuments
+            var formattedDocuments = newDocuments
                 .Select(d => d.WithSyntaxRoot(Formatter.Format(
                     d.GetSyntaxRootAsync().Result,
                     Formatter.Annotation,
                     d.Project.Solution.Workspace)))
                 .ToArray();
-            var newCompilerDiagnostics = formatteDocuments
-                .SelectMany(d => Verifier.GetCompilerDiagnostics(d))
+            var newCompilerDiagnostics = formattedDocuments
+                .SelectMany(d => Documents.GetCompilerDiagnostics(d))
                 .ToArray();
-            var diagnosticsDelta = GetNewDiagnostics(
+            var diagnosticsDelta = Diagnostics.GetNewDelta(
                 compilerDiagnostics, newCompilerDiagnostics);
 
             var diagnosticMessages = string.Join(
                 "\r\n",
                 diagnosticsDelta.Select(d => d.ToString()));
-            var soucres = formatteDocuments
+            var soucres = formattedDocuments
                 .Select(d => d.GetSyntaxRootAsync().Result.ToFullString());
             Assert.Fail(
                 "Fix introduced new compiler diagnostics:\r\n"
@@ -192,13 +179,14 @@ private void FailFixIntroducedNewCompilerDiagnostics(
         /// The <c>DocumentId</c> of the source to compare.
         /// </param>
         /// <param name="actual">
-        /// The actual source that the <c>CodeFix</c> provider provides.
+        /// The actual source that the CodeFix provider provides.
         /// </param>
         /// <param name="expected">
-        /// The expected source that the <c>CodeFix</c> provider is supposed to
+        /// The expected source that the CodeFix provider is supposed to
         /// provide.
         /// </param>
-        private void Compare(DocumentId id, string actual, string expected)
+        private static void Compare(
+            DocumentId id, string actual, string expected)
         {
             var actualArray = actual.Split("\r\n");
             var expectedArray = expected.Split("\r\n");
@@ -215,5 +203,27 @@ private void Compare(DocumentId id, string actual, string expected)
             }
             Assert.AreEqual(expected, actual);
         }
+
+        /// <summary>
+        /// Returns the string representing the specified document
+        /// based on the syntax root.
+        /// </summary>
+        /// <param name="document">
+        /// The <c>>Document</c> to be converted to a string.
+        /// </param>
+        /// <returns>
+        /// A string containing the syntax of the Document after formatting.
+        /// </returns>
+        private static string ToString(Document document)
+        {
+            var simplifiedDoc = Simplifier.ReduceAsync(
+                document, Simplifier.Annotation).Result;
+            var root = simplifiedDoc.GetSyntaxRootAsync().Result;
+            root = Formatter.Format(
+                root,
+                Formatter.Annotation,
+                simplifiedDoc.Project.Solution.Workspace);
+            return root.GetText().ToString();
+        }
     }
 }

…ker.Test/Helpers/CompilationException.cs …r.Test/Framework/CompilationException.csStyleChecker/StyleChecker.Test/Helpers/CompilationException.cs renamed to StyleChecker/StyleChecker.Test/Framework/CompilationException.cs StyleChecker/StyleChecker.Test/Helpers/CompilationException.cs renamed to StyleChecker/StyleChecker.Test/Framework/CompilationException.cs

@@ -1,4 +1,4 @@
-namespace TestHelper
+namespace StyleChecker.Test.Framework
 {
     using System;
     using System.Collections.Immutable;

…/StyleChecker.Test/Helpers/ConfigText.cs …tyleChecker.Test/Framework/ConfigText.csStyleChecker/StyleChecker.Test/Helpers/ConfigText.cs renamed to StyleChecker/StyleChecker.Test/Framework/ConfigText.cs StyleChecker/StyleChecker.Test/Helpers/ConfigText.cs renamed to StyleChecker/StyleChecker.Test/Framework/ConfigText.cs

@@ -1,4 +1,4 @@
-namespace TestHelper
+namespace StyleChecker.Test.Framework
 {
     using System.Collections.Immutable;
     using System.Threading;

…Checker.Test/Helpers/DiagnosticResult.cs …ecker.Test/Framework/DiagnosticResult.csStyleChecker/StyleChecker.Test/Helpers/DiagnosticResult.cs renamed to StyleChecker/StyleChecker.Test/Framework/DiagnosticResult.cs StyleChecker/StyleChecker.Test/Helpers/DiagnosticResult.cs renamed to StyleChecker/StyleChecker.Test/Framework/DiagnosticResult.cs

@@ -1,4 +1,4 @@
-namespace TestHelper
+namespace StyleChecker.Test.Framework
 {
     using System;
     using Microsoft.CodeAnalysis;

…Test/Helpers/DiagnosticResultLocation.cs …st/Framework/DiagnosticResultLocation.csStyleChecker/StyleChecker.Test/Helpers/DiagnosticResultLocation.cs renamed to StyleChecker/StyleChecker.Test/Framework/DiagnosticResultLocation.cs StyleChecker/StyleChecker.Test/Helpers/DiagnosticResultLocation.cs renamed to StyleChecker/StyleChecker.Test/Framework/DiagnosticResultLocation.cs

@@ -1,4 +1,4 @@
-namespace TestHelper
+namespace StyleChecker.Test.Framework
 {
     using System;