Skip to content

Commit b17aa80

Browse files
sharwellsharwell
committed
Add tests for the new lightup layer features
1 parent f335340 commit b17aa80

17 files changed

Lines changed: 451 additions & 5 deletions

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

Lines changed: 33 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
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 Microsoft.CodeAnalysis.CSharp;
7+
using StyleCop.Analyzers.Lightup;
8+
using Xunit;
9+
10+
public class ArgumentSyntaxExtensionsTests
11+
{
12+
[Fact]
13+
public void TestRefKindKeyword()
14+
{
15+
var argumentSyntax = SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))
16+
.WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.InKeyword));
17+
Assert.Equal(argumentSyntax.RefKindKeyword, ArgumentSyntaxExtensions.RefKindKeyword(argumentSyntax));
18+
Assert.Equal(argumentSyntax.RefOrOutKeyword, ArgumentSyntaxExtensions.RefKindKeyword(argumentSyntax));
19+
}
20+
21+
[Fact]
22+
public void TestWithRefKindKeyword()
23+
{
24+
var argumentSyntax = SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression));
25+
26+
var refKindKeyword = SyntaxFactory.Token(SyntaxKind.InKeyword);
27+
Assert.Equal(default, ArgumentSyntaxExtensions.RefKindKeyword(argumentSyntax));
28+
var argumentWithInKeyword = ArgumentSyntaxExtensions.WithRefKindKeyword(argumentSyntax, refKindKeyword);
29+
Assert.NotNull(argumentWithInKeyword);
30+
Assert.True(refKindKeyword.IsEquivalentTo(argumentWithInKeyword.RefKindKeyword));
31+
}
32+
}
33+
}

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

Lines changed: 33 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
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 Microsoft.CodeAnalysis.CSharp;
7+
using StyleCop.Analyzers.Lightup;
8+
using Xunit;
9+
10+
public class CrefParameterSyntaxExtensionsTests
11+
{
12+
[Fact]
13+
public void TestRefKindKeyword()
14+
{
15+
var crefParameterSyntax = SyntaxFactory.CrefParameter(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)))
16+
.WithRefKindKeyword(SyntaxFactory.Token(SyntaxKind.InKeyword));
17+
Assert.Equal(crefParameterSyntax.RefKindKeyword, CrefParameterSyntaxExtensions.RefKindKeyword(crefParameterSyntax));
18+
Assert.Equal(crefParameterSyntax.RefOrOutKeyword, CrefParameterSyntaxExtensions.RefKindKeyword(crefParameterSyntax));
19+
}
20+
21+
[Fact]
22+
public void TestWithRefKindKeyword()
23+
{
24+
var crefParameterSyntax = SyntaxFactory.CrefParameter(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)));
25+
26+
var refKindKeyword = SyntaxFactory.Token(SyntaxKind.InKeyword);
27+
Assert.Equal(default, CrefParameterSyntaxExtensions.RefKindKeyword(crefParameterSyntax));
28+
var crefParameterWithInKeyword = CrefParameterSyntaxExtensions.WithRefKindKeyword(crefParameterSyntax, refKindKeyword);
29+
Assert.NotNull(crefParameterWithInKeyword);
30+
Assert.True(refKindKeyword.IsEquivalentTo(crefParameterWithInKeyword.RefKindKeyword));
31+
}
32+
}
33+
}

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

