Skip to content

Commit b7cb15b

Browse files
bjornhellanderbjornhellander
committed
Add tests for ForEachVariableStatementSyntaxWrapper
#2377
1 parent 17b613d commit b7cb15b

File tree

7 files changed

+602
-0
lines changed

7 files changed

+602
-0
lines changed

‎StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp10/Lightup/ForEachVariableStatementSyntaxWrapperCSharp10UnitTests.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 partial class ForEachVariableStatementSyntaxWrapperCSharp10UnitTests : ForEachVariableStatementSyntaxWrapperCSharp9UnitTests
9+
{
10+
}
11+
}

‎StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp11/Lightup/ForEachVariableStatementSyntaxWrapperCSharp11UnitTests.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 partial class ForEachVariableStatementSyntaxWrapperCSharp11UnitTests : ForEachVariableStatementSyntaxWrapperCSharp10UnitTests
9+
{
10+
}
11+
}

‎StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp12/Lightup/ForEachVariableStatementSyntaxWrapperCSharp12UnitTests.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.CSharp12.Lightup
5+
{
6+
using StyleCop.Analyzers.Test.CSharp11.Lightup;
7+
8+
public partial class ForEachVariableStatementSyntaxWrapperCSharp12UnitTests : ForEachVariableStatementSyntaxWrapperCSharp11UnitTests
9+
{
10+
}
11+
}

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

