Merge pull request #2405 from bjornhellander/Issue2380_AddTestsForRefTypeSyntaxWrapper

Added tests for RefTypeSyntaxWrapper

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/RefTypeSyntaxWrapperTests.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 RefTypeSyntaxWrapperTests
+    {
+        [Fact]
+        public void TestNull()
+        {
+            var syntaxNode = default(SyntaxNode);
+            var wrapper = (RefTypeSyntaxWrapper)syntaxNode;
+            Assert.Null(wrapper.SyntaxNode);
+            Assert.Throws<NullReferenceException>(() => wrapper.RefKeyword);
+            Assert.Throws<NullReferenceException>(() => wrapper.Type);
+            Assert.Throws<NullReferenceException>(() => wrapper.WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword))));
+            Assert.Throws<NullReferenceException>(() => wrapper.WithRefKeyword(SyntaxFactory.Token(SyntaxKind.RefKeyword)));
+        }
+
+        [Fact]
+        public void TestProperties()
+        {
+            var syntaxNode = this.CreateRefType();
+            Assert.True(syntaxNode.IsKind(SyntaxKind.RefType));
+            Assert.True(syntaxNode.IsKind(SyntaxKindEx.RefType));
+
+            var wrapper = (RefTypeSyntaxWrapper)syntaxNode;
+            Assert.Same(syntaxNode, wrapper.SyntaxNode);
+            Assert.Same(syntaxNode.Type, wrapper.Type);
+            Assert.True(syntaxNode.RefKeyword.IsEquivalentTo(wrapper.RefKeyword));
+
+            var newType = SyntaxFactory.PointerType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword)));
+            var wrapperWithModifiedType = wrapper.WithType(newType);
+            Assert.NotNull(wrapperWithModifiedType.SyntaxNode);
+            Assert.NotSame(syntaxNode.Type, wrapperWithModifiedType.Type);
+            Assert.Equal(SyntaxKind.PointerType, wrapperWithModifiedType.Type.Kind());
+
+            var newRefKeyword = SyntaxFactory.Token(SyntaxKind.RefKeyword).WithLeadingTrivia(SyntaxFactory.Space);
+            var wrapperWithModifiedRefKeyword = wrapper.WithRefKeyword(newRefKeyword);
+            Assert.NotNull(wrapperWithModifiedRefKeyword.SyntaxNode);
+            Assert.Equal(1, wrapperWithModifiedRefKeyword.RefKeyword.LeadingTrivia.Count);
+            Assert.Equal(" ", wrapperWithModifiedRefKeyword.RefKeyword.LeadingTrivia.ToString());
+        }
+
+        [Fact]
+        public void TestIsInstance()
+        {
+            Assert.False(RefTypeSyntaxWrapper.IsInstance(null));
+            Assert.False(RefTypeSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
+
+            var syntaxNode = this.CreateRefType();
+            Assert.True(RefTypeSyntaxWrapper.IsInstance(syntaxNode));
+        }
+
+        [Fact]
+        public void TestConversionsNull()
+        {
+            var syntaxNode = default(SyntaxNode);
+            var wrapper = (RefTypeSyntaxWrapper)syntaxNode;
+
+            TypeSyntax syntax = wrapper;
+            Assert.Null(syntax);
+        }
+
+        [Fact]
+        public void TestConversions()
+        {
+            var syntaxNode = this.CreateRefType();
+            var wrapper = (RefTypeSyntaxWrapper)syntaxNode;
+
+            TypeSyntax syntax = wrapper;
+            Assert.Same(syntaxNode, syntax);
+        }
+
+        [Fact]
+        public void TestInvalidConversion()
+        {
+            var syntaxNode = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
+            Assert.Throws<InvalidCastException>(() => (RefTypeSyntaxWrapper)syntaxNode);
+        }
+
+        private RefTypeSyntax CreateRefType()
+        {
+            return SyntaxFactory.RefType(SyntaxFactory.Token(SyntaxKind.RefKeyword), SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)));
+        }
+    }
+}

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

@@ -279,6 +279,7 @@
     <Compile Include="Lightup\LightupHelpersTestsCSharp7.cs" />
     <Compile Include="Lightup\ParenthesizedVariableDesignationSyntaxWrapperTests.cs" />
     <Compile Include="Lightup\PatternSyntaxWrapperTests.cs" />
+    <Compile Include="Lightup\RefTypeSyntaxWrapperTests.cs" />
     <Compile Include="Lightup\SingleVariableDesignationSyntaxWrapperTests.cs" />
     <Compile Include="Lightup\SyntaxWrapperTests.cs" />
     <Compile Include="Lightup\ThrowExpressionSyntaxWrapperTests.cs" />

StyleCop.Analyzers/StyleCop.Analyzers.Test/Lightup/RefTypeSyntaxWrapperTests.cs

@@ -0,0 +1,51 @@
+// 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 Microsoft.CodeAnalysis.CSharp.Syntax;
+    using StyleCop.Analyzers.Lightup;
+    using Xunit;
+
+    public class RefTypeSyntaxWrapperTests
+    {
+        [Fact]
+        public void TestNull()
+        {
+            var syntaxNode = default(SyntaxNode);
+            var wrapper = (RefTypeSyntaxWrapper)syntaxNode;
+            Assert.Null(wrapper.SyntaxNode);
+            Assert.Throws<NullReferenceException>(() => wrapper.Type);
+            Assert.Throws<NullReferenceException>(() => wrapper.RefKeyword);
+            Assert.Throws<NullReferenceException>(() => wrapper.WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword))));
+            Assert.Throws<NullReferenceException>(() => wrapper.WithRefKeyword(SyntaxFactory.Token(SyntaxKind.IsKeyword)));
+        }
+
+        [Fact]
+        public void TestIsInstance()
+        {
+            Assert.False(RefTypeSyntaxWrapper.IsInstance(null));
+            Assert.False(RefTypeSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
+        }
+
+        [Fact]
+        public void TestConversionsNull()
+        {
+            var syntaxNode = default(SyntaxNode);
+            var wrapper = (RefTypeSyntaxWrapper)syntaxNode;
+
+            TypeSyntax syntax = wrapper;
+            Assert.Null(syntax);
+        }
+
+        [Fact]
+        public void TestInvalidConversion()
+        {
+            var syntaxNode = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
+            Assert.Throws<InvalidCastException>(() => (RefTypeSyntaxWrapper)syntaxNode);
+        }
+    }
+}

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

@@ -247,6 +247,7 @@
     <Compile Include="Lightup\LightupHelpersTests.cs" />
     <Compile Include="Lightup\ParenthesizedVariableDesignationSyntaxWrapperTests.cs" />
     <Compile Include="Lightup\PatternSyntaxWrapperTests.cs" />
+    <Compile Include="Lightup\RefTypeSyntaxWrapperTests.cs" />
     <Compile Include="Lightup\SeparatedSyntaxListWrapperTestBase.cs" />
     <Compile Include="Lightup\SingleVariableDesignationSyntaxWrapperTests.cs" />
     <Compile Include="Lightup\SyntaxWrapperTests.cs" />