Skip to content

Commit f1c8266

Browse files
sharwellsharwell
committed
Add tests for TupleExpressionSyntaxWrapper
Fixes #2383
1 parent d46e3fc commit f1c8266

4 files changed

Lines changed: 170 additions & 0 deletions

File tree

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

Lines changed: 111 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,111 @@
1+
// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
2+
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
3+
4+
namespace StyleCop.Analyzers.Test.CSharp7.Lightup
5+
{
6+
using System;
7+
using System.Collections.Immutable;
8+
using Microsoft.CodeAnalysis;
9+
using Microsoft.CodeAnalysis.CSharp;
10+
using Microsoft.CodeAnalysis.CSharp.Syntax;
11+
using StyleCop.Analyzers.Lightup;
12+
using Xunit;
13+
14+
public class TupleExpressionSyntaxWrapperTests
15+
{
16+
[Fact]
17+
public void TestNull()
18+
{
19+
var syntaxNode = default(SyntaxNode);
20+
var wrapper = (TupleExpressionSyntaxWrapper)syntaxNode;
21+
Assert.Null(wrapper.SyntaxNode);
22+
Assert.Throws<NullReferenceException>(() => wrapper.OpenParenToken);
23+
Assert.Throws<NullReferenceException>(() => wrapper.Arguments);
24+
Assert.Throws<NullReferenceException>(() => wrapper.CloseParenToken);
25+
Assert.Throws<NullReferenceException>(() => wrapper.WithOpenParenToken(SyntaxFactory.Token(SyntaxKind.OpenParenToken)));
26+
Assert.Throws<NullReferenceException>(() => wrapper.WithArguments(SyntaxFactory.SeparatedList(
27+
ImmutableArray.Create(
28+
SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)),
29+
SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression))))));
30+
Assert.Throws<NullReferenceException>(() => wrapper.WithCloseParenToken(SyntaxFactory.Token(SyntaxKind.CloseParenToken)));
31+
}
32+
33+
[Fact]
34+
public void TestProperties()
35+
{
36+
var syntaxNode = this.CreateTupleExpression();
37+
Assert.True(syntaxNode.IsKind(SyntaxKind.TupleExpression));
38+
Assert.True(syntaxNode.IsKind(SyntaxKindEx.TupleExpression));
39+
40+
var wrapper = (TupleExpressionSyntaxWrapper)syntaxNode;
41+
Assert.Same(syntaxNode, wrapper.SyntaxNode);
42+
Assert.True(syntaxNode.OpenParenToken.IsEquivalentTo(wrapper.OpenParenToken));
43+
Assert.Same(syntaxNode.Arguments[0], wrapper.Arguments[0]);
44+
Assert.True(syntaxNode.CloseParenToken.IsEquivalentTo(wrapper.CloseParenToken));
45+
46+
var newOpenParenToken = SyntaxFactory.Token(SyntaxKind.OpenParenToken).WithLeadingTrivia(SyntaxFactory.Space);
47+
var wrapperWithModifiedOpenParenToken = wrapper.WithOpenParenToken(newOpenParenToken);
48+
Assert.NotNull(wrapperWithModifiedOpenParenToken.SyntaxNode);
49+
Assert.Equal(1, wrapperWithModifiedOpenParenToken.OpenParenToken.LeadingTrivia.Count);
50+
Assert.Equal(" ", wrapperWithModifiedOpenParenToken.OpenParenToken.LeadingTrivia.ToString());
51+
52+
var newArguments = wrapper.Arguments.Replace(wrapper.Arguments[0], SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
53+
var wrapperWithModifiedArguments = wrapper.WithArguments(newArguments);
54+
Assert.NotNull(wrapperWithModifiedArguments.SyntaxNode);
55+
Assert.NotSame(syntaxNode.Arguments[0], wrapperWithModifiedArguments.Arguments[0]);
56+
Assert.Equal(SyntaxKind.NullLiteralExpression, wrapperWithModifiedArguments.Arguments[0].Expression.Kind());
57+
58+
var newCloseParenToken = SyntaxFactory.Token(SyntaxKind.CloseParenToken).WithLeadingTrivia(SyntaxFactory.Space);
59+
var wrapperWithModifiedCloseParenToken = wrapper.WithCloseParenToken(newCloseParenToken);
60+
Assert.NotNull(wrapperWithModifiedCloseParenToken.SyntaxNode);
61+
Assert.Equal(1, wrapperWithModifiedCloseParenToken.CloseParenToken.LeadingTrivia.Count);
62+
Assert.Equal(" ", wrapperWithModifiedCloseParenToken.CloseParenToken.LeadingTrivia.ToString());
63+
}
64+
65+
[Fact]
66+
public void TestIsInstance()
67+
{
68+
Assert.False(TupleExpressionSyntaxWrapper.IsInstance(null));
69+
Assert.False(TupleExpressionSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
70+
71+
var syntaxNode = this.CreateTupleExpression();
72+
Assert.True(TupleExpressionSyntaxWrapper.IsInstance(syntaxNode));
73+
}
74+
75+
[Fact]
76+
public void TestConversionsNull()
77+
{
78+
var syntaxNode = default(SyntaxNode);
79+
var wrapper = (TupleExpressionSyntaxWrapper)syntaxNode;
80+
81+
ExpressionSyntax syntax = wrapper;
82+
Assert.Null(syntax);
83+
}
84+
85+
[Fact]
86+
public void TestConversions()
87+
{
88+
var syntaxNode = this.CreateTupleExpression();
89+
var wrapper = (TupleExpressionSyntaxWrapper)syntaxNode;
90+
91+
ExpressionSyntax syntax = wrapper;
92+
Assert.Same(syntaxNode, syntax);
93+
}
94+
95+
[Fact]
96+
public void TestInvalidConversion()
97+
{
98+
var syntaxNode = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
99+
Assert.Throws<InvalidCastException>(() => (TupleExpressionSyntaxWrapper)syntaxNode);
100+
}
101+
102+
private TupleExpressionSyntax CreateTupleExpression()
103+
{
104+
return SyntaxFactory.TupleExpression(
105+
SyntaxFactory.SeparatedList(
106+
ImmutableArray.Create(
107+
SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)),
108+
SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression)))));
109+
}
110+
}
111+
}

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

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -285,6 +285,7 @@
285285
<Compile Include="Lightup\SingleVariableDesignationSyntaxWrapperTests.cs" />
286286
<Compile Include="Lightup\SyntaxWrapperTests.cs" />
287287
<Compile Include="Lightup\ThrowExpressionSyntaxWrapperTests.cs" />
288+
<Compile Include="Lightup\TupleExpressionSyntaxWrapperTests.cs" />
288289
<Compile Include="Lightup\TupleTypeSyntaxWrapperTests.cs" />
289290
<Compile Include="Lightup\VariableDesignationSyntaxWrapperTests.cs" />
290291
<Compile Include="Lightup\WhenClauseSyntaxWrapperTests.cs" />