+237
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,237 @@
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.AttributeLists);
23+
Assert.Throws<NullReferenceException>(() => wrapper.AwaitKeyword);
24+
Assert.Throws<NullReferenceException>(() => wrapper.ForEachKeyword);
25+
Assert.Throws<NullReferenceException>(() => wrapper.OpenParenToken);
26+
Assert.Throws<NullReferenceException>(() => wrapper.Variable);
27+
Assert.Throws<NullReferenceException>(() => wrapper.InKeyword);
28+
Assert.Throws<NullReferenceException>(() => wrapper.Expression);
29+
Assert.Throws<NullReferenceException>(() => wrapper.CloseParenToken);
30+
Assert.Throws<NullReferenceException>(() => wrapper.Statement);
31+
Assert.Throws<NullReferenceException>(() => wrapper.WithAttributeLists(default(SyntaxList<AttributeListSyntax>)));
32+
Assert.Throws<NullReferenceException>(() => wrapper.WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword)));
33+
Assert.Throws<NullReferenceException>(() => wrapper.WithForEachKeyword(SyntaxFactory.Token(SyntaxKind.ForEachKeyword)));
34+
Assert.Throws<NullReferenceException>(() => wrapper.WithOpenParenToken(SyntaxFactory.Token(SyntaxKind.OpenParenToken)));
35+
Assert.Throws<NullReferenceException>(() => wrapper.WithVariable(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
36+
Assert.Throws<NullReferenceException>(() => wrapper.WithInKeyword(SyntaxFactory.Token(SyntaxKind.InKeyword)));
37+
Assert.Throws<NullReferenceException>(() => wrapper.WithExpression(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
38+
Assert.Throws<NullReferenceException>(() => wrapper.WithCloseParenToken(SyntaxFactory.Token(SyntaxKind.CloseParenToken)));
39+
Assert.Throws<NullReferenceException>(() => wrapper.WithStatement(SyntaxFactory.EmptyStatement()));
40+
}
41+
42+
[Fact]
43+
public void TestWrapperIdentity()
44+
{
45+
var syntaxNode = this.CreateForEachVariableStatement();
46+
Assert.True(syntaxNode.IsKind(SyntaxKind.ForEachVariableStatement));
47+
48+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
49+
Assert.Same(syntaxNode, wrapper.SyntaxNode);
50+
}
51+
52+
[Fact]
53+
public void TestAttributeListKeyword()
54+
{
55+
var syntaxNode = this.CreateForEachVariableStatement();
56+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
57+
Assert.Equal(default, wrapper.AttributeLists);
58+
59+
var newPropertyValue = default(SyntaxList<AttributeListSyntax>);
60+
_ = wrapper.WithAttributeLists(newPropertyValue);
61+
62+
newPropertyValue = new SyntaxList<AttributeListSyntax>(
63+
SyntaxFactory.AttributeList(
64+
SyntaxFactory.SeparatedList(
65+
new[]
66+
{
67+
SyntaxFactory.Attribute(
68+
SyntaxFactory.IdentifierName("x"),
69+
null),
70+
})));
71+
Assert.Throws<NotSupportedException>(() => wrapper.WithAttributeLists(newPropertyValue));
72+
}
73+
74+
[Fact]
75+
public void TestAwaitKeyword()
76+
{
77+
var syntaxNode = this.CreateForEachVariableStatement();
78+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
79+
Assert.Equal(default, wrapper.AwaitKeyword);
80+
81+
Assert.Throws<NotSupportedException>(() => wrapper.WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword)));
82+
}
83+
84+
[Fact]
85+
public void TestForEachKeyword()
86+
{
87+
var syntaxNode = this.CreateForEachVariableStatement();
88+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
89+
Assert.Equal(syntaxNode.ForEachKeyword, wrapper.ForEachKeyword);
90+
91+
wrapper = wrapper.WithForEachKeyword(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.ForEachKeyword)));
92+
Assert.NotNull(wrapper.SyntaxNode);
93+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
94+
Assert.False(syntaxNode.ForEachKeyword.IsEquivalentTo(wrapper.ForEachKeyword));
95+
}
96+
97+
[Fact]
98+
public void TestOpenParenToken()
99+
{
100+
var syntaxNode = this.CreateForEachVariableStatement();
101+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
102+
Assert.Equal(syntaxNode.OpenParenToken, wrapper.OpenParenToken);
103+
104+
wrapper = wrapper.WithOpenParenToken(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.OpenParenToken)));
105+
Assert.NotNull(wrapper.SyntaxNode);
106+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
107+
Assert.False(syntaxNode.OpenParenToken.IsEquivalentTo(wrapper.OpenParenToken));
108+
}
109+
110+
[Fact]
111+
public void TestVariable()
112+
{
113+
var syntaxNode = this.CreateForEachVariableStatement();
114+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
115+
Assert.Same(syntaxNode.Variable, wrapper.Variable);
116+
117+
wrapper = wrapper.WithVariable(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(0)));
118+
Assert.NotNull(wrapper.SyntaxNode);
119+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
120+
Assert.NotSame(syntaxNode.Variable, wrapper.Variable);
121+
Assert.False(syntaxNode.Variable.IsEquivalentTo(wrapper.Variable));
122+
}
123+
124+
[Fact]
125+
public void TestInKeyword()
126+
{
127+
var syntaxNode = this.CreateForEachVariableStatement();
128+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
129+
Assert.Equal(syntaxNode.InKeyword, wrapper.InKeyword);
130+
131+
wrapper = wrapper.WithInKeyword(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.InKeyword)));
132+
Assert.NotNull(wrapper.SyntaxNode);
133+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
134+
Assert.False(syntaxNode.InKeyword.IsEquivalentTo(wrapper.InKeyword));
135+
}
136+
137+
[Fact]
138+
public void TestExpression()
139+
{
140+
var syntaxNode = this.CreateForEachVariableStatement();
141+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
142+
Assert.Same(syntaxNode.Expression, wrapper.Expression);
143+
144+
wrapper = wrapper.WithExpression(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(0)));
145+
Assert.NotNull(wrapper.SyntaxNode);
146+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
147+
Assert.NotSame(syntaxNode.Expression, wrapper.Expression);
148+
Assert.False(syntaxNode.Expression.IsEquivalentTo(wrapper.Expression));
149+
}
150+
151+
[Fact]
152+
public void TestCloseParenToken()
153+
{
154+
var syntaxNode = this.CreateForEachVariableStatement();
155+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
156+
Assert.Equal(syntaxNode.CloseParenToken, wrapper.CloseParenToken);
157+
158+
wrapper = wrapper.WithCloseParenToken(SpacingExtensions.WithoutTrivia(SyntaxFactory.Token(SyntaxKind.CloseParenToken)));
159+
Assert.NotNull(wrapper.SyntaxNode);
160+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
161+
Assert.False(syntaxNode.CloseParenToken.IsEquivalentTo(wrapper.CloseParenToken));
162+
}
163+
164+
[Fact]
165+
public void TestStatement()
166+
{
167+
var syntaxNode = this.CreateForEachVariableStatement();
168+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
169+
Assert.Same(syntaxNode.Statement, wrapper.Statement);
170+
171+
wrapper = wrapper.WithStatement(SyntaxFactory.Block());
172+
Assert.NotNull(wrapper.SyntaxNode);
173+
Assert.NotSame(syntaxNode, wrapper.SyntaxNode);
174+
Assert.NotSame(syntaxNode.Statement, wrapper.Statement);
175+
Assert.False(syntaxNode.Statement.IsEquivalentTo(wrapper.Statement));
176+
}
177+
178+
[Fact]
179+
public void TestIsInstance()
180+
{
181+
Assert.False(ForEachVariableStatementSyntaxWrapper.IsInstance(null));
182+
Assert.False(ForEachVariableStatementSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
183+
184+
var syntaxNode = this.CreateForEachVariableStatement();
185+
Assert.True(ForEachVariableStatementSyntaxWrapper.IsInstance(syntaxNode));
186+
}
187+
188+
[Fact]
189+
public void TestConversionsNull()
190+
{
191+
var syntaxNode = default(SyntaxNode);
192+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
193+
194+
StatementSyntax syntax = wrapper;
195+
Assert.Null(syntax);
196+
197+
wrapper = (ForEachVariableStatementSyntaxWrapper)(CommonForEachStatementSyntaxWrapper)syntaxNode;
198+
199+
syntax = wrapper;
200+
Assert.Null(syntax);
201+
}
202+
203+
[Fact]
204+
public void TestConversions()
205+
{
206+
var syntaxNode = this.CreateForEachVariableStatement();
207+
var wrapper = (ForEachVariableStatementSyntaxWrapper)syntaxNode;
208+
209+
StatementSyntax syntax = wrapper;
210+
Assert.Same(syntaxNode, syntax);
211+
212+
wrapper = (ForEachVariableStatementSyntaxWrapper)(CommonForEachStatementSyntaxWrapper)syntaxNode;
213+
214+
syntax = wrapper;
215+
Assert.Same(syntaxNode, syntax);
216+
}
217+
218+
[Fact]
219+
public void TestInvalidConversion()
220+
{
221+
var syntaxNode = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
222+
Assert.Throws<InvalidCastException>(() => (ForEachVariableStatementSyntaxWrapper)syntaxNode);
223+
}
224+
225+
private ForEachVariableStatementSyntax CreateForEachVariableStatement()
226+
{
227+
return SyntaxFactory.ForEachVariableStatement(
228+
SyntaxFactory.Token(SyntaxKind.ForEachKeyword),
229+
SyntaxFactory.Token(SyntaxKind.OpenParenToken),
230+
SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression),
231+
SyntaxFactory.Token(SyntaxKind.InKeyword),
232+
SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression),
233+
SyntaxFactory.Token(SyntaxKind.CloseParenToken),
234+
SyntaxFactory.EmptyStatement());
235+
}
236+
}
237+
}

0 commit comments

Comments
 (0)