Skip to content

Commit 0a556b2

Browse files
sharwellsharwell
committed
Add tests for ConstantPatternSyntaxWrapper
1 parent 137e535 commit 0a556b2

5 files changed

Lines changed: 172 additions & 14 deletions

File tree

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

Lines changed: 87 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,87 @@
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 StyleCop.Analyzers.Lightup;
10+
using Xunit;
11+
12+
public class ConstantPatternSyntaxWrapperTests
13+
{
14+
[Fact]
15+
public void TestNull()
16+
{
17+
var syntaxNode = default(SyntaxNode);
18+
var constantPatternSyntax = (ConstantPatternSyntaxWrapper)syntaxNode;
19+
Assert.Null(constantPatternSyntax.SyntaxNode);
20+
Assert.Throws<NullReferenceException>(() => constantPatternSyntax.Expression);
21+
Assert.Throws<NullReferenceException>(() => constantPatternSyntax.WithExpression(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
22+
}
23+
24+
[Fact]
25+
public void TestExpression()
26+
{
27+
var syntaxNode = SyntaxFactory.ConstantPattern(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression));
28+
var constantPatternSyntax = (ConstantPatternSyntaxWrapper)syntaxNode;
29+
Assert.Same(syntaxNode, constantPatternSyntax.SyntaxNode);
30+
Assert.Same(syntaxNode.Expression, constantPatternSyntax.Expression);
31+
32+
constantPatternSyntax = constantPatternSyntax.WithExpression(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)));
33+
Assert.NotNull(constantPatternSyntax.SyntaxNode);
34+
Assert.NotSame(syntaxNode, constantPatternSyntax.SyntaxNode);
35+
Assert.Equal(SyntaxKind.NumericLiteralExpression, constantPatternSyntax.Expression.Kind());
36+
}
37+
38+
[Fact]
39+
public void TestIsInstance()
40+
{
41+
Assert.False(ConstantPatternSyntaxWrapper.IsInstance(null));
42+
Assert.False(ConstantPatternSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
43+
44+
var syntaxNode = SyntaxFactory.ConstantPattern(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression));
45+
Assert.True(ConstantPatternSyntaxWrapper.IsInstance(syntaxNode));
46+
}
47+
48+
[Fact]
49+
public void TestConversionsNull()
50+
{
51+
var syntaxNode = default(SyntaxNode);
52+
var constantPatternSyntax = (ConstantPatternSyntaxWrapper)syntaxNode;
53+
54+
PatternSyntaxWrapper patternSyntax = constantPatternSyntax;
55+
Assert.Null(patternSyntax.SyntaxNode);
56+
57+
constantPatternSyntax = (ConstantPatternSyntaxWrapper)patternSyntax;
58+
Assert.Null(constantPatternSyntax.SyntaxNode);
59+
60+
SyntaxNode syntax = constantPatternSyntax;
61+
Assert.Null(syntax);
62+
}
63+
64+
[Fact]
65+
public void TestConversions()
66+
{
67+
var syntaxNode = SyntaxFactory.ConstantPattern(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression));
68+
var constantPatternSyntax = (ConstantPatternSyntaxWrapper)syntaxNode;
69+
70+
PatternSyntaxWrapper patternSyntax = constantPatternSyntax;
71+
Assert.Same(syntaxNode, patternSyntax.SyntaxNode);
72+
73+
constantPatternSyntax = (ConstantPatternSyntaxWrapper)patternSyntax;
74+
Assert.Same(syntaxNode, constantPatternSyntax.SyntaxNode);
75+
76+
SyntaxNode syntax = constantPatternSyntax;
77+
Assert.Same(syntaxNode, syntax);
78+
}
79+
80+
[Fact]
81+
public void TestInvalidConversion()
82+
{
83+
var syntaxNode = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
84+
Assert.Throws<InvalidCastException>(() => (ConstantPatternSyntaxWrapper)syntaxNode);
85+
}
86+
}
87+
}

‎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
@@ -196,6 +196,7 @@
196196
<ItemGroup>
197197
<Compile Include="Lightup\AccessorDeclarationSyntaxExtensionsTests.cs" />
198198
<Compile Include="Lightup\BaseMethodDeclarationSyntaxExtensionsTests.cs" />
199+
<Compile Include="Lightup\ConstantPatternSyntaxWrapperTests.cs" />
199200
<Compile Include="Lightup\ConstructorDeclarationSyntaxExtensionsTests.cs" />
200201
<Compile Include="Lightup\DestructorDeclarationSyntaxExtensionsTests.cs" />
201202
<Compile Include="Properties\AssemblyInfo.cs" />

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