Lines changed: 130 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,130 @@
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 ImplicitStackAllocArrayCreationExpressionSyntaxWrapperTests
14+
{
15+
[Fact]
16+
public void TestNull()
17+
{
18+
var syntaxNode = default(SyntaxNode);
19+
var wrapper = (ImplicitStackAllocArrayCreationExpressionSyntaxWrapper)syntaxNode;
20+
Assert.Null(wrapper.SyntaxNode);
21+
Assert.Throws<NullReferenceException>(() => wrapper.StackAllocKeyword);
22+
Assert.Throws<NullReferenceException>(() => wrapper.OpenBracketToken);
23+
Assert.Throws<NullReferenceException>(() => wrapper.CloseBracketToken);
24+
Assert.Throws<NullReferenceException>(() => wrapper.Initializer);
25+
Assert.Throws<NullReferenceException>(() => wrapper.WithStackAllocKeyword(SyntaxFactory.Token(SyntaxKind.StackAllocKeyword)));
26+
Assert.Throws<NullReferenceException>(() => wrapper.WithOpenBracketToken(SyntaxFactory.Token(SyntaxKind.OpenBracketToken)));
27+
Assert.Throws<NullReferenceException>(() => wrapper.WithCloseBracketToken(SyntaxFactory.Token(SyntaxKind.CloseBracketToken)));
28+
Assert.Throws<NullReferenceException>(() => wrapper.WithInitializer(SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression)));
29+
Assert.Throws<NullReferenceException>(() => wrapper.AddInitializerExpressions());
30+
}
31+
32+
[Fact]
33+
public void TestProperties()
34+
{
35+
var syntaxNode = this.CreateImplicitStackAllocArrayCreationExpression();
36+
Assert.True(syntaxNode.IsKind(SyntaxKind.ImplicitStackAllocArrayCreationExpression));
37+
Assert.True(syntaxNode.IsKind(SyntaxKindEx.ImplicitStackAllocArrayCreationExpression));
38+
39+
var wrapper = (ImplicitStackAllocArrayCreationExpressionSyntaxWrapper)syntaxNode;
40+
Assert.Same(syntaxNode, wrapper.SyntaxNode);
41+
Assert.Equal(syntaxNode.StackAllocKeyword, wrapper.StackAllocKeyword); // This is a struct, so we can't use Same()
42+
Assert.Equal(syntaxNode.OpenBracketToken, wrapper.OpenBracketToken); // This is a struct, so we can't use Same()
43+
Assert.Equal(syntaxNode.CloseBracketToken, wrapper.CloseBracketToken); // This is a struct, so we can't use Same()
44+
Assert.Same(syntaxNode.Initializer, wrapper.Initializer);
45+
46+
var newStackAllocKeyword = SyntaxFactory.Token(SyntaxKind.StackAllocKeyword);
47+
var wrapperWithModifiedStackAllocKeyword = wrapper.WithStackAllocKeyword(newStackAllocKeyword);
48+
Assert.NotNull(wrapperWithModifiedStackAllocKeyword.SyntaxNode);
49+
Assert.NotEqual(syntaxNode.StackAllocKeyword, wrapperWithModifiedStackAllocKeyword.StackAllocKeyword);
50+
Assert.Equal(SyntaxKind.StackAllocKeyword, wrapperWithModifiedStackAllocKeyword.StackAllocKeyword.Kind());
51+
Assert.Equal("stackalloc", wrapperWithModifiedStackAllocKeyword.StackAllocKeyword.Text);
52+
53+
var newOpenBracketToken = SyntaxFactory.Token(SyntaxKind.OpenBracketToken);
54+
var wrapperWithModifiedOpenBracketToken = wrapper.WithOpenBracketToken(newOpenBracketToken);
55+
Assert.NotNull(wrapperWithModifiedOpenBracketToken.SyntaxNode);
56+
Assert.NotEqual(syntaxNode.OpenBracketToken, wrapperWithModifiedOpenBracketToken.OpenBracketToken);
57+
Assert.Equal(SyntaxKind.OpenBracketToken, wrapperWithModifiedOpenBracketToken.OpenBracketToken.Kind());
58+
Assert.Equal("[", wrapperWithModifiedOpenBracketToken.OpenBracketToken.Text);
59+
60+
var newCloseBracketToken = SyntaxFactory.Token(SyntaxKind.CloseBracketToken);
61+
var wrapperWithModifiedCloseBracketToken = wrapper.WithCloseBracketToken(newCloseBracketToken);
62+
Assert.NotNull(wrapperWithModifiedCloseBracketToken.SyntaxNode);
63+
Assert.NotEqual(syntaxNode.CloseBracketToken, wrapperWithModifiedCloseBracketToken.CloseBracketToken);
64+
Assert.Equal(SyntaxKind.CloseBracketToken, wrapperWithModifiedCloseBracketToken.CloseBracketToken.Kind());
65+
Assert.Equal("]", wrapperWithModifiedCloseBracketToken.CloseBracketToken.Text);
66+
67+
var newInitializer = SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression);
68+
var wrapperWithModifiedInitializer = wrapper.WithInitializer(newInitializer);
69+
Assert.NotNull(wrapperWithModifiedInitializer.SyntaxNode);
70+
Assert.NotSame(syntaxNode.Initializer, wrapperWithModifiedInitializer.Initializer);
71+
Assert.Empty(wrapperWithModifiedInitializer.Initializer.Expressions);
72+
73+
var addedInitializerExpressions = new ExpressionSyntax[] { SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(2)) };
74+
var wrapperWithAddedInitializerExpressions = wrapper.AddInitializerExpressions(addedInitializerExpressions);
75+
Assert.NotNull(wrapperWithAddedInitializerExpressions.SyntaxNode);
76+
Assert.NotSame(syntaxNode.Initializer, wrapperWithAddedInitializerExpressions.Initializer);
77+
Assert.Equal(2, wrapperWithAddedInitializerExpressions.Initializer.Expressions.Count);
78+
Assert.Equal("1", wrapperWithAddedInitializerExpressions.Initializer.Expressions[0].ToString());
79+
Assert.Equal("2", wrapperWithAddedInitializerExpressions.Initializer.Expressions[1].ToString());
80+
}
81+
82+
[Fact]
83+
public void TestIsInstance()
84+
{
85+
Assert.False(ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.IsInstance(null));
86+
Assert.False(ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.IsInstance(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
87+
88+
var syntaxNode = this.CreateImplicitStackAllocArrayCreationExpression();
89+
Assert.True(ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.IsInstance(syntaxNode));
90+
}
91+
92+
[Fact]
93+
public void TestConversionsNull()
94+
{
95+
var syntaxNode = default(SyntaxNode);
96+
var wrapper = (ImplicitStackAllocArrayCreationExpressionSyntaxWrapper)syntaxNode;
97+
98+
ExpressionSyntax syntax = wrapper;
99+
Assert.Null(syntax);
100+
}
101+
102+
[Fact]
103+
public void TestConversions()
104+
{
105+
var syntaxNode = this.CreateImplicitStackAllocArrayCreationExpression();
106+
var wrapper = (ImplicitStackAllocArrayCreationExpressionSyntaxWrapper)syntaxNode;
107+
108+
ExpressionSyntax syntax = wrapper;
109+
Assert.Same(syntaxNode, syntax);
110+
}
111+
112+
[Fact]
113+
public void TestInvalidConversion()
114+
{
115+
var syntaxNode = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
116+
Assert.Throws<InvalidCastException>(() => (ImplicitStackAllocArrayCreationExpressionSyntaxWrapper)syntaxNode);
117+
}
118+
119+
private ImplicitStackAllocArrayCreationExpressionSyntax CreateImplicitStackAllocArrayCreationExpression()
120+
{
121+
return SyntaxFactory.ImplicitStackAllocArrayCreationExpression(
122+
stackAllocKeyword: SyntaxFactory.Token(SyntaxKind.StackAllocKeyword),
123+
openBracketToken: SyntaxFactory.Token(SyntaxKind.OpenBracketToken),
124+
closeBracketToken: SyntaxFactory.Token(SyntaxKind.CloseBracketToken),
125+
initializer: SyntaxFactory.InitializerExpression(
126+
SyntaxKind.ArrayInitializerExpression,
127+
SyntaxFactory.SingletonSeparatedList<ExpressionSyntax>(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)))));
128+
}
129+
}
130+
}

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

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -19,9 +19,11 @@ public void TestNull()
1919
var wrapper = (RefTypeSyntaxWrapper)syntaxNode;
2020
Assert.Null(wrapper.SyntaxNode);
2121
Assert.Throws<NullReferenceException>(() => wrapper.RefKeyword);
22+
Assert.Throws<NullReferenceException>(() => wrapper.ReadOnlyKeyword);
2223
Assert.Throws<NullReferenceException>(() => wrapper.Type);
2324
Assert.Throws<NullReferenceException>(() => wrapper.WithType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword))));
2425
Assert.Throws<NullReferenceException>(() => wrapper.WithRefKeyword(SyntaxFactory.Token(SyntaxKind.RefKeyword)));
26+
Assert.Throws<NullReferenceException>(() => wrapper.WithReadOnlyKeyword(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)));
2527
}
2628

