StyleCopAnalyzers/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp10/NamingRules/SA1300CSharp10UnitTests.cs at ac30b06e7e2315a734a0b43125dd59f666e04de2 · DotNetAnalyzers/StyleCopAnalyzers · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

#nullable disable

namespace StyleCop.Analyzers.Test.CSharp10.NamingRules
{
    using System.Threading;
    using System.Threading.Tasks;
    using Microsoft.CodeAnalysis.Testing;
    using StyleCop.Analyzers.Test.CSharp9.NamingRules;
    using Xunit;
    using static StyleCop.Analyzers.Test.Verifiers.StyleCopCodeFixVerifier<
        StyleCop.Analyzers.NamingRules.SA1300ElementMustBeginWithUpperCaseLetter,
        StyleCop.Analyzers.NamingRules.RenameToUpperCaseCodeFixProvider>;

    public partial class SA1300CSharp10UnitTests : SA1300CSharp9UnitTests
    {
        [Fact]
        public async Task TestUpperCaseFileScopedNamespaceAsync()
        {
            var testCode = @"namespace Test;";

            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
        }

        [Fact]
        public async Task TestLowerCaseFileScopedNamespaceAsync()
        {
            var testCode = @"namespace {|#0:test|};";

            var fixedCode = @"namespace Test;";

            DiagnosticResult expected = Diagnostic().WithArguments("test").WithLocation(0);
            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
        }

        [Fact]
        public async Task TestAllowedLowerCaseFileScopedNamespaceIsNotReportedAsync()
        {
            var customTestSettings = @"
{
  ""settings"": {
    ""namingRules"": {
      ""allowedNamespaceComponents"": [ ""eBay"" ]
    }
  }
}
";

            var testCode = @"namespace eBay;";

            await new CSharpTest
            {
                TestCode = testCode,
                Settings = customTestSettings,
            }.RunAsync(CancellationToken.None).ConfigureAwait(false);
        }

        [Fact]
        public async Task TestLowerCaseComplicatedFileScopedNamespaceAsync()
        {
            var testCode = @"namespace {|#0:test|}.{|#1:foo|}.{|#2:bar|};";

            var fixedCode = @"namespace Test.Foo.Bar;";

            DiagnosticResult[] expected = new[]
            {
                Diagnostic().WithArguments("test").WithLocation(0),
                Diagnostic().WithArguments("foo").WithLocation(1),
                Diagnostic().WithArguments("bar").WithLocation(2),
            };

            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
        }

        [Fact]
        public async Task TestAllowedLowerCaseComplicatedFileScopedNamespaceIsNotReportedAsync()
        {
            var customTestSettings = @"
{
  ""settings"": {
    ""namingRules"": {
      ""allowedNamespaceComponents"": [ ""iPod"" ]
    }
  }
}
";

            var testCode = @"namespace Apple.iPod.Library;";

            await new CSharpTest
            {
                TestCode = testCode,
                Settings = customTestSettings,
            }.RunAsync(CancellationToken.None).ConfigureAwait(false);
        }

        [Fact]
        [WorkItem(3979, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3979")]
        public async Task TestRecordStructNameMustStartWithUpperCaseLetterAsync()
        {
            var testCode = @"
public record struct {|#0:r|}(int A)
{
    public {|#1:r|}(int a, int b)
        : this(A: a)
    {
    }
}
";

            var fixedCode = @"
public record struct R(int A)
{
    public R(int a, int b)
        : this(A: a)
    {
    }
}
";

            DiagnosticResult[] expected =
            {
                Diagnostic().WithLocation(0).WithArguments("r"),
                Diagnostic().WithLocation(1).WithArguments("r"),
            };

            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
        }
    }
}