Skip to content

Commit 573011e

Browse files
sharwellsharwell
authored
Merge pull request #2436 from sharwell/wrapper-tests
Add tests for additional C# 7 syntax wrapper types
2 parents ae0764a + 3e87755 commit 573011e

13 files changed

Lines changed: 810 additions & 6 deletions

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

Lines changed: 105 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,105 @@
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 Microsoft.CodeAnalysis;
8+
using Microsoft.CodeAnalysis.CSharp;
9+
using Microsoft.CodeAnalysis.CSharp.Syntax;
10+
using StyleCop.Analyzers.Lightup;
11+
using Xunit;
12+
13+
public class DeclarationExpressionSyntaxWrapperTests
14+
{
15+
[Fact]
16+
public void TestNull()
17+
{
18+
var syntaxNode = default(SyntaxNode);
19+
var declarationExpressionSyntax = (DeclarationExpressionSyntaxWrapper)syntaxNode;
20+
Assert.Null(declarationExpressionSyntax.SyntaxNode);
21+
Assert.Throws<NullReferenceException>(() => declarationExpressionSyntax.Type);
22+
Assert.Throws<NullReferenceException>(() => declarationExpressionSyntax.Designation);
23+
Assert.Throws<NullReferenceException>(() => declarationExpressionSyntax.WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword))));
24+
Assert.Throws<NullReferenceException>(() => declarationExpressionSyntax.WithDesignation((VariableDesignationSyntaxWrapper)SyntaxFactory.DiscardDesignation()));
25+
}
26+
27+
[Fact]
28+
public void TestProperties()
29+
{
30+
var syntaxNode = SyntaxFactory.DeclarationExpression(
31+
SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)),
32+
SyntaxFactory.DiscardDesignation());
33+
Assert.True(syntaxNode.IsKind(SyntaxKind.DeclarationExpression));
34+
Assert.True(syntaxNode.IsKind(SyntaxKindEx.DeclarationExpression));
35+
36+
var declarationExpressionSyntax = (DeclarationExpressionSyntaxWrapper)syntaxNode;
37+
Assert.Same(syntaxNode, declarationExpressionSyntax.SyntaxNode);
38+
Assert.Same(syntaxNode.Type, declarationExpressionSyntax.Type);
39+
Assert.Same(syntaxNode.Designation, declarationExpressionSyntax.Designation.SyntaxNode);
40+
41+
declarationExpressionSyntax = declarationExpressionSyntax.WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)));
42+
Assert.NotNull(declarationExpressionSyntax.SyntaxNode);
43+
Assert.NotSame(syntaxNode, declarationExpressionSyntax.SyntaxNode);
44+
Assert.Same(((DeclarationExpressionSyntax)declarationExpressionSyntax.SyntaxNode).Type, declarationExpressionSyntax.Type);
45+
46+
declarationExpressionSyntax = declarationExpressionSyntax.WithDesignation((VariableDesignationSyntaxWrapper)SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier("Anything")));
47+
Assert.NotNull(declarationExpressionSyntax.SyntaxNode);
48+
Assert.NotSame(syntaxNode, declarationExpressionSyntax.SyntaxNode);
49+
Assert.Same(((DeclarationExpressionSyntax)declarationExpressionSyntax.SyntaxNode).Designation, declarationExpressionSyntax.Designation.SyntaxNode);
50+
}
51+
52+
[Fact]
53+
public void TestIsInstance()
54+
{
55+
Assert.False(DeclarationExpressionSyntaxWrapper.IsInstance(null));
56+
Assert.False(DeclarationExpressionSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
57+
58+
var syntaxNode = SyntaxFactory.DeclarationExpression(
59+
SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)),
60+
SyntaxFactory.DiscardDesignation());
61+
Assert.True(DeclarationExpressionSyntaxWrapper.IsInstance(syntaxNode));
62+
}
63+
64+
[Fact]
65+
public void TestConversionsNull()
66+
{
67+
var syntaxNode = default(SyntaxNode);
68+
var declarationExpressionSyntax = (DeclarationExpressionSyntaxWrapper)syntaxNode;
69+
70+
ExpressionSyntax expressionSyntax = declarationExpressionSyntax;
71+
Assert.Null(expressionSyntax);
72+
73+
declarationExpressionSyntax = (DeclarationExpressionSyntaxWrapper)expressionSyntax;
74+
Assert.Null(declarationExpressionSyntax.SyntaxNode);
75+
76+
SyntaxNode syntax = declarationExpressionSyntax;
77+
Assert.Null(syntax);
78+
}
79+
80+
[Fact]
81+
public void TestConversions()
82+
{
83+
var syntaxNode = SyntaxFactory.DeclarationExpression(
84+
SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)),
85+
SyntaxFactory.DiscardDesignation());
86+
var declarationExpressionSyntax = (DeclarationExpressionSyntaxWrapper)syntaxNode;
87+
88+
ExpressionSyntax expressionSyntax = declarationExpressionSyntax;
89+
Assert.Same(syntaxNode, expressionSyntax);
90+
91+
declarationExpressionSyntax = (DeclarationExpressionSyntaxWrapper)expressionSyntax;
92+
Assert.Same(syntaxNode, declarationExpressionSyntax.SyntaxNode);
93+
94+
SyntaxNode syntax = declarationExpressionSyntax;
95+
Assert.Same(syntaxNode, syntax);
96+
}
97+
98+
[Fact]
99+
public void TestInvalidConversion()
100+
{
101+
var syntaxNode = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
102+
Assert.Throws<InvalidCastException>(() => (DeclarationExpressionSyntaxWrapper)syntaxNode);
103+
}
104+
}
105+
}

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