2729
[Fact]
@@ -35,6 +37,7 @@ public void TestProperties()
3537
Assert.Same(syntaxNode, wrapper.SyntaxNode);
3638
Assert.Same(syntaxNode.Type, wrapper.Type);
3739
Assert.True(syntaxNode.RefKeyword.IsEquivalentTo(wrapper.RefKeyword));
40+
Assert.Equal(default, syntaxNode.ReadOnlyKeyword);
3841

3942
var newType = SyntaxFactory.PointerType(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword)));
4043
var wrapperWithModifiedType = wrapper.WithType(newType);
@@ -47,6 +50,13 @@ public void TestProperties()
4750
Assert.NotNull(wrapperWithModifiedRefKeyword.SyntaxNode);
4851
Assert.Single(wrapperWithModifiedRefKeyword.RefKeyword.LeadingTrivia);
4952
Assert.Equal(" ", wrapperWithModifiedRefKeyword.RefKeyword.LeadingTrivia.ToString());
53+
54+
var readOnlyKeyword = SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword).WithLeadingTrivia(SyntaxFactory.Space);
55+
var wrapperWithReadOnlyKeyword = wrapper.WithReadOnlyKeyword(readOnlyKeyword);
56+
Assert.NotNull(wrapperWithReadOnlyKeyword.SyntaxNode);
57+
Assert.Single(wrapperWithReadOnlyKeyword.ReadOnlyKeyword.LeadingTrivia);
58+
Assert.Equal(" ", wrapperWithReadOnlyKeyword.ReadOnlyKeyword.LeadingTrivia.ToString());
59+
Assert.True(wrapperWithReadOnlyKeyword.ReadOnlyKeyword.IsEquivalentTo(readOnlyKeyword));
5060
}
5161

