Added tests for WhenClauseSyntaxWrapper.

Author: bjornhellander

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/WhenClauseSyntaxWrapperTests.cs

@@ -0,0 +1,94 @@
+// 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 StyleCop.Analyzers.Test.CSharp7.Lightup
+{
+    using System;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
+    using Microsoft.CodeAnalysis.CSharp.Syntax;
+    using StyleCop.Analyzers.Lightup;
+    using Xunit;
+
+    public class WhenClauseSyntaxWrapperTests
+    {
+        [Fact]
+        public void TestNull()
+        {
+            var syntaxNode = default(SyntaxNode);
+            var wrapper = (WhenClauseSyntaxWrapper)syntaxNode;
+            Assert.Null(wrapper.SyntaxNode);
+            Assert.Throws<NullReferenceException>(() => wrapper.WhenKeyword);
+            Assert.Throws<NullReferenceException>(() => wrapper.Condition);
+            Assert.Throws<NullReferenceException>(() => wrapper.WithCondition(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)));
+            Assert.Throws<NullReferenceException>(() => wrapper.WithWhenKeyword(SyntaxFactory.Token(SyntaxKind.WhenKeyword)));
+        }
+
+        [Fact]
+        public void TestProperties()
+        {
+            var syntaxNode = this.CreateWhenClause();
+            Assert.True(syntaxNode.IsKind(SyntaxKind.WhenClause));
+            Assert.True(syntaxNode.IsKind(SyntaxKindEx.WhenClause));
+
+            var wrapper = (WhenClauseSyntaxWrapper)syntaxNode;
+            Assert.Same(syntaxNode, wrapper.SyntaxNode);
+            Assert.Same(syntaxNode.Condition, wrapper.Condition);
+            Assert.True(syntaxNode.WhenKeyword.IsEquivalentTo(wrapper.WhenKeyword));
+
+            var newCondition = SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression);
+            var wrapperWithModifiedCondition = wrapper.WithCondition(newCondition);
+            Assert.NotNull(wrapperWithModifiedCondition.SyntaxNode);
+            Assert.NotSame(syntaxNode.Condition, wrapperWithModifiedCondition.Condition);
+            Assert.Equal(SyntaxKind.FalseLiteralExpression, wrapperWithModifiedCondition.Condition.Kind());
+
+            var newWhenKeyword = SyntaxFactory.Token(SyntaxKind.WhenKeyword).WithLeadingTrivia(SyntaxFactory.Space);
+            var wrapperWithModifiedWhenKeyword = wrapper.WithWhenKeyword(newWhenKeyword);
+            Assert.NotNull(wrapperWithModifiedWhenKeyword.SyntaxNode);
+            Assert.Equal(1, wrapperWithModifiedWhenKeyword.WhenKeyword.LeadingTrivia.Count);
+            Assert.Equal(" ", wrapperWithModifiedWhenKeyword.WhenKeyword.LeadingTrivia.ToString());
+        }
+
+        [Fact]
+        public void TestIsInstance()
+        {
+            Assert.False(WhenClauseSyntaxWrapper.IsInstance(null));
+            Assert.False(WhenClauseSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
+
+            var syntaxNode = this.CreateWhenClause();
+            Assert.True(WhenClauseSyntaxWrapper.IsInstance(syntaxNode));
+        }
+
+        [Fact]
+        public void TestConversionsNull()
+        {
+            var syntaxNode = default(SyntaxNode);
+            var wrapper = (WhenClauseSyntaxWrapper)syntaxNode;
+
+            CSharpSyntaxNode syntax = wrapper;
+            Assert.Null(syntax);
+        }
+
+        [Fact]
+        public void TestConversions()
+        {
+            var syntaxNode = this.CreateWhenClause();
+            var wrapper = (WhenClauseSyntaxWrapper)syntaxNode;
+
+            CSharpSyntaxNode syntax = wrapper;
+            Assert.Same(syntaxNode, syntax);
+        }
+
+        [Fact]
+        public void TestInvalidConversion()
+        {
+            var syntaxNode = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
+            Assert.Throws<InvalidCastException>(() => (WhenClauseSyntaxWrapper)syntaxNode);
+        }
+
+        private WhenClauseSyntax CreateWhenClause()
+        {
+            return SyntaxFactory.WhenClause(SyntaxFactory.Token(SyntaxKind.WhenKeyword), SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression));
+        }
+    }
+}

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/StyleCop.Analyzers.Test.CSharp7.csproj

