Use real symbols instead of Moq

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp11/Lightup/IImportScopeWrapperCSharp11UnitTests.cs

@@ -3,39 +3,83 @@
 
 namespace StyleCop.Analyzers.Test.CSharp11.Lightup
 {
+    using System;
     using System.Collections.Generic;
-    using System.Collections.Immutable;
+    using System.Linq;
+    using System.Threading;
+    using System.Threading.Tasks;
     using Microsoft.CodeAnalysis;
-    using Moq;
+    using Microsoft.CodeAnalysis.CSharp;
+    using Microsoft.CodeAnalysis.Text;
     using StyleCop.Analyzers.Lightup;
     using StyleCop.Analyzers.Test.CSharp10.Lightup;
+    using StyleCop.Analyzers.Test.Verifiers;
     using Xunit;
 
     public partial class IImportScopeWrapperCSharp11UnitTests : IImportScopeWrapperCSharp10UnitTests
     {
         [Theory]
-        [InlineData(0)]
         [InlineData(1)]
         [InlineData(2)]
-        public void TestCompatibleInstance(int numberOfAliasSymbols)
+        public async Task TestCompatibleInstanceAsync(int numberOfAliasSymbols)
         {
-            var obj = CreateImportScope(numberOfAliasSymbols);
+            var obj = await CreateImportScopeAsync(numberOfAliasSymbols, CancellationToken.None).ConfigureAwait(false);
             Assert.True(IImportScopeWrapper.IsInstance(obj));
             var wrapper = IImportScopeWrapper.FromObject(obj);
             Assert.Equal(obj.Aliases, wrapper.Aliases);
         }
 
-        private static IImportScope CreateImportScope(int numberOfAliasSymbols)
+        private static async Task<IImportScope> CreateImportScopeAsync(int numberOfAliasSymbols, CancellationToken cancellationToken)
         {
-            var aliasSymbolMocks = new List<IAliasSymbol>();
+            var aliasDirectives = new List<string>(numberOfAliasSymbols);
             for (var i = 0; i < numberOfAliasSymbols; i++)
             {
-                aliasSymbolMocks.Add(Mock.Of<IAliasSymbol>());
+                aliasDirectives.Add($"global using Alias{i} = System.String;");
             }
 
-            var importScopeMock = new Mock<IImportScope>();
-            importScopeMock.Setup(x => x.Aliases).Returns(aliasSymbolMocks.ToImmutableArray());
-            return importScopeMock.Object;
+            var source = string.Join(Environment.NewLine, aliasDirectives);
+            if (source.Length > 0)
+            {
+                source += Environment.NewLine;
+            }
+
+            source += @"
+namespace TestNamespace
+{
+    public class TestClass
+    {
+    }
+}
+";
+
+            var workspace = GenericAnalyzerTest.CreateWorkspace();
+            var projectId = ProjectId.CreateNewId();
+
+            var references = await GenericAnalyzerTest.ReferenceAssemblies
+                .ResolveAsync(LanguageNames.CSharp, cancellationToken).ConfigureAwait(false);
+
+            var solution = workspace.CurrentSolution
+                .AddProject(projectId, "TestProject", "TestProject", LanguageNames.CSharp)
+                .WithProjectCompilationOptions(projectId, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
+                .WithProjectParseOptions(projectId, new CSharpParseOptions(LanguageVersionEx.CSharp11))
+                .AddMetadataReferences(projectId, references);
+
+            var documentId = DocumentId.CreateNewId(projectId);
+            solution = solution.AddDocument(documentId, "Test.cs", SourceText.From(source));
+
+            var project = solution.GetProject(projectId)!;
+            var compilation = (await project.GetCompilationAsync(cancellationToken).ConfigureAwait(false))!;
+            var syntaxTree = compilation.SyntaxTrees.Single();
+            var semanticModel = compilation.GetSemanticModel(syntaxTree);
+            var importScopes = semanticModel.GetImportScopes(syntaxTree.Length, cancellationToken);
+
+            var result = importScopes.FirstOrDefault(scope => scope.Aliases.Length == numberOfAliasSymbols);
+            if (result == null)
+            {
+                throw new InvalidOperationException("Could not create an import scope with the expected number of alias symbols.");
+            }
+
+            return result;
         }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp11/StyleCop.Analyzers.Test.CSharp11.csproj

@@ -19,7 +19,6 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.4.0" />
-    <PackageReference Include="Moq" Version="4.20.70" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" PrivateAssets="all" />
   </ItemGroup>