Merge pull request #41 from sharwell/test-coverage

Test coverage

Author: sharwell

AsyncUsageAnalyzers/AsyncUsageAnalyzers.CodeFixes/Helpers/RenameHelper.cs

@@ -21,7 +21,7 @@ public static async Task<Solution> RenameSymbolAsync(Document document, SyntaxNo
             var annotatedToken = annotatedRoot.FindToken(declarationToken.SpanStart);
 
             var semanticModel = await annotatedDocument.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-            var symbol = semanticModel?.GetDeclaredSymbol(annotatedToken.Parent, cancellationToken);
+            var symbol = semanticModel.GetDeclaredSymbol(annotatedToken.Parent, cancellationToken);
 
             var newSolution = await Renamer.RenameSymbolAsync(annotatedSolution, symbol, newName, null, cancellationToken).ConfigureAwait(false);
 

AsyncUsageAnalyzers/AsyncUsageAnalyzers.Test/AnalyzerConstantsUnitTests.cs

@@ -0,0 +1,38 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+namespace AsyncUsageAnalyzers.Test
+{
+    using Xunit;
+
+    public class AnalyzerConstantsUnitTests
+    {
+        [Fact]
+        public void TestEnabledByDefault()
+        {
+            Assert.True(AnalyzerConstants.EnabledByDefault);
+        }
+
+        [Fact]
+        public void TestDisabledByDefault()
+        {
+            Assert.False(AnalyzerConstants.DisabledByDefault);
+        }
+
+        [Fact]
+        public void TestDisabledAlternative()
+        {
+            Assert.False(AnalyzerConstants.DisabledAlternative);
+        }
+
+        [Fact]
+        public void TestDisabledNoTests()
+        {
+#if DEBUG
+            Assert.True(AnalyzerConstants.DisabledNoTests);
+#else
+            Assert.False(AnalyzerConstants.DisabledNoTests);
+#endif
+        }
+    }
+}

AsyncUsageAnalyzers/AsyncUsageAnalyzers.Test/AsyncUsageAnalyzers.Test.csproj

@@ -117,8 +117,11 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="AnalyzerConstantsUnitTests.cs" />
+    <Compile Include="AttributesUnitTests.cs" />
     <Compile Include="Helpers\DiagnosticResultLocation.cs" />
     <Compile Include="Helpers\MetadataReferences.cs" />
+    <Compile Include="Helpers\SpecializedTasksUnitTests.cs" />
     <Compile Include="Helpers\TestDiagnosticProvider.cs" />
     <Compile Include="Naming\AvoidAsyncSuffixUnitTests.cs" />
     <Compile Include="Naming\UseAsyncSuffixUnitTests.cs" />

AsyncUsageAnalyzers/AsyncUsageAnalyzers.Test/AttributesUnitTests.cs

@@ -0,0 +1,17 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+namespace AsyncUsageAnalyzers.Test
+{
+    using Xunit;
+
+    public class AttributesUnitTests
+    {
+        [Fact]
+        public void TestNoCodeFixAttribute()
+        {
+            var attribute = new NoCodeFixAttribute("Message");
+            Assert.Equal("Message", attribute.Reason);
+        }
+    }
+}

AsyncUsageAnalyzers/AsyncUsageAnalyzers.Test/Helpers/SpecializedTasksUnitTests.cs

@@ -0,0 +1,20 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
+
+namespace AsyncUsageAnalyzers.Test.Helpers
+{
+    using System.Threading.Tasks;
+    using AsyncUsageAnalyzers.Helpers;
+    using Xunit;
+
+    public class SpecializedTasksUnitTests
+    {
+        [Fact]
+        public void TestCompletedTask()
+        {
+            Assert.NotNull(SpecializedTasks.CompletedTask);
+            Assert.Equal(TaskStatus.RanToCompletion, SpecializedTasks.CompletedTask.Status);
+            Assert.Same(SpecializedTasks.CompletedTask, SpecializedTasks.CompletedTask);
+        }
+    }
+}

AsyncUsageAnalyzers/AsyncUsageAnalyzers.Test/Reliability/AvoidAsyncVoidUnitTests.cs

@@ -7,12 +7,19 @@ namespace AsyncUsageAnalyzers.Test.Reliability
     using System.Threading;
     using System.Threading.Tasks;
     using AsyncUsageAnalyzers.Reliability;
+    using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.Diagnostics;
     using TestHelper;
     using Xunit;
 
     public class AvoidAsyncVoidUnitTests : DiagnosticVerifier
     {
+        private static readonly DiagnosticDescriptor CS1660 =
+            new DiagnosticDescriptor("CS1660", "Error", "Cannot convert lambda expression to type '{0}' because it is not a delegate type", "Compiler", DiagnosticSeverity.Error, true);
+
+        private static readonly DiagnosticDescriptor CS1989 =
+            new DiagnosticDescriptor("CS1989", "Error", "Async lambda expressions cannot be converted to expression trees", "Compiler", DiagnosticSeverity.Error, true);
+
         [Fact]
         public async Task TestAsyncReturnVoidAsync()
         {
@@ -100,6 +107,82 @@ class ClassName
             await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
         }
 
+        [Fact]
+        public async Task TestNonAsyncLambdaReturnTaskAsync()
+        {
+            string testCode = @"
+using System;
+using System.Threading.Tasks;
+class ClassName
+{
+    static Func<Task> ZeroArgumentFunction;
+    static Func<object, Task> SingleArgumentFunction;
+
+    ClassName()
+    {
+        ZeroArgumentFunction = () => Task.Delay(42);
+        SingleArgumentFunction = arg => Task.Delay(42);
+        SingleArgumentFunction = (object arg) => Task.Delay(42);
+        SingleArgumentFunction = delegate (object arg) { return Task.Delay(42); };
+    }
+}
+";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestAsyncExpressionLambdaReturnTaskAsync()
+        {
+            string testCode = @"
+using System;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+class ClassName
+{
+    static Expression<Func<Task>> ZeroArgumentFunction;
+    static Expression<Func<object, Task>> SingleArgumentFunction;
+
+    ClassName()
+    {
+        ZeroArgumentFunction = async () => await Task.Delay(42);
+        SingleArgumentFunction = async arg => await Task.Delay(42);
+        SingleArgumentFunction = async (object arg) => await Task.Delay(42);
+    }
+}
+";
+
+            DiagnosticResult[] expected =
+            {
+                this.CSharpDiagnostic(CS1989).WithLocation(12, 32),
+                this.CSharpDiagnostic(CS1989).WithLocation(13, 34),
+                this.CSharpDiagnostic(CS1989).WithLocation(14, 34),
+            };
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestAsyncDynamicLambdaReturnTaskAsync()
+        {
+            string testCode = @"
+using System;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+class ClassName
+{
+    static dynamic ZeroArgumentFunction;
+
+    ClassName()
+    {
+        ZeroArgumentFunction = async () => await Task.Delay(42);
+    }
+}
+";
+
+            DiagnosticResult expected = this.CSharpDiagnostic(CS1660).WithArguments("dynamic").WithLocation(11, 32);
+            await this.VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+        }
+
         [Fact]
         public async Task TestAsyncReturnTaskAsync()
         {

AsyncUsageAnalyzers/AsyncUsageAnalyzers.Test/Usage/UseConfigureAwaitUnitTests.cs

@@ -44,6 +44,23 @@ async Task MethodNameAsync()
             await this.VerifyCSharpFixAsync(testCode, fixedCode, cancellationToken: CancellationToken.None).ConfigureAwait(false);
         }
 
+        [Fact]
+        public async Task TestDynamicExpressionAsync()
+        {
+            string testCode = @"
+using System.Threading.Tasks;
+class ClassName
+{
+    async Task MethodNameAsync()
+    {
+        await (dynamic)Task.Delay(1000);
+    }
+}
+";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
         [Fact]
         public async Task TestNestedExpressionsAsync()
         {

AsyncUsageAnalyzers/AsyncUsageAnalyzers.Test/Verifiers/DiagnosticVerifier.cs

@@ -30,6 +30,11 @@ public async Task TestEmptySourceAsync()
         {
             var testCode = string.Empty;
             await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+
+            testCode =
+                "   \r\n"
+                + "\r\n";
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
         }
 
         /// <summary>

AsyncUsageAnalyzers/AsyncUsageAnalyzers/AnalyzerConstants.cs

@@ -28,7 +28,6 @@ static AnalyzerConstants()
         /// <see cref="DiagnosticDescriptor(string, string, string, string, DiagnosticSeverity, bool, string, string, string[])"/>
         /// to disable a diagnostic which is currently untested.
         /// </value>
-        [ExcludeFromCodeCoverage]
         [SuppressMessage("StyleCop.CSharp.DocumentationRules", "SA1623:Property summary documentation must match accessors.", Justification = "This property behaves more like an opaque value than a Boolean.")]
         internal static bool DisabledNoTests { get; }
 

AsyncUsageAnalyzers/AsyncUsageAnalyzers/GeneratedCodeAnalysisExtensions.cs

@@ -175,7 +175,7 @@ private static bool IsEmpty(SyntaxTree tree, CancellationToken cancellationToken
             var firstToken = root.GetFirstToken(includeZeroWidth: true);
 
             return firstToken.IsKind(SyntaxKind.EndOfFileToken)
-                && TriviaHelper.IndexOfFirstNonWhitespaceTrivia(firstToken.LeadingTrivia) == -1;
+                && TriviaHelper.IndexOfFirstNonWhitespaceTrivia(firstToken.LeadingTrivia, true) == -1;
         }
     }
 }