Lines changed: 54 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,54 @@
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 Microsoft.CodeAnalysis;
8+
using Microsoft.CodeAnalysis.CSharp;
9+
using StyleCop.Analyzers.Lightup;
10+
using Xunit;
11+
12+
public class ConstantPatternSyntaxWrapperTests
13+
{
14+
[Fact]
15+
public void TestNull()
16+
{
17+
var syntaxNode = default(SyntaxNode);
18+
var constantPatternSyntax = (ConstantPatternSyntaxWrapper)syntaxNode;
19+
Assert.Null(constantPatternSyntax.SyntaxNode);
20+
Assert.Throws<NullReferenceException>(() => constantPatternSyntax.Expression);
21+
Assert.Throws<NullReferenceException>(() => constantPatternSyntax.WithExpression(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
22+
}
23+
24+
[Fact]
25+
public void TestIsInstance()
26+
{
27+
Assert.False(ConstantPatternSyntaxWrapper.IsInstance(null));
28+
Assert.False(ConstantPatternSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
29+
}
30+
31+
[Fact]
32+
public void TestConversionsNull()
33+
{
34+
var syntaxNode = default(SyntaxNode);
35+
var constantPatternSyntax = (ConstantPatternSyntaxWrapper)syntaxNode;
36+
37+
PatternSyntaxWrapper patternSyntax = constantPatternSyntax;
38+
Assert.Null(patternSyntax.SyntaxNode);
39+
40+
constantPatternSyntax = (ConstantPatternSyntaxWrapper)patternSyntax;
41+
Assert.Null(constantPatternSyntax.SyntaxNode);
42+
43+
SyntaxNode syntax = constantPatternSyntax;
44+
Assert.Null(syntax);
45+
}
46+
47+
[Fact]
48+
public void TestInvalidConversion()
49+
{
50+
var syntaxNode = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
51+
Assert.Throws<InvalidCastException>(() => (ConstantPatternSyntaxWrapper)syntaxNode);
52+
}
53+
}
54+
}

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

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -237,6 +237,7 @@
237237
<Compile Include="LayoutRules\SA1520UnitTests.cs" />
238238
<Compile Include="Lightup\AccessorDeclarationSyntaxExtensionsTests.cs" />
239239
<Compile Include="Lightup\BaseMethodDeclarationSyntaxExtensionsTests.cs" />
240+
<Compile Include="Lightup\ConstantPatternSyntaxWrapperTests.cs" />
240241
<Compile Include="Lightup\ConstructorDeclarationSyntaxExtensionsTests.cs" />
241242
<Compile Include="Lightup\DestructorDeclarationSyntaxExtensionsTests.cs" />
242243
<Compile Include="LinqHelpers\SyntaxTriviaListEnumerableTests.cs" />

‎StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LightupHelpers.cs‎

Lines changed: 29 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -49,9 +49,22 @@ internal static bool CanWrapNode(SyntaxNode node, Type underlyingType)
4949

5050
internal static Func<TSyntax, TProperty> CreateSyntaxPropertyAccessor<TSyntax, TProperty>(Type type, string propertyName)
5151
{
52+
Func<TSyntax, TProperty> fallbackAccessor =
53+
syntax =>
54+
{
55+
if (syntax == null)
56+
{
57+
// Unlike an extension method which would throw ArgumentNullException here, the light-up
58+
// behavior needs to match behavior of the underlying property.
59+
throw new NullReferenceException();
60+
}
61+
62+
return default(TProperty);
63+
};
64+
5265
if (type == null)
5366
{
54-
return syntax => default(TProperty);
67+
return fallbackAccessor;
5568
}
5669

5770
if (!typeof(TSyntax).GetTypeInfo().IsAssignableFrom(type.GetTypeInfo()))
@@ -62,7 +75,7 @@ internal static Func<TSyntax, TProperty> CreateSyntaxPropertyAccessor<TSyntax, T
6275
var property = type.GetTypeInfo().GetDeclaredProperty(propertyName);
6376
if (property == null)
6477
{
65-
return syntax => default(TProperty);
78+
return fallbackAccessor;
6679
}
6780

6881
if (!typeof(TProperty).GetTypeInfo().IsAssignableFrom(property.PropertyType.GetTypeInfo()))
@@ -85,17 +98,27 @@ internal static Func<TSyntax, TProperty> CreateSyntaxPropertyAccessor<TSyntax, T
8598

8699
internal static Func<TSyntax, TProperty, TSyntax> CreateSyntaxWithPropertyAccessor<TSyntax, TProperty>(Type type, string propertyName)
87100
{
88-
if (type == null)
89-
{
90-
return (syntax, newValue) =>
101+
Func<TSyntax, TProperty, TSyntax> fallbackAccessor =
102+
(syntax, newValue) =>
91103
{
104+
if (syntax == null)
105+
{
106+
// Unlike an extension method which would throw ArgumentNullException here, the light-up
107+
// behavior needs to match behavior of the underlying property.
108+
throw new NullReferenceException();
109+
}
110+
92111
if (Equals(newValue, default(TProperty)))
93112
{
94113
return syntax;
95114
}
96115

97116
throw new NotSupportedException();
98117
};
118+
119+
if (type == null)
120+
{
121+
return fallbackAccessor;
99122
}
100123

101124
if (!typeof(TSyntax).GetTypeInfo().IsAssignableFrom(type.GetTypeInfo()))
@@ -106,15 +129,7 @@ internal static Func<TSyntax, TProperty, TSyntax> CreateSyntaxWithPropertyAccess
106129
var property = type.GetTypeInfo().GetDeclaredProperty(propertyName);
107130
if (property == null)
108131
{
109-
return (syntax, newValue) =>
110-
{
111-
if (Equals(newValue, default(TProperty)))
112-
{
113-
return syntax;
114-
}
115-
116-
throw new NotSupportedException();
117-
};
132+
return fallbackAccessor;
118133
}
119134

120135
if (!typeof(TProperty).GetTypeInfo().IsAssignableFrom(property.PropertyType.GetTypeInfo()))

0 commit comments

Comments
 (0)