Lines changed: 94 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,94 @@
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 Microsoft.CodeAnalysis;
8+
using Microsoft.CodeAnalysis.CSharp;
9+
using Microsoft.CodeAnalysis.CSharp.Syntax;
10+
using StyleCop.Analyzers.Lightup;
11+
using Xunit;
12+
13+
public class RefExpressionSyntaxWrapperTests
14+
{
15+
[Fact]
16+
public void TestNull()
17+
{
18+
var syntaxNode = default(SyntaxNode);
19+
var wrapper = (RefExpressionSyntaxWrapper)syntaxNode;
20+
Assert.Null(wrapper.SyntaxNode);
21+
Assert.Throws<NullReferenceException>(() => wrapper.RefKeyword);
22+
Assert.Throws<NullReferenceException>(() => wrapper.Expression);
23+
Assert.Throws<NullReferenceException>(() => wrapper.WithExpression(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
24+
Assert.Throws<NullReferenceException>(() => wrapper.WithRefKeyword(SyntaxFactory.Token(SyntaxKind.RefKeyword)));
25+
}
26+
27+
[Fact]
28+
public void TestProperties()
29+
{
30+
var syntaxNode = this.CreateRefExpression();
31+
Assert.True(syntaxNode.IsKind(SyntaxKind.RefExpression));
32+
Assert.True(syntaxNode.IsKind(SyntaxKindEx.RefExpression));
33+
34+
var wrapper = (RefExpressionSyntaxWrapper)syntaxNode;
35+
Assert.Same(syntaxNode, wrapper.SyntaxNode);
36+
Assert.Same(syntaxNode.Expression, wrapper.Expression);
37+
Assert.True(syntaxNode.RefKeyword.IsEquivalentTo(wrapper.RefKeyword));
38+
39+
var newExpression = SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression);
40+
var wrapperWithModifiedExpression = wrapper.WithExpression(newExpression);
41+
Assert.NotNull(wrapperWithModifiedExpression.SyntaxNode);
42+
Assert.NotSame(syntaxNode.Expression, wrapperWithModifiedExpression.Expression);
43+
Assert.Equal(SyntaxKind.TrueLiteralExpression, wrapperWithModifiedExpression.Expression.Kind());
44+
45+
var newRefKeyword = SyntaxFactory.Token(SyntaxKind.RefKeyword).WithLeadingTrivia(SyntaxFactory.Space);
46+
var wrapperWithModifiedRefKeyword = wrapper.WithRefKeyword(newRefKeyword);
47+
Assert.NotNull(wrapperWithModifiedRefKeyword.SyntaxNode);
48+
Assert.Equal(1, wrapperWithModifiedRefKeyword.RefKeyword.LeadingTrivia.Count);
49+
Assert.Equal(" ", wrapperWithModifiedRefKeyword.RefKeyword.LeadingTrivia.ToString());
50+
}
51+
52+
[Fact]
53+
public void TestIsInstance()
54+
{
55+
Assert.False(RefExpressionSyntaxWrapper.IsInstance(null));
56+
Assert.False(RefExpressionSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
57+
58+
var syntaxNode = this.CreateRefExpression();
59+
Assert.True(RefExpressionSyntaxWrapper.IsInstance(syntaxNode));
60+
}
61+
62+
[Fact]
63+
public void TestConversionsNull()
64+
{
65+
var syntaxNode = default(SyntaxNode);
66+
var wrapper = (RefExpressionSyntaxWrapper)syntaxNode;
67+
68+
ExpressionSyntax syntax = wrapper;
69+
Assert.Null(syntax);
70+
}
71+
72+
[Fact]
73+
public void TestConversions()
74+
{
75+
var syntaxNode = this.CreateRefExpression();
76+
var wrapper = (RefExpressionSyntaxWrapper)syntaxNode;
77+
78+
ExpressionSyntax syntax = wrapper;
79+
Assert.Same(syntaxNode, syntax);
80+
}
81+
82+
[Fact]
83+
public void TestInvalidConversion()
84+
{
85+
var syntaxNode = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
86+
Assert.Throws<InvalidCastException>(() => (RefExpressionSyntaxWrapper)syntaxNode);
87+
}
88+
89+
private RefExpressionSyntax CreateRefExpression()
90+
{
91+
return SyntaxFactory.RefExpression(SyntaxFactory.Token(SyntaxKind.RefKeyword), SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression));
92+
}
93+
}
94+
}

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

