From f9b1122c4366b4353a2d185009fdf3fd2de659a4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B6rn=20Hellander?= Date: Sun, 2 Apr 2023 11:05:41 +0200 Subject: [PATCH] Add tests for ForEachVariableStatementSyntaxWrapper #2377 --- ...ableStatementSyntaxWrapperTestsCSharp10.cs | 11 + ...ableStatementSyntaxWrapperTestsCSharp11.cs | 11 + ...EachVariableStatementSyntaxWrapperTests.cs | 203 +++++++++++++++++ ...iableStatementSyntaxWrapperTestsCSharp8.cs | 207 ++++++++++++++++++ ...iableStatementSyntaxWrapperTestsCSharp9.cs | 11 + 5 files changed, 443 insertions(+) create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp10/Lightup/ForEachVariableStatementSyntaxWrapperTestsCSharp10.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp11/Lightup/ForEachVariableStatementSyntaxWrapperTestsCSharp11.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/ForEachVariableStatementSyntaxWrapperTests.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/Lightup/ForEachVariableStatementSyntaxWrapperTestsCSharp8.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp9/Lightup/ForEachVariableStatementSyntaxWrapperTestsCSharp9.cs diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp10/Lightup/ForEachVariableStatementSyntaxWrapperTestsCSharp10.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp10/Lightup/ForEachVariableStatementSyntaxWrapperTestsCSharp10.cs new file mode 100644 index 000000000..352a2ef2c --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp10/Lightup/ForEachVariableStatementSyntaxWrapperTestsCSharp10.cs @@ -0,0 +1,11 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Test.CSharp10.Lightup +{ + using StyleCop.Analyzers.Test.CSharp9.Lightup; + + public class ForEachVariableStatementSyntaxWrapperTestsCSharp10 : ForEachVariableStatementSyntaxWrapperTestsCSharp9 + { + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp11/Lightup/ForEachVariableStatementSyntaxWrapperTestsCSharp11.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp11/Lightup/ForEachVariableStatementSyntaxWrapperTestsCSharp11.cs new file mode 100644 index 000000000..b5d3441ce --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp11/Lightup/ForEachVariableStatementSyntaxWrapperTestsCSharp11.cs @@ -0,0 +1,11 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Test.CSharp11.Lightup +{ + using StyleCop.Analyzers.Test.CSharp10.Lightup; + + public class ForEachVariableStatementSyntaxWrapperTestsCSharp11 : ForEachVariableStatementSyntaxWrapperTestsCSharp10 + { + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/ForEachVariableStatementSyntaxWrapperTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/ForEachVariableStatementSyntaxWrapperTests.cs new file mode 100644 index 000000000..7dcd9c16d --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/ForEachVariableStatementSyntaxWrapperTests.cs @@ -0,0 +1,203 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. 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.Helpers; + using StyleCop.Analyzers.Lightup; + using Xunit; + + public class ForEachVariableStatementSyntaxWrapperTests + { + [Fact] + public void TestNull() + { + var syntaxNode = default(SyntaxNode); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Null(wrapper.SyntaxNode); + Assert.Throws(() => wrapper.AwaitKeyword); + Assert.Throws(() => wrapper.ForEachKeyword); + Assert.Throws(() => wrapper.OpenParenToken); + Assert.Throws(() => wrapper.Variable); + Assert.Throws(() => wrapper.InKeyword); + Assert.Throws(() => wrapper.Expression); + Assert.Throws(() => wrapper.CloseParenToken); + Assert.Throws(() => wrapper.Statement); + Assert.Throws(() => wrapper.WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword))); + Assert.Throws(() => wrapper.WithForEachKeyword(SyntaxFactory.Token(SyntaxKind.ForEachKeyword))); + Assert.Throws(() => wrapper.WithOpenParenToken(SyntaxFactory.Token(SyntaxKind.OpenParenToken))); + Assert.Throws(() => wrapper.WithVariable(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))); + Assert.Throws(() => wrapper.WithInKeyword(SyntaxFactory.Token(SyntaxKind.InKeyword))); + Assert.Throws(() => wrapper.WithExpression(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))); + Assert.Throws(() => wrapper.WithCloseParenToken(SyntaxFactory.Token(SyntaxKind.CloseParenToken))); + Assert.Throws(() => wrapper.WithStatement(SyntaxFactory.EmptyStatement())); + } + + [Fact] + public void TestWrapperIdentity() + { + var syntaxNode = this.CreateForEachVariableStatement(); + Assert.True(syntaxNode.IsKind(SyntaxKind.ForEachVariableStatement)); + + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Same(syntaxNode, wrapper.SyntaxNode); + } + + [Fact] + public void TestAwaitKeyword() + { + var syntaxNode = this.CreateForEachVariableStatement(); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Equal(default, wrapper.AwaitKeyword); + + Assert.Throws(() => wrapper.WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword))); + } + + [Fact] + public void TestForEachKeyword() + { + var syntaxNode = this.CreateForEachVariableStatement(); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Equal(syntaxNode.ForEachKeyword, wrapper.ForEachKeyword); + + wrapper = wrapper.WithForEachKeyword(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.ForEachKeyword))); + Assert.NotNull(wrapper.SyntaxNode); + Assert.NotSame(syntaxNode, wrapper.SyntaxNode); + Assert.False(syntaxNode.ForEachKeyword.IsEquivalentTo(wrapper.ForEachKeyword)); + } + + [Fact] + public void TestOpenParenToken() + { + var syntaxNode = this.CreateForEachVariableStatement(); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Equal(syntaxNode.OpenParenToken, wrapper.OpenParenToken); + + wrapper = wrapper.WithOpenParenToken(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.OpenParenToken))); + Assert.NotNull(wrapper.SyntaxNode); + Assert.NotSame(syntaxNode, wrapper.SyntaxNode); + Assert.False(syntaxNode.OpenParenToken.IsEquivalentTo(wrapper.OpenParenToken)); + } + + [Fact] + public void TestVariable() + { + var syntaxNode = this.CreateForEachVariableStatement(); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Same(syntaxNode.Variable, wrapper.Variable); + + wrapper = wrapper.WithVariable(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(0))); + Assert.NotNull(wrapper.SyntaxNode); + Assert.NotSame(syntaxNode, wrapper.SyntaxNode); + Assert.NotSame(syntaxNode.Variable, wrapper.Variable); + Assert.False(syntaxNode.Variable.IsEquivalentTo(wrapper.Variable)); + } + + [Fact] + public void TestInKeyword() + { + var syntaxNode = this.CreateForEachVariableStatement(); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Equal(syntaxNode.InKeyword, wrapper.InKeyword); + + wrapper = wrapper.WithInKeyword(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.InKeyword))); + Assert.NotNull(wrapper.SyntaxNode); + Assert.NotSame(syntaxNode, wrapper.SyntaxNode); + Assert.False(syntaxNode.InKeyword.IsEquivalentTo(wrapper.InKeyword)); + } + + [Fact] + public void TestExpression() + { + var syntaxNode = this.CreateForEachVariableStatement(); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Same(syntaxNode.Expression, wrapper.Expression); + + wrapper = wrapper.WithExpression(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(0))); + Assert.NotNull(wrapper.SyntaxNode); + Assert.NotSame(syntaxNode, wrapper.SyntaxNode); + Assert.NotSame(syntaxNode.Expression, wrapper.Expression); + Assert.False(syntaxNode.Expression.IsEquivalentTo(wrapper.Expression)); + } + + [Fact] + public void TestCloseParenToken() + { + var syntaxNode = this.CreateForEachVariableStatement(); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Equal(syntaxNode.CloseParenToken, wrapper.CloseParenToken); + + wrapper = wrapper.WithCloseParenToken(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.CloseParenToken))); + Assert.NotNull(wrapper.SyntaxNode); + Assert.NotSame(syntaxNode, wrapper.SyntaxNode); + Assert.False(syntaxNode.CloseParenToken.IsEquivalentTo(wrapper.CloseParenToken)); + } + + [Fact] + public void TestStatement() + { + var syntaxNode = this.CreateForEachVariableStatement(); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Same(syntaxNode.Statement, wrapper.Statement); + + wrapper = wrapper.WithStatement(SyntaxFactory.Block()); + Assert.NotNull(wrapper.SyntaxNode); + Assert.NotSame(syntaxNode, wrapper.SyntaxNode); + Assert.NotSame(syntaxNode.Statement, wrapper.Statement); + Assert.False(syntaxNode.Statement.IsEquivalentTo(wrapper.Statement)); + } + + [Fact] + public void TestIsInstance() + { + Assert.False(ForEachVariableStatementSyntaxWrapper.IsInstance(null)); + Assert.False(ForEachVariableStatementSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))); + + var syntaxNode = this.CreateForEachVariableStatement(); + Assert.True(ForEachVariableStatementSyntaxWrapper.IsInstance(syntaxNode)); + } + + [Fact] + public void TestConversionsNull() + { + var syntaxNode = default(SyntaxNode); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + + StatementSyntax syntax = wrapper; + Assert.Null(syntax); + } + + [Fact] + public void TestConversions() + { + var syntaxNode = this.CreateForEachVariableStatement(); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + + StatementSyntax syntax = wrapper; + Assert.Same(syntaxNode, syntax); + } + + [Fact] + public void TestInvalidConversion() + { + var syntaxNode = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression); + Assert.Throws(() => (ForEachVariableStatementSyntaxWrapper)syntaxNode); + } + + private ForEachVariableStatementSyntax CreateForEachVariableStatement() + { + return SyntaxFactory.ForEachVariableStatement( + SyntaxFactory.Token(SyntaxKind.ForEachKeyword), + SyntaxFactory.Token(SyntaxKind.OpenParenToken), + SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression), + SyntaxFactory.Token(SyntaxKind.InKeyword), + SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression), + SyntaxFactory.Token(SyntaxKind.CloseParenToken), + SyntaxFactory.EmptyStatement()); + } + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/Lightup/ForEachVariableStatementSyntaxWrapperTestsCSharp8.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/Lightup/ForEachVariableStatementSyntaxWrapperTestsCSharp8.cs new file mode 100644 index 000000000..b41d35088 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/Lightup/ForEachVariableStatementSyntaxWrapperTestsCSharp8.cs @@ -0,0 +1,207 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Test.CSharp8.Lightup +{ + using System; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + using StyleCop.Analyzers.Helpers; + using StyleCop.Analyzers.Lightup; + using Xunit; + + public class ForEachVariableStatementSyntaxWrapperTestsCSharp8 + { + [Fact] + public void TestNull() + { + var syntaxNode = default(SyntaxNode); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Null(wrapper.SyntaxNode); + Assert.Throws(() => wrapper.AwaitKeyword); + Assert.Throws(() => wrapper.ForEachKeyword); + Assert.Throws(() => wrapper.OpenParenToken); + Assert.Throws(() => wrapper.Variable); + Assert.Throws(() => wrapper.InKeyword); + Assert.Throws(() => wrapper.Expression); + Assert.Throws(() => wrapper.CloseParenToken); + Assert.Throws(() => wrapper.Statement); + Assert.Throws(() => wrapper.WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword))); + Assert.Throws(() => wrapper.WithForEachKeyword(SyntaxFactory.Token(SyntaxKind.ForEachKeyword))); + Assert.Throws(() => wrapper.WithOpenParenToken(SyntaxFactory.Token(SyntaxKind.OpenParenToken))); + Assert.Throws(() => wrapper.WithVariable(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))); + Assert.Throws(() => wrapper.WithInKeyword(SyntaxFactory.Token(SyntaxKind.InKeyword))); + Assert.Throws(() => wrapper.WithExpression(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))); + Assert.Throws(() => wrapper.WithCloseParenToken(SyntaxFactory.Token(SyntaxKind.CloseParenToken))); + Assert.Throws(() => wrapper.WithStatement(SyntaxFactory.EmptyStatement())); + } + + [Fact] + public void TestWrapperIdentity() + { + var syntaxNode = this.CreateForEachVariableStatement(); + Assert.True(syntaxNode.IsKind(SyntaxKind.ForEachVariableStatement)); + + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Same(syntaxNode, wrapper.SyntaxNode); + } + + [Fact] + public void TestAwaitKeyword() + { + var syntaxNode = this.CreateForEachVariableStatement(); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Equal(syntaxNode.AwaitKeyword, wrapper.AwaitKeyword); + + wrapper = wrapper.WithAwaitKeyword(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.AwaitKeyword))); + Assert.NotNull(wrapper.SyntaxNode); + Assert.NotSame(syntaxNode, wrapper.SyntaxNode); + Assert.False(syntaxNode.AwaitKeyword.IsEquivalentTo(wrapper.AwaitKeyword)); + } + + [Fact] + public void TestForEachKeyword() + { + var syntaxNode = this.CreateForEachVariableStatement(); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Equal(syntaxNode.ForEachKeyword, wrapper.ForEachKeyword); + + wrapper = wrapper.WithForEachKeyword(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.ForEachKeyword))); + Assert.NotNull(wrapper.SyntaxNode); + Assert.NotSame(syntaxNode, wrapper.SyntaxNode); + Assert.False(syntaxNode.ForEachKeyword.IsEquivalentTo(wrapper.ForEachKeyword)); + } + + [Fact] + public void TestOpenParenToken() + { + var syntaxNode = this.CreateForEachVariableStatement(); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Equal(syntaxNode.OpenParenToken, wrapper.OpenParenToken); + + wrapper = wrapper.WithOpenParenToken(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.OpenParenToken))); + Assert.NotNull(wrapper.SyntaxNode); + Assert.NotSame(syntaxNode, wrapper.SyntaxNode); + Assert.False(syntaxNode.OpenParenToken.IsEquivalentTo(wrapper.OpenParenToken)); + } + + [Fact] + public void TestVariable() + { + var syntaxNode = this.CreateForEachVariableStatement(); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Same(syntaxNode.Variable, wrapper.Variable); + + wrapper = wrapper.WithVariable(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(0))); + Assert.NotNull(wrapper.SyntaxNode); + Assert.NotSame(syntaxNode, wrapper.SyntaxNode); + Assert.NotSame(syntaxNode.Variable, wrapper.Variable); + Assert.False(syntaxNode.Variable.IsEquivalentTo(wrapper.Variable)); + } + + [Fact] + public void TestInKeyword() + { + var syntaxNode = this.CreateForEachVariableStatement(); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Equal(syntaxNode.InKeyword, wrapper.InKeyword); + + wrapper = wrapper.WithInKeyword(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.InKeyword))); + Assert.NotNull(wrapper.SyntaxNode); + Assert.NotSame(syntaxNode, wrapper.SyntaxNode); + Assert.False(syntaxNode.InKeyword.IsEquivalentTo(wrapper.InKeyword)); + } + + [Fact] + public void TestExpression() + { + var syntaxNode = this.CreateForEachVariableStatement(); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Same(syntaxNode.Expression, wrapper.Expression); + + wrapper = wrapper.WithExpression(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(0))); + Assert.NotNull(wrapper.SyntaxNode); + Assert.NotSame(syntaxNode, wrapper.SyntaxNode); + Assert.NotSame(syntaxNode.Expression, wrapper.Expression); + Assert.False(syntaxNode.Expression.IsEquivalentTo(wrapper.Expression)); + } + + [Fact] + public void TestCloseParenToken() + { + var syntaxNode = this.CreateForEachVariableStatement(); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Equal(syntaxNode.CloseParenToken, wrapper.CloseParenToken); + + wrapper = wrapper.WithCloseParenToken(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.CloseParenToken))); + Assert.NotNull(wrapper.SyntaxNode); + Assert.NotSame(syntaxNode, wrapper.SyntaxNode); + Assert.False(syntaxNode.CloseParenToken.IsEquivalentTo(wrapper.CloseParenToken)); + } + + [Fact] + public void TestStatement() + { + var syntaxNode = this.CreateForEachVariableStatement(); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + Assert.Same(syntaxNode.Statement, wrapper.Statement); + + wrapper = wrapper.WithStatement(SyntaxFactory.Block()); + Assert.NotNull(wrapper.SyntaxNode); + Assert.NotSame(syntaxNode, wrapper.SyntaxNode); + Assert.NotSame(syntaxNode.Statement, wrapper.Statement); + Assert.False(syntaxNode.Statement.IsEquivalentTo(wrapper.Statement)); + } + + [Fact] + public void TestIsInstance() + { + Assert.False(ForEachVariableStatementSyntaxWrapper.IsInstance(null)); + Assert.False(ForEachVariableStatementSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))); + + var syntaxNode = this.CreateForEachVariableStatement(); + Assert.True(ForEachVariableStatementSyntaxWrapper.IsInstance(syntaxNode)); + } + + [Fact] + public void TestConversionsNull() + { + var syntaxNode = default(SyntaxNode); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + + StatementSyntax syntax = wrapper; + Assert.Null(syntax); + } + + [Fact] + public void TestConversions() + { + var syntaxNode = this.CreateForEachVariableStatement(); + var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode; + + StatementSyntax syntax = wrapper; + Assert.Same(syntaxNode, syntax); + } + + [Fact] + public void TestInvalidConversion() + { + var syntaxNode = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression); + Assert.Throws(() => (ForEachVariableStatementSyntaxWrapper)syntaxNode); + } + + private ForEachVariableStatementSyntax CreateForEachVariableStatement() + { + return SyntaxFactory.ForEachVariableStatement( + SyntaxFactory.Token(SyntaxKind.AwaitKeyword), + SyntaxFactory.Token(SyntaxKind.ForEachKeyword), + SyntaxFactory.Token(SyntaxKind.OpenParenToken), + SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression), + SyntaxFactory.Token(SyntaxKind.InKeyword), + SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression), + SyntaxFactory.Token(SyntaxKind.CloseParenToken), + SyntaxFactory.EmptyStatement()); + } + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp9/Lightup/ForEachVariableStatementSyntaxWrapperTestsCSharp9.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp9/Lightup/ForEachVariableStatementSyntaxWrapperTestsCSharp9.cs new file mode 100644 index 000000000..25d35c976 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp9/Lightup/ForEachVariableStatementSyntaxWrapperTestsCSharp9.cs @@ -0,0 +1,11 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Test.CSharp9.Lightup +{ + using StyleCop.Analyzers.Test.CSharp8.Lightup; + + public class ForEachVariableStatementSyntaxWrapperTestsCSharp9 : ForEachVariableStatementSyntaxWrapperTestsCSharp8 + { + } +}