Skip to content

Commit c44b4ba

Browse files
bjornhellanderbjornhellander
committed
Add tests for ForEachVariableStatementSyntaxWrapper
#2377
1 parent ef1f91c commit c44b4ba

File tree

5 files changed

+443
-0
lines changed

5 files changed

+443
-0
lines changed

‎StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp10/Lightup/ForEachVariableStatementSyntaxWrapperTestsCSharp10.cs

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
2+
// Licensed under the MIT License. See LICENSE in the project root for license information.
3+
4+
namespace StyleCop.Analyzers.Test.CSharp10.Lightup
5+
{
6+
using StyleCop.Analyzers.Test.CSharp9.Lightup;
7+
8+
public class ForEachVariableStatementSyntaxWrapperTestsCSharp10 : ForEachVariableStatementSyntaxWrapperTestsCSharp9
9+
{
10+
}
11+
}

‎StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp11/Lightup/ForEachVariableStatementSyntaxWrapperTestsCSharp11.cs

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
2+
// Licensed under the MIT License. See LICENSE in the project root for license information.
3+
4+
namespace StyleCop.Analyzers.Test.CSharp11.Lightup
5+
{
6+
using StyleCop.Analyzers.Test.CSharp10.Lightup;
7+
8+
public class ForEachVariableStatementSyntaxWrapperTestsCSharp11 : ForEachVariableStatementSyntaxWrapperTestsCSharp10
9+
{
10+
}
11+
}

‎StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/ForEachVariableStatementSyntaxWrapperTests.cs