Lines changed: 97 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,97 @@
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 TupleElementSyntaxWrapperTests
15+
{
16+
[Fact]
17+
public void TestNull()
18+
{
19+
var syntaxNode = default(SyntaxNode);
20+
var wrapper = (TupleElementSyntaxWrapper)syntaxNode;
21+
Assert.Null(wrapper.SyntaxNode);
22+
Assert.Throws<NullReferenceException>(() => wrapper.Type);
23+
Assert.Throws<NullReferenceException>(() => wrapper.Identifier);
24+
Assert.Throws<NullReferenceException>(() => wrapper.WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword))));
25+
Assert.Throws<NullReferenceException>(() => wrapper.WithIdentifier(SyntaxFactory.Identifier("x")));
26+
}
27+
28+
[Fact]
29+
public void TestProperties()
30+
{
31+
var syntaxNode = this.CreateTupleElement();
32+
Assert.True(syntaxNode.IsKind(SyntaxKind.TupleElement));
33+
Assert.True(syntaxNode.IsKind(SyntaxKindEx.TupleElement));
34+
35+
var wrapper = (TupleElementSyntaxWrapper)syntaxNode;
36+
Assert.Same(syntaxNode, wrapper.SyntaxNode);
37+
Assert.Same(syntaxNode.Type, wrapper.Type);
38+
Assert.True(syntaxNode.Identifier.IsEquivalentTo(wrapper.Identifier));
39+
40+
var newType = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.UIntKeyword));
41+
var wrapperWithModifiedType = wrapper.WithType(newType);
42+
Assert.NotNull(wrapperWithModifiedType.SyntaxNode);
43+
Assert.NotSame(syntaxNode.Type, wrapperWithModifiedType.Type);
44+
Assert.Equal(SyntaxKind.UIntKeyword, ((PredefinedTypeSyntax)wrapperWithModifiedType.Type).Keyword.Kind());
45+
46+
var newIdentifier = SyntaxFactory.Identifier("y").WithLeadingTrivia(SyntaxFactory.Space);
47+
var wrapperWithModifiedIdentifier = wrapper.WithIdentifier(newIdentifier);
48+
Assert.NotNull(wrapperWithModifiedIdentifier.SyntaxNode);
49+
Assert.Equal(1, wrapperWithModifiedIdentifier.Identifier.LeadingTrivia.Count);
50+
Assert.Equal(" ", wrapperWithModifiedIdentifier.Identifier.LeadingTrivia.ToString());
51+
}
52+
53+
[Fact]
54+
public void TestIsInstance()
55+
{
56+
Assert.False(TupleElementSyntaxWrapper.IsInstance(null));
57+
Assert.False(TupleElementSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
58+
59+
var syntaxNode = this.CreateTupleElement();
60+
Assert.True(TupleElementSyntaxWrapper.IsInstance(syntaxNode));
61+
}
62+
63+
[Fact]
64+
public void TestConversionsNull()
65+
{
66+
var syntaxNode = default(SyntaxNode);
67+
var wrapper = (TupleElementSyntaxWrapper)syntaxNode;
68+
69+
CSharpSyntaxNode syntax = wrapper;
70+
Assert.Null(syntax);
71+
}
72+
73+
[Fact]
74+
public void TestConversions()
75+
{
76+
var syntaxNode = this.CreateTupleElement();
77+
var wrapper = (TupleElementSyntaxWrapper)syntaxNode;
78+
79+
CSharpSyntaxNode syntax = wrapper;
80+
Assert.Same(syntaxNode, syntax);
81+
}
82+
83+
[Fact]
84+
public void TestInvalidConversion()
85+
{
86+
var syntaxNode = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
87+
Assert.Throws<InvalidCastException>(() => (TupleElementSyntaxWrapper)syntaxNode);
88+
}
89+
90+
private TupleElementSyntax CreateTupleElement()
91+
{
92+
return SyntaxFactory.TupleElement(
93+
SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)),
94+
SyntaxFactory.Identifier("id"));
95+
}
96+
}
97+
}

0 commit comments

Comments
 (0)