‎StyleCop.Analyzers/StyleCop.Analyzers.Test/Lightup/TupleExpressionSyntaxWrapperTests.cs‎

Lines changed: 57 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,57 @@
1+
// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
2+
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.
3+
4+
namespace StyleCop.Analyzers.Test.Lightup
5+
{
6+
using System;
7+
using System.Collections.Immutable;
8+
using Microsoft.CodeAnalysis;
9+
using Microsoft.CodeAnalysis.CSharp;
10+
using Microsoft.CodeAnalysis.CSharp.Syntax;
11+
using StyleCop.Analyzers.Lightup;
12+
using Xunit;
13+
14+
public class TupleExpressionSyntaxWrapperTests
15+
{
16+
[Fact]
17+
public void TestNull()
18+
{
19+
var syntaxNode = default(SyntaxNode);
20+
var wrapper = (TupleExpressionSyntaxWrapper)syntaxNode;
21+
Assert.Null(wrapper.SyntaxNode);
22+
Assert.Throws<NullReferenceException>(() => wrapper.OpenParenToken);
23+
Assert.Throws<NullReferenceException>(() => wrapper.Arguments);
24+
Assert.Throws<NullReferenceException>(() => wrapper.CloseParenToken);
25+
Assert.Throws<NullReferenceException>(() => wrapper.WithOpenParenToken(SyntaxFactory.Token(SyntaxKind.OpenParenToken)));
26+
Assert.Throws<NullReferenceException>(() => wrapper.WithArguments(SyntaxFactory.SeparatedList(
27+
ImmutableArray.Create(
28+
SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)),
29+
SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression))))));
30+
Assert.Throws<NullReferenceException>(() => wrapper.WithCloseParenToken(SyntaxFactory.Token(SyntaxKind.CloseParenToken)));
31+
}
32+
33+
[Fact]
34+
public void TestIsInstance()
35+
{
36+
Assert.False(TupleExpressionSyntaxWrapper.IsInstance(null));
37+
Assert.False(TupleExpressionSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
38+
}
39+
40+
[Fact]
41+
public void TestConversionsNull()
42+
{
43+
var syntaxNode = default(SyntaxNode);
44+
var wrapper = (TupleExpressionSyntaxWrapper)syntaxNode;
45+
46+
ExpressionSyntax syntax = wrapper;
47+
Assert.Null(syntax);
48+
}
49+
50+
[Fact]
51+
public void TestInvalidConversion()
52+
{
53+
var syntaxNode = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
54+
Assert.Throws<InvalidCastException>(() => (TupleExpressionSyntaxWrapper)syntaxNode);
55+
}
56+
}
57+
}

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

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -266,6 +266,7 @@
266266
<Compile Include="Lightup\SingleVariableDesignationSyntaxWrapperTests.cs" />
267267
<Compile Include="Lightup\SyntaxWrapperTests.cs" />
268268
<Compile Include="Lightup\ThrowExpressionSyntaxWrapperTests.cs" />
269+
<Compile Include="Lightup\TupleExpressionSyntaxWrapperTests.cs" />
269270
<Compile Include="Lightup\TupleTypeSyntaxWrapperTests.cs" />
270271
<Compile Include="Lightup\UnsupportedSyntaxListTests.cs" />
271272
<Compile Include="Lightup\VariableDesignationSyntaxWrapperTests.cs" />

0 commit comments

Comments
 (0)