5262
[Fact]

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

Lines changed: 38 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
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 Microsoft.CodeAnalysis.CSharp;
7+
using StyleCop.Analyzers.Lightup;
8+
using Xunit;
9+
10+
public class StackAllocArrayCreationExpressionSyntaxExtensionsTests
11+
{
12+
[Fact]
13+
public void TestInitializer()
14+
{
15+
var stackAllocSyntax = SyntaxFactory.StackAllocArrayCreationExpression(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)))
16+
.WithInitializer(SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression));
17+
Assert.NotNull(StackAllocArrayCreationExpressionSyntaxExtensions.Initializer(stackAllocSyntax));
18+
Assert.Equal(SyntaxKind.ArrayInitializerExpression, StackAllocArrayCreationExpressionSyntaxExtensions.Initializer(stackAllocSyntax).Kind());
19+
}
20+
21+
[Fact]
22+
public void TestWithInitializer()
23+
{
24+
var stackAllocSyntax = SyntaxFactory.StackAllocArrayCreationExpression(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)));
25+
26+
// With default value is allowed
27+
var stackAllocWithDefaultInitializer = StackAllocArrayCreationExpressionSyntaxExtensions.WithInitializer(stackAllocSyntax, null);
28+
Assert.Null(StackAllocArrayCreationExpressionSyntaxExtensions.Initializer(stackAllocWithDefaultInitializer));
29+
30+
// Non-default throws an exception
31+
var initializer = SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression);
32+
var stackAllocWithInitializer = StackAllocArrayCreationExpressionSyntaxExtensions.WithInitializer(stackAllocSyntax, initializer);
33+
Assert.NotNull(stackAllocWithInitializer.Initializer);
34+
Assert.Equal(SyntaxKind.ArrayInitializerExpression, stackAllocWithInitializer.Initializer.Kind());
35+
Assert.True(stackAllocWithInitializer.Initializer.IsEquivalentTo(initializer));
36+
}
37+
}
38+
}

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

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@
1717
</PropertyGroup>
1818