+203
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,203 @@
1+
// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
2+
// Licensed under the MIT License. See LICENSE in the project root for license information.
3+
4+
namespace StyleCop.Analyzers.Test.CSharp7.Lightup
5+
{
6+
using System;
7+
using Microsoft.CodeAnalysis;
8+
using Microsoft.CodeAnalysis.CSharp;
9+
using Microsoft.CodeAnalysis.CSharp.Syntax;
10+
using StyleCop.Analyzers.Helpers;
11+
using StyleCop.Analyzers.Lightup;
12+
using Xunit;
13+
14+
public class ForEachVariableStatementSyntaxWrapperTests
15+
{
16+
[Fact]
17+
public void TestNull()
18+
{
19+
var syntaxNode = default(SyntaxNode);
20+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
21+
Assert.Null(wrapper.SyntaxNode);
22+
Assert.Throws<NullReferenceException>(() => wrapper.AwaitKeyword);
23+
Assert.Throws<NullReferenceException>(() => wrapper.ForEachKeyword);
24+
Assert.Throws<NullReferenceException>(() => wrapper.OpenParenToken);
25+
Assert.Throws<NullReferenceException>(() => wrapper.Variable);
26+
Assert.Throws<NullReferenceException>(() => wrapper.InKeyword);
27+
Assert.Throws<NullReferenceException>(() => wrapper.Expression);
28+
Assert.Throws<NullReferenceException>(() => wrapper.CloseParenToken);
29+
Assert.Throws<NullReferenceException>(() => wrapper.Statement);
30+
Assert.Throws<NullReferenceException>(() => wrapper.WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword)));
31+
Assert.Throws<NullReferenceException>(() => wrapper.WithForEachKeyword(SyntaxFactory.Token(SyntaxKind.ForEachKeyword)));
32+
Assert.Throws<NullReferenceException>(() => wrapper.WithOpenParenToken(SyntaxFactory.Token(SyntaxKind.OpenParenToken)));
33+
Assert.Throws<NullReferenceException>(() => wrapper.WithVariable(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
34+
Assert.Throws<NullReferenceException>(() => wrapper.WithInKeyword(SyntaxFactory.Token(SyntaxKind.InKeyword)));
35+
Assert.Throws<NullReferenceException>(() => wrapper.WithExpression(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
36+
Assert.Throws<NullReferenceException>(() => wrapper.WithCloseParenToken(SyntaxFactory.Token(SyntaxKind.CloseParenToken)));
37+
Assert.Throws<NullReferenceException>(() => wrapper.WithStatement(SyntaxFactory.EmptyStatement()));
38+
}
39+
40+
[Fact]
41+
public void TestWrapperIdentity()
42+
{
43+
var syntaxNode = this.CreateForEachVariableStatement();
44+
Assert.True(syntaxNode.IsKind(SyntaxKind.ForEachVariableStatement));
45+
46+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
47+
Assert.Same(syntaxNode, wrapper.SyntaxNode);
48+
}
49+
50+
[Fact]
51+
public void TestAwaitKeyword()
52+
{
53+
var syntaxNode = this.CreateForEachVariableStatement();
54+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
55+
Assert.Equal(default, wrapper.AwaitKeyword);
56+
57+
Assert.Throws<NotSupportedException>(() => wrapper.WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword)));
58+
}
59+
60+
[Fact]
61+
public void TestForEachKeyword()
62+
{
63+
var syntaxNode = this.CreateForEachVariableStatement();
64+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
65+
Assert.Equal(syntaxNode.ForEachKeyword, wrapper.ForEachKeyword);
66+
67+
wrapper = wrapper.WithForEachKeyword(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.ForEachKeyword)));
68+
Assert.NotNull(wrapper.SyntaxNode);
69+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
70+
Assert.False(syntaxNode.ForEachKeyword.IsEquivalentTo(wrapper.ForEachKeyword));
71+
}
72+
73+
[Fact]
74+
public void TestOpenParenToken()
75+
{
76+
var syntaxNode = this.CreateForEachVariableStatement();
77+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
78+
Assert.Equal(syntaxNode.OpenParenToken, wrapper.OpenParenToken);
79+
80+
wrapper = wrapper.WithOpenParenToken(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.OpenParenToken)));
81+
Assert.NotNull(wrapper.SyntaxNode);
82+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
83+
Assert.False(syntaxNode.OpenParenToken.IsEquivalentTo(wrapper.OpenParenToken));
84+
}
85+
86+
[Fact]
87+
public void TestVariable()
88+
{
89+
var syntaxNode = this.CreateForEachVariableStatement();
90+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
91+
Assert.Same(syntaxNode.Variable, wrapper.Variable);
92+
93+
wrapper = wrapper.WithVariable(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(0)));
94+
Assert.NotNull(wrapper.SyntaxNode);
95+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
96+
Assert.NotSame(syntaxNode.Variable, wrapper.Variable);
97+
Assert.False(syntaxNode.Variable.IsEquivalentTo(wrapper.Variable));
98+
}
99+
100+
[Fact]
101+
public void TestInKeyword()
102+
{
103+
var syntaxNode = this.CreateForEachVariableStatement();
104+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
105+
Assert.Equal(syntaxNode.InKeyword, wrapper.InKeyword);
106+
107+
wrapper = wrapper.WithInKeyword(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.InKeyword)));
108+
Assert.NotNull(wrapper.SyntaxNode);
109+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
110+
Assert.False(syntaxNode.InKeyword.IsEquivalentTo(wrapper.InKeyword));
111+
}
112+
113+
[Fact]
114+
public void TestExpression()
115+
{
116+
var syntaxNode = this.CreateForEachVariableStatement();
117+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
118+
Assert.Same(syntaxNode.Expression, wrapper.Expression);
119+
120+
wrapper = wrapper.WithExpression(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(0)));
121+
Assert.NotNull(wrapper.SyntaxNode);
122+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
123+
Assert.NotSame(syntaxNode.Expression, wrapper.Expression);
124+
Assert.False(syntaxNode.Expression.IsEquivalentTo(wrapper.Expression));
125+
}
126+
127+
[Fact]
128+
public void TestCloseParenToken()
129+
{
130+
var syntaxNode = this.CreateForEachVariableStatement();
131+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
132+
Assert.Equal(syntaxNode.CloseParenToken, wrapper.CloseParenToken);
133+
134+
wrapper = wrapper.WithCloseParenToken(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.CloseParenToken)));
135+
Assert.NotNull(wrapper.SyntaxNode);
136+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
137+
Assert.False(syntaxNode.CloseParenToken.IsEquivalentTo(wrapper.CloseParenToken));
138+
}
139+
140+
[Fact]
141+
public void TestStatement()
142+
{
143+
var syntaxNode = this.CreateForEachVariableStatement();
144+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
145+
Assert.Same(syntaxNode.Statement, wrapper.Statement);
146+
147+
wrapper = wrapper.WithStatement(SyntaxFactory.Block());
148+
Assert.NotNull(wrapper.SyntaxNode);
149+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
150+
Assert.NotSame(syntaxNode.Statement, wrapper.Statement);
151+
Assert.False(syntaxNode.Statement.IsEquivalentTo(wrapper.Statement));
152+
}
153+
154+
[Fact]
155+
public void TestIsInstance()
156+
{
157+
Assert.False(ForEachVariableStatementSyntaxWrapper.IsInstance(null));
158+
Assert.False(ForEachVariableStatementSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
159+
160+
var syntaxNode = this.CreateForEachVariableStatement();
161+
Assert.True(ForEachVariableStatementSyntaxWrapper.IsInstance(syntaxNode));
162+
}
163+
164+
[Fact]
165+
public void TestConversionsNull()
166+
{
167+
var syntaxNode = default(SyntaxNode);
168+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
169+
170+
StatementSyntax syntax = wrapper;
171+
Assert.Null(syntax);
172+
}
173+
174+
[Fact]
175+
public void TestConversions()
176+
{
177+
var syntaxNode = this.CreateForEachVariableStatement();
178+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
179+
180+
StatementSyntax syntax = wrapper;
181+
Assert.Same(syntaxNode, syntax);
182+
}
183+
184+
[Fact]
185+
public void TestInvalidConversion()
186+
{
187+
var syntaxNode = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
188+
Assert.Throws<InvalidCastException>(() => (ForEachVariableStatementSyntaxWrapper)syntaxNode);
189+
}
190+
191+
private ForEachVariableStatementSyntax CreateForEachVariableStatement()
192+
{
193+
return SyntaxFactory.ForEachVariableStatement(
194+
SyntaxFactory.Token(SyntaxKind.ForEachKeyword),
195+
SyntaxFactory.Token(SyntaxKind.OpenParenToken),
196+
SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression),
197+
SyntaxFactory.Token(SyntaxKind.InKeyword),
198+
SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression),
199+
SyntaxFactory.Token(SyntaxKind.CloseParenToken),
200+
SyntaxFactory.EmptyStatement());
201+
}
202+
}
203+
}

0 commit comments

Comments
 (0)