@@ -282,6 +282,7 @@
     <Compile Include="Lightup\SingleVariableDesignationSyntaxWrapperTests.cs" />
     <Compile Include="Lightup\SyntaxWrapperTests.cs" />
     <Compile Include="Lightup\VariableDesignationSyntaxWrapperTests.cs" />
+    <Compile Include="Lightup\WhenClauseSyntaxWrapperTests.cs" />
     <Compile Include="MaintainabilityRules\SA1119CSharp7UnitTests.cs" />
     <Compile Include="MaintainabilityRules\SA1400CSharp7UnitTests.cs" />
     <Compile Include="MaintainabilityRules\SA1401CSharp7UnitTests.cs" />

StyleCop.Analyzers/StyleCop.Analyzers.Test/Lightup/WhenClauseSyntaxWrapperTests.cs

@@ -0,0 +1,50 @@
+// 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 StyleCop.Analyzers.Test.Lightup
+{
+    using System;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
+    using StyleCop.Analyzers.Lightup;
+    using Xunit;
+
+    public class WhenClauseSyntaxWrapperTests
+    {
+        [Fact]
+        public void TestNull()
+        {
+            var syntaxNode = default(SyntaxNode);
+            var wrapper = (WhenClauseSyntaxWrapper)syntaxNode;
+            Assert.Null(wrapper.SyntaxNode);
+            Assert.Throws<NullReferenceException>(() => wrapper.Condition);
+            Assert.Throws<NullReferenceException>(() => wrapper.WhenKeyword);
+            Assert.Throws<NullReferenceException>(() => wrapper.WithCondition(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
+            Assert.Throws<NullReferenceException>(() => wrapper.WithWhenKeyword(SyntaxFactory.Token(SyntaxKind.IsKeyword)));
+        }
+
+        [Fact]
+        public void TestIsInstance()
+        {
+            Assert.False(WhenClauseSyntaxWrapper.IsInstance(null));
+            Assert.False(WhenClauseSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
+        }
+
+        [Fact]
+        public void TestConversionsNull()
+        {
+            var syntaxNode = default(SyntaxNode);
+            var wrapper = (WhenClauseSyntaxWrapper)syntaxNode;
+
+            CSharpSyntaxNode syntax = wrapper;
+            Assert.Null(syntax);
+        }
+
+        [Fact]
+        public void TestInvalidConversion()
+        {
+            var syntaxNode = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
+            Assert.Throws<InvalidCastException>(() => (WhenClauseSyntaxWrapper)syntaxNode);
+        }
+    }
+}

StyleCop.Analyzers/StyleCop.Analyzers.Test/StyleCop.Analyzers.Test.csproj

@@ -252,6 +252,7 @@
     <Compile Include="Lightup\SyntaxWrapperTests.cs" />
     <Compile Include="Lightup\UnsupportedSyntaxListTests.cs" />
     <Compile Include="Lightup\VariableDesignationSyntaxWrapperTests.cs" />
+    <Compile Include="Lightup\WhenClauseSyntaxWrapperTests.cs" />
     <Compile Include="LinqHelpers\SyntaxTriviaListEnumerableTests.cs" />
     <Compile Include="MaintainabilityRules\DebugMessagesUnitTestsBase.cs" />
     <Compile Include="MaintainabilityRules\FileMayOnlyContainTestBase.cs" />