1919
<ItemGroup>
20-
<PackageReference Include="Microsoft.CodeAnalysis" Version="2.6.0" />
20+
<PackageReference Include="Microsoft.CodeAnalysis" Version="2.8.2" />
2121
<PackageReference Include="xunit" Version="2.3.1" />
2222
<PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" PrivateAssets="all" />
2323
</ItemGroup>

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

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
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.CSharp;
8+
using StyleCop.Analyzers.Lightup;
9+
using Xunit;
10+
11+
public class ArgumentSyntaxExtensionsTests
12+
{
13+
[Fact]
14+
public void TestRefKindKeyword()
15+
{
16+
var argumentSyntax = SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression));
17+
Assert.Equal(default, ArgumentSyntaxExtensions.RefKindKeyword(argumentSyntax));
18+
}
19+
20+
[Fact]
21+
public void TestWithRefKindKeyword()
22+
{
23+
var argumentSyntax = SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression));
24+
25+
// With default value is allowed
26+
var argumentWithDefaultRefKind = ArgumentSyntaxExtensions.WithRefKindKeyword(argumentSyntax, default);
27+
Assert.Equal(default, ArgumentSyntaxExtensions.RefKindKeyword(argumentWithDefaultRefKind));
28+
29+
// Non-default throws an exception
30+
var refKind = SyntaxFactory.Token(SyntaxKind.RefKeyword);
31+
Assert.Throws<NotSupportedException>(() => ArgumentSyntaxExtensions.WithRefKindKeyword(argumentSyntax, refKind));
32+
}
33+
}
34+
}

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

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
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.CSharp;
8+
using StyleCop.Analyzers.Lightup;
9+
using Xunit;
10+
11+
public class CrefParameterSyntaxExtensionsTests
12+
{
13+
[Fact]
14+
public void TestRefKindKeyword()
15+
{
16+
var crefParameterSyntax = SyntaxFactory.CrefParameter(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)));
17+
Assert.Equal(default, CrefParameterSyntaxExtensions.RefKindKeyword(crefParameterSyntax));
18+
}
19+
20+
[Fact]
21+
public void TestWithRefKindKeyword()
22+
{
23+
var crefParameterSyntax = SyntaxFactory.CrefParameter(SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)));
24+
25+
// With default value is allowed
26+
var crefParameterWithDefaultRefKind = CrefParameterSyntaxExtensions.WithRefKindKeyword(crefParameterSyntax, default);
27+
Assert.Equal(default, CrefParameterSyntaxExtensions.RefKindKeyword(crefParameterWithDefaultRefKind));
28+
29+
// Non-default throws an exception
30+
var refKind = SyntaxFactory.Token(SyntaxKind.RefKeyword);
31+
Assert.Throws<NotSupportedException>(() => CrefParameterSyntaxExtensions.WithRefKindKeyword(crefParameterSyntax, refKind));
32+
}
33+
}
34+
}

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

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
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 StyleCop.Analyzers.Lightup;
9+
using Xunit;
10+
11+
public class INamedTypeSymbolExtensionsTests
12+
{
13+
[Fact]
14+
public void TestNull()
15+
{
16+
INamedTypeSymbol symbol = null;
17+
Assert.Throws<NullReferenceException>(() => INamedTypeSymbolExtensions.IsSerializable(symbol));
18+
Assert.Throws<NullReferenceException>(() => INamedTypeSymbolExtensions.TupleElements(symbol));
19+
Assert.Throws<NullReferenceException>(() => INamedTypeSymbolExtensions.TupleUnderlyingType(symbol));
20+
}
21+
}
22+
}

0 commit comments

Comments
 (0)