diff --git a/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/AnalyzerTest`1.cs b/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/AnalyzerTest`1.cs index 4489270ec..432441871 100644 --- a/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/AnalyzerTest`1.cs +++ b/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/AnalyzerTest`1.cs @@ -114,6 +114,8 @@ public string TestCode /// public List DisabledDiagnostics { get; } = new List(); + public ReferenceAssemblies ReferenceAssemblies { get; set; } = ReferenceAssemblies.Default; + /// /// Gets a collection of transformation functions to apply to during diagnostic /// or code fix test setup. @@ -484,9 +486,9 @@ private static bool IsInSourceFile(DiagnosticResult result, (string filename, So /// The that the task will observe. /// A collection of s that surfaced in the source code, sorted by /// . - private Task> GetSortedDiagnosticsAsync((string filename, SourceText content)[] sources, (string filename, SourceText content)[] additionalFiles, ProjectState[] additionalProjects, MetadataReference[] additionalMetadataReferences, ImmutableArray analyzers, IVerifier verifier, CancellationToken cancellationToken) + private async Task> GetSortedDiagnosticsAsync((string filename, SourceText content)[] sources, (string filename, SourceText content)[] additionalFiles, ProjectState[] additionalProjects, MetadataReference[] additionalMetadataReferences, ImmutableArray analyzers, IVerifier verifier, CancellationToken cancellationToken) { - return GetSortedDiagnosticsAsync(GetSolution(sources, additionalFiles, additionalProjects, additionalMetadataReferences, verifier), analyzers, CompilerDiagnostics, cancellationToken); + return await GetSortedDiagnosticsAsync(await GetSolutionAsync(sources, additionalFiles, additionalProjects, additionalMetadataReferences, verifier, cancellationToken), analyzers, CompilerDiagnostics, cancellationToken); } /// @@ -558,12 +560,13 @@ protected virtual AnalyzerOptions GetAnalyzerOptions(Project project) /// Additional projects to include in the solution. /// Additional metadata references to include in the project. /// The verifier to use for test assertions. + /// The that the task will observe. /// A solution containing a project with the specified sources and additional files. - private Solution GetSolution((string filename, SourceText content)[] sources, (string filename, SourceText content)[] additionalFiles, ProjectState[] additionalProjects, MetadataReference[] additionalMetadataReferences, IVerifier verifier) + private async Task GetSolutionAsync((string filename, SourceText content)[] sources, (string filename, SourceText content)[] additionalFiles, ProjectState[] additionalProjects, MetadataReference[] additionalMetadataReferences, IVerifier verifier, CancellationToken cancellationToken) { verifier.LanguageIsSupported(Language); - var project = CreateProject(sources, additionalFiles, additionalProjects, additionalMetadataReferences, Language); + var project = await CreateProjectAsync(sources, additionalFiles, additionalProjects, additionalMetadataReferences, Language, cancellationToken); var documents = project.Documents.ToArray(); verifier.Equal(sources.Length, documents.Length, "Amount of sources did not match amount of Documents created"); @@ -575,7 +578,7 @@ private Solution GetSolution((string filename, SourceText content)[] sources, (s /// Create a project using the input strings as sources. /// /// - /// This method first creates a by calling , and then + /// This method first creates a by calling , and then /// applies compilation options to the project by calling . /// /// Classes in the form of strings. @@ -584,11 +587,12 @@ private Solution GetSolution((string filename, SourceText content)[] sources, (s /// Additional metadata references to include in the project. /// The language the source classes are in. Values may be taken from the /// class. + /// The that the task will observe. /// A created out of the s created from the source /// strings. - protected Project CreateProject((string filename, SourceText content)[] sources, (string filename, SourceText content)[] additionalFiles, ProjectState[] additionalProjects, MetadataReference[] additionalMetadataReferences, string language) + protected async Task CreateProjectAsync((string filename, SourceText content)[] sources, (string filename, SourceText content)[] additionalFiles, ProjectState[] additionalProjects, MetadataReference[] additionalMetadataReferences, string language, CancellationToken cancellationToken) { - var project = CreateProjectImpl(sources, additionalFiles, additionalProjects, additionalMetadataReferences, language); + var project = await CreateProjectImplAsync(sources, additionalFiles, additionalProjects, additionalMetadataReferences, language, cancellationToken); return ApplyCompilationOptions(project); } @@ -601,15 +605,16 @@ protected Project CreateProject((string filename, SourceText content)[] sources, /// Additional metadata references to include in the project. /// The language the source classes are in. Values may be taken from the /// class. + /// The that the task will observe. /// A created out of the s created from the source /// strings. - protected virtual Project CreateProjectImpl((string filename, SourceText content)[] sources, (string filename, SourceText content)[] additionalFiles, ProjectState[] additionalProjects, MetadataReference[] additionalMetadataReferences, string language) + protected virtual async Task CreateProjectImplAsync((string filename, SourceText content)[] sources, (string filename, SourceText content)[] additionalFiles, ProjectState[] additionalProjects, MetadataReference[] additionalMetadataReferences, string language, CancellationToken cancellationToken) { var fileNamePrefix = DefaultFilePathPrefix; var fileExt = DefaultFileExt; var projectId = ProjectId.CreateNewId(debugName: DefaultTestProjectName); - var solution = CreateSolution(projectId, language); + var solution = await CreateSolutionAsync(projectId, language, cancellationToken); foreach (var projectState in additionalProjects) { @@ -655,8 +660,9 @@ protected virtual Project CreateProjectImpl((string filename, SourceText content /// /// The project identifier to use. /// The language for which the solution is being created. + /// The that the task will observe. /// The created solution. - protected virtual Solution CreateSolution(ProjectId projectId, string language) + protected virtual async Task CreateSolutionAsync(ProjectId projectId, string language, CancellationToken cancellationToken) { var compilationOptions = CreateCompilationOptions(); @@ -666,38 +672,17 @@ protected virtual Solution CreateSolution(ProjectId projectId, string language) xmlReferenceResolver.XmlReferences.Add(xmlReference.Key, xmlReference.Value); } - compilationOptions = compilationOptions.WithXmlReferenceResolver(xmlReferenceResolver); + compilationOptions = compilationOptions + .WithXmlReferenceResolver(xmlReferenceResolver) + .WithAssemblyIdentityComparer(ReferenceAssemblies.AssemblyIdentityComparer); var solution = CreateWorkspace() .CurrentSolution .AddProject(projectId, DefaultTestProjectName, DefaultTestProjectName, language) - .WithProjectCompilationOptions(projectId, compilationOptions) - .AddMetadataReference(projectId, MetadataReferences.CorlibReference) - .AddMetadataReference(projectId, MetadataReferences.SystemReference) - .AddMetadataReference(projectId, MetadataReferences.SystemCoreReference) - .AddMetadataReference(projectId, MetadataReferences.CodeAnalysisReference) - .AddMetadataReference(projectId, MetadataReferences.SystemCollectionsImmutableReference); - - if (language == LanguageNames.VisualBasic) - { - solution = solution.AddMetadataReference(projectId, MetadataReferences.MicrosoftVisualBasicReference); - } + .WithProjectCompilationOptions(projectId, compilationOptions); - if (MetadataReferences.MscorlibFacadeReference != null) - { - solution = solution.AddMetadataReference(projectId, MetadataReferences.MscorlibFacadeReference); - } - - if (MetadataReferences.SystemRuntimeReference != null) - { - solution = solution.AddMetadataReference(projectId, MetadataReferences.SystemRuntimeReference); - } - - if (typeof(object).GetTypeInfo().Assembly.GetType("System.ValueTuple`2", throwOnError: false) == null - && MetadataReferences.SystemValueTupleReference != null) - { - solution = solution.AddMetadataReference(projectId, MetadataReferences.SystemValueTupleReference); - } + var metadataReferences = await ReferenceAssemblies.ResolveAsync(language, cancellationToken); + solution = solution.AddMetadataReferences(projectId, metadataReferences); foreach (var transform in OptionsTransforms) { diff --git a/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/MetadataReferenceCollection.cs b/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/MetadataReferenceCollection.cs index 7acd05e69..3f96f4418 100644 --- a/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/MetadataReferenceCollection.cs +++ b/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/MetadataReferenceCollection.cs @@ -23,7 +23,7 @@ public void Add(string path) private static MetadataReference GetOrCreateReference(string path) { - return s_referencesFromFiles.GetOrAdd(path, p => MetadataReference.CreateFromFile(p)); + return s_referencesFromFiles.GetOrAdd(path, p => MetadataReferences.CreateReferenceFromFile(p)); } } } diff --git a/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/MetadataReferences.cs b/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/MetadataReferences.cs index ff43831e9..96bc03a82 100644 --- a/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/MetadataReferences.cs +++ b/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/MetadataReferences.cs @@ -1,16 +1,11 @@ // Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. using System; -using System.Collections.Immutable; -using System.Linq; +using System.IO; +using System.Linq.Expressions; using System.Reflection; -using System.Runtime.CompilerServices; using Microsoft.CodeAnalysis; -#if NETSTANDARD1_5 -using System.IO; -#endif - namespace Microsoft.CodeAnalysis.Testing { /// @@ -18,78 +13,34 @@ namespace Microsoft.CodeAnalysis.Testing /// public static class MetadataReferences { - public static readonly MetadataReference CorlibReference = MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location).WithAliases(ImmutableArray.Create("global", "corlib")); - public static readonly MetadataReference SystemReference = MetadataReference.CreateFromFile(typeof(System.Diagnostics.Debug).GetTypeInfo().Assembly.Location).WithAliases(ImmutableArray.Create("global", "system")); - public static readonly MetadataReference SystemCoreReference = MetadataReference.CreateFromFile(typeof(Enumerable).GetTypeInfo().Assembly.Location); - public static readonly MetadataReference CodeAnalysisReference = MetadataReference.CreateFromFile(typeof(Compilation).GetTypeInfo().Assembly.Location); - public static readonly MetadataReference SystemCollectionsImmutableReference = MetadataReference.CreateFromFile(typeof(ImmutableArray).GetTypeInfo().Assembly.Location); - - internal static readonly MetadataReference? MscorlibFacadeReference; - internal static readonly MetadataReference? SystemRuntimeReference; - internal static readonly MetadataReference? SystemValueTupleReference; - - private static MetadataReference? _microsoftVisualBasicReference; + private static readonly Func s_createDocumentationProvider; static MetadataReferences() { -#if NETSTANDARD1_5 - if (typeof(string).GetTypeInfo().Assembly.ExportedTypes.Any(x => x.Name == "System.ValueTuple")) - { - // mscorlib contains ValueTuple, so no need to add a separate reference - MscorlibFacadeReference = null; - SystemRuntimeReference = null; - SystemValueTupleReference = null; - } - else - { - MscorlibFacadeReference = MetadataReference.CreateFromFile(Path.Combine(Path.GetDirectoryName(typeof(Lazy<,>).GetTypeInfo().Assembly.Location), "mscorlib.dll")); - SystemRuntimeReference = MetadataReference.CreateFromFile(typeof(Lazy<,>).GetTypeInfo().Assembly.Location); - SystemValueTupleReference = MetadataReference.CreateFromFile(typeof(ValueTuple<,>).GetTypeInfo().Assembly.Location); - } -#elif NETSTANDARD2_0 - // mscorlib contains ValueTuple, so no need to add a separate reference - MscorlibFacadeReference = null; - SystemRuntimeReference = null; - SystemValueTupleReference = null; -#elif NET452 - // System.Object is already in mscorlib - MscorlibFacadeReference = null; + Func createDocumentationProvider = _ => null; - var systemRuntime = AppDomain.CurrentDomain.GetAssemblies().SingleOrDefault(x => x.GetName().Name == "System.Runtime"); - if (systemRuntime != null) + var xmlDocumentationProvider = typeof(Workspace).GetTypeInfo().Assembly.GetType("Microsoft.CodeAnalysis.XmlDocumentationProvider"); + if (xmlDocumentationProvider is object) { - SystemRuntimeReference = MetadataReference.CreateFromFile(systemRuntime.Location); + var createFromFile = xmlDocumentationProvider.GetTypeInfo().GetMethod("CreateFromFile", new[] { typeof(string) }); + if (createFromFile is object) + { + var xmlDocCommentFilePath = Expression.Parameter(typeof(string), "xmlDocCommentFilePath"); + var body = Expression.Convert( + Expression.Call(createFromFile, xmlDocCommentFilePath), + typeof(DocumentationProvider)); + var expression = Expression.Lambda>(body, xmlDocCommentFilePath); + createDocumentationProvider = expression.Compile(); + } } - var systemValueTuple = AppDomain.CurrentDomain.GetAssemblies().SingleOrDefault(x => x.GetName().Name == "System.ValueTuple"); - if (systemValueTuple != null) - { - SystemValueTupleReference = MetadataReference.CreateFromFile(systemValueTuple.Location); - } -#else -#error Unsupported target framework. -#endif + s_createDocumentationProvider = createDocumentationProvider; } - public static MetadataReference MicrosoftVisualBasicReference + internal static MetadataReference CreateReferenceFromFile(string path) { - [MethodImpl(MethodImplOptions.NoInlining)] - get - { - if (_microsoftVisualBasicReference is null) - { - try - { - _microsoftVisualBasicReference = MetadataReference.CreateFromFile(typeof(Microsoft.VisualBasic.Strings).GetTypeInfo().Assembly.Location); - } - catch (Exception e) - { - throw new PlatformNotSupportedException("Microsoft.VisualBasic is not supported on this platform", e); - } - } - - return _microsoftVisualBasicReference; - } + var documentationFile = Path.ChangeExtension(path, ".xml"); + return MetadataReference.CreateFromFile(path, documentation: s_createDocumentationProvider(documentationFile)); } } } diff --git a/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/Microsoft.CodeAnalysis.Analyzer.Testing.csproj b/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/Microsoft.CodeAnalysis.Analyzer.Testing.csproj index 648759321..a07693507 100644 --- a/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/Microsoft.CodeAnalysis.Analyzer.Testing.csproj +++ b/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/Microsoft.CodeAnalysis.Analyzer.Testing.csproj @@ -1,7 +1,7 @@  - netstandard1.5;netstandard2.0;net452 + netstandard1.5;netstandard2.0;net452;net46;net472 Microsoft.CodeAnalysis.Analyzer.Testing Microsoft.CodeAnalysis.Testing @@ -13,12 +13,42 @@ Roslyn Analyzer Test Framework Common + + + + 4.5.3 + + + + + 4.9.4 + + + + + 4.6.4 + + + + + 5.3.1 + + + + + + + + + + + diff --git a/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/PublicAPI.Unshipped.txt b/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/PublicAPI.Unshipped.txt index 90525ffd7..84f5f9996 100644 --- a/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/PublicAPI.Unshipped.txt +++ b/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/PublicAPI.Unshipped.txt @@ -2,13 +2,15 @@ Microsoft.CodeAnalysis.Testing.AnalyzerTest Microsoft.CodeAnalysis.Testing.AnalyzerTest.AnalyzerTest() -> void Microsoft.CodeAnalysis.Testing.AnalyzerTest.CompilerDiagnostics.get -> Microsoft.CodeAnalysis.Testing.CompilerDiagnostics Microsoft.CodeAnalysis.Testing.AnalyzerTest.CompilerDiagnostics.set -> void -Microsoft.CodeAnalysis.Testing.AnalyzerTest.CreateProject((string filename, Microsoft.CodeAnalysis.Text.SourceText content)[] sources, (string filename, Microsoft.CodeAnalysis.Text.SourceText content)[] additionalFiles, Microsoft.CodeAnalysis.Testing.ProjectState[] additionalProjects, Microsoft.CodeAnalysis.MetadataReference[] additionalMetadataReferences, string language) -> Microsoft.CodeAnalysis.Project +Microsoft.CodeAnalysis.Testing.AnalyzerTest.CreateProjectAsync((string filename, Microsoft.CodeAnalysis.Text.SourceText content)[] sources, (string filename, Microsoft.CodeAnalysis.Text.SourceText content)[] additionalFiles, Microsoft.CodeAnalysis.Testing.ProjectState[] additionalProjects, Microsoft.CodeAnalysis.MetadataReference[] additionalMetadataReferences, string language, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task Microsoft.CodeAnalysis.Testing.AnalyzerTest.DisabledDiagnostics.get -> System.Collections.Generic.List Microsoft.CodeAnalysis.Testing.AnalyzerTest.ExpectedDiagnostics.get -> System.Collections.Generic.List Microsoft.CodeAnalysis.Testing.AnalyzerTest.GetSortedDiagnosticsAsync(Microsoft.CodeAnalysis.Solution solution, System.Collections.Immutable.ImmutableArray analyzers, Microsoft.CodeAnalysis.Testing.CompilerDiagnostics compilerDiagnostics, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task> Microsoft.CodeAnalysis.Testing.AnalyzerTest.MarkupOptions.get -> Microsoft.CodeAnalysis.Testing.MarkupOptions Microsoft.CodeAnalysis.Testing.AnalyzerTest.MarkupOptions.set -> void Microsoft.CodeAnalysis.Testing.AnalyzerTest.OptionsTransforms.get -> System.Collections.Generic.List> +Microsoft.CodeAnalysis.Testing.AnalyzerTest.ReferenceAssemblies.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +Microsoft.CodeAnalysis.Testing.AnalyzerTest.ReferenceAssemblies.set -> void Microsoft.CodeAnalysis.Testing.AnalyzerTest.SolutionTransforms.get -> System.Collections.Generic.List> Microsoft.CodeAnalysis.Testing.AnalyzerTest.TestBehaviors.get -> Microsoft.CodeAnalysis.Testing.TestBehaviors Microsoft.CodeAnalysis.Testing.AnalyzerTest.TestBehaviors.set -> void @@ -94,6 +96,40 @@ Microsoft.CodeAnalysis.Testing.ProjectState.AssemblyName.get -> string Microsoft.CodeAnalysis.Testing.ProjectState.Name.get -> string Microsoft.CodeAnalysis.Testing.ProjectState.ProjectState(string name, string defaultPrefix, string defaultExtension) -> void Microsoft.CodeAnalysis.Testing.ProjectState.Sources.get -> Microsoft.CodeAnalysis.Testing.SourceFileList +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.AddAssemblies(System.Collections.Immutable.ImmutableArray assemblies) -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.AddLanguageSpecificAssemblies(string language, System.Collections.Immutable.ImmutableArray assemblies) -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.AddPackages(System.Collections.Immutable.ImmutableArray packages) -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.Assemblies.get -> System.Collections.Immutable.ImmutableArray +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.AssemblyIdentityComparer.get -> Microsoft.CodeAnalysis.AssemblyIdentityComparer +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.LanguageSpecificAssemblies.get -> System.Collections.Immutable.ImmutableDictionary> +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetCore +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net20 +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net40 +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net45 +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net451 +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net452 +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net46 +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net461 +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net462 +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net47 +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net471 +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net472 +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net48 +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetStandard +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.Packages.get -> System.Collections.Immutable.ImmutableArray +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.ReferenceAssemblies(string targetFramework) -> void +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.ReferenceAssemblies(string targetFramework, NuGet.Packaging.Core.PackageIdentity referenceAssemblyPackage, string referenceAssemblyPath) -> void +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.ReferenceAssemblyPackage.get -> NuGet.Packaging.Core.PackageIdentity +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.ReferenceAssemblyPath.get -> string +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.ResolveAsync(string language, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task> +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.TargetFramework.get -> string +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.WithAssemblies(System.Collections.Immutable.ImmutableArray assemblies) -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.WithAssemblyIdentityComparer(Microsoft.CodeAnalysis.AssemblyIdentityComparer assemblyIdentityComparer) -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.WithLanguageSpecificAssemblies(System.Collections.Immutable.ImmutableDictionary> languageSpecificAssemblies) -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.WithLanguageSpecificAssemblies(string language, System.Collections.Immutable.ImmutableArray assemblies) -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.WithPackages(System.Collections.Immutable.ImmutableArray packages) -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies Microsoft.CodeAnalysis.Testing.SolutionState Microsoft.CodeAnalysis.Testing.SolutionState.AdditionalFiles.get -> Microsoft.CodeAnalysis.Testing.SourceFileCollection Microsoft.CodeAnalysis.Testing.SolutionState.AdditionalFilesFactories.get -> System.Collections.Generic.List>> @@ -140,7 +176,54 @@ static Microsoft.CodeAnalysis.Testing.AnalyzerVerifier Microsoft.CodeAnalysis.Testing.DiagnosticResult static Microsoft.CodeAnalysis.Testing.DiagnosticResult.CompilerWarning(string identifier) -> Microsoft.CodeAnalysis.Testing.DiagnosticResult static Microsoft.CodeAnalysis.Testing.IVerifierExtensions.EqualOrDiff(this Microsoft.CodeAnalysis.Testing.IVerifier verifier, string expected, string actual, string message = null) -> void -static Microsoft.CodeAnalysis.Testing.MetadataReferences.MicrosoftVisualBasicReference.get -> Microsoft.CodeAnalysis.MetadataReference +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.Default.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetCore.NetCoreApp10.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetCore.NetCoreApp11.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetCore.NetCoreApp20.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetCore.NetCoreApp21.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net20.Default.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net20.WindowsForms.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net40.Default.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net40.WindowsForms.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net40.Wpf.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net45.Default.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net45.WindowsForms.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net45.Wpf.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net451.Default.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net451.WindowsForms.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net451.Wpf.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net452.Default.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net452.WindowsForms.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net452.Wpf.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net46.Default.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net46.WindowsForms.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net46.Wpf.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net461.Default.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net461.WindowsForms.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net461.Wpf.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net462.Default.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net462.WindowsForms.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net462.Wpf.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net47.Default.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net47.WindowsForms.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net47.Wpf.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net471.Default.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net471.WindowsForms.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net471.Wpf.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net472.Default.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net472.WindowsForms.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net472.Wpf.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net48.Default.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net48.WindowsForms.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetFramework.Net48.Wpf.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetStandard.NetStandard10.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetStandard.NetStandard11.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetStandard.NetStandard12.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetStandard.NetStandard13.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetStandard.NetStandard14.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetStandard.NetStandard15.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetStandard.NetStandard16.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies +static Microsoft.CodeAnalysis.Testing.ReferenceAssemblies.NetStandard.NetStandard20.get -> Microsoft.CodeAnalysis.Testing.ReferenceAssemblies static Microsoft.CodeAnalysis.Testing.TestFileMarkupParser.CreateTestFile(string code, System.Collections.Generic.IDictionary> spans, int? cursor) -> string static Microsoft.CodeAnalysis.Testing.TestFileMarkupParser.CreateTestFile(string code, System.Collections.Generic.IList spans, int? cursor) -> string static Microsoft.CodeAnalysis.Testing.TestFileMarkupParser.CreateTestFile(string code, int cursor) -> string @@ -157,14 +240,9 @@ static Microsoft.CodeAnalysis.Testing.TestFileMarkupParser.GetSpan(string input, static Microsoft.CodeAnalysis.Testing.TestFileMarkupParser.GetSpans(string input, out string output, out System.Collections.Generic.IDictionary> spans) -> void static Microsoft.CodeAnalysis.Testing.TestFileMarkupParser.GetSpans(string input, out string output, out System.Collections.Generic.IList spans) -> void static readonly Microsoft.CodeAnalysis.Testing.DiagnosticResult.EmptyDiagnosticResults -> Microsoft.CodeAnalysis.Testing.DiagnosticResult[] -static readonly Microsoft.CodeAnalysis.Testing.MetadataReferences.CodeAnalysisReference -> Microsoft.CodeAnalysis.MetadataReference -static readonly Microsoft.CodeAnalysis.Testing.MetadataReferences.CorlibReference -> Microsoft.CodeAnalysis.MetadataReference -static readonly Microsoft.CodeAnalysis.Testing.MetadataReferences.SystemCollectionsImmutableReference -> Microsoft.CodeAnalysis.MetadataReference -static readonly Microsoft.CodeAnalysis.Testing.MetadataReferences.SystemCoreReference -> Microsoft.CodeAnalysis.MetadataReference -static readonly Microsoft.CodeAnalysis.Testing.MetadataReferences.SystemReference -> Microsoft.CodeAnalysis.MetadataReference virtual Microsoft.CodeAnalysis.Testing.AnalyzerTest.ApplyCompilationOptions(Microsoft.CodeAnalysis.Project project) -> Microsoft.CodeAnalysis.Project -virtual Microsoft.CodeAnalysis.Testing.AnalyzerTest.CreateProjectImpl((string filename, Microsoft.CodeAnalysis.Text.SourceText content)[] sources, (string filename, Microsoft.CodeAnalysis.Text.SourceText content)[] additionalFiles, Microsoft.CodeAnalysis.Testing.ProjectState[] additionalProjects, Microsoft.CodeAnalysis.MetadataReference[] additionalMetadataReferences, string language) -> Microsoft.CodeAnalysis.Project -virtual Microsoft.CodeAnalysis.Testing.AnalyzerTest.CreateSolution(Microsoft.CodeAnalysis.ProjectId projectId, string language) -> Microsoft.CodeAnalysis.Solution +virtual Microsoft.CodeAnalysis.Testing.AnalyzerTest.CreateProjectImplAsync((string filename, Microsoft.CodeAnalysis.Text.SourceText content)[] sources, (string filename, Microsoft.CodeAnalysis.Text.SourceText content)[] additionalFiles, Microsoft.CodeAnalysis.Testing.ProjectState[] additionalProjects, Microsoft.CodeAnalysis.MetadataReference[] additionalMetadataReferences, string language, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task +virtual Microsoft.CodeAnalysis.Testing.AnalyzerTest.CreateSolutionAsync(Microsoft.CodeAnalysis.ProjectId projectId, string language, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task virtual Microsoft.CodeAnalysis.Testing.AnalyzerTest.CreateWorkspace() -> Microsoft.CodeAnalysis.AdhocWorkspace virtual Microsoft.CodeAnalysis.Testing.AnalyzerTest.DefaultFilePath.get -> string virtual Microsoft.CodeAnalysis.Testing.AnalyzerTest.DefaultFilePathPrefix.get -> string @@ -181,4 +259,4 @@ virtual Microsoft.CodeAnalysis.Testing.DefaultVerifier.LanguageIsSupported(strin virtual Microsoft.CodeAnalysis.Testing.DefaultVerifier.NotEmpty(string collectionName, System.Collections.Generic.IEnumerable collection) -> void virtual Microsoft.CodeAnalysis.Testing.DefaultVerifier.PushContext(string context) -> Microsoft.CodeAnalysis.Testing.IVerifier virtual Microsoft.CodeAnalysis.Testing.DefaultVerifier.SequenceEqual(System.Collections.Generic.IEnumerable expected, System.Collections.Generic.IEnumerable actual, System.Collections.Generic.IEqualityComparer equalityComparer = null, string message = null) -> void -virtual Microsoft.CodeAnalysis.Testing.DefaultVerifier.True(bool assert, string message = null) -> void +virtual Microsoft.CodeAnalysis.Testing.DefaultVerifier.True(bool assert, string message = null) -> void \ No newline at end of file diff --git a/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/ReferenceAssemblies+FileSystemSemaphore.cs b/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/ReferenceAssemblies+FileSystemSemaphore.cs new file mode 100644 index 000000000..ed77ffc8e --- /dev/null +++ b/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/ReferenceAssemblies+FileSystemSemaphore.cs @@ -0,0 +1,54 @@ +// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.IO; +using System.Threading; +using System.Threading.Tasks; + +namespace Microsoft.CodeAnalysis.Testing +{ + public sealed partial class ReferenceAssemblies + { + private sealed class FileSystemSemaphore + { + private readonly string _path; + + public FileSystemSemaphore(string path) + { + _path = path ?? throw new ArgumentNullException(nameof(path)); + + Directory.CreateDirectory(Path.GetDirectoryName(path)); + } + + internal async Task WaitAsync(CancellationToken cancellationToken) + { + while (true) + { + try + { + return new Releaser(File.Open(_path, FileMode.OpenOrCreate, FileAccess.Read, FileShare.None)); + } + catch (IOException) + { + await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken); + } + } + } + + public readonly struct Releaser : IDisposable + { + private readonly FileStream _fileStream; + + public Releaser(FileStream fileStream) + { + _fileStream = fileStream; + } + + public void Dispose() + { + _fileStream?.Dispose(); + } + } + } + } +} diff --git a/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/ReferenceAssemblies.cs b/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/ReferenceAssemblies.cs new file mode 100644 index 000000000..2a4152257 --- /dev/null +++ b/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing/ReferenceAssemblies.cs @@ -0,0 +1,749 @@ +// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.IO; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using NuGet.Common; +using NuGet.Configuration; +using NuGet.Frameworks; +using NuGet.Packaging; +using NuGet.Packaging.Core; +using NuGet.Protocol; +using NuGet.Protocol.Core.Types; +using NuGet.Resolver; +using NuGet.Versioning; + +#if NET46 || NET472 || NETSTANDARD +using NuGet.Packaging.Signing; +#endif + +namespace Microsoft.CodeAnalysis.Testing +{ + public sealed partial class ReferenceAssemblies + { + private const string ReferenceAssembliesPackageVersion = "1.0.0-preview.2"; + + private static readonly FileSystemSemaphore Semaphore = new FileSystemSemaphore(Path.Combine(Path.GetTempPath(), "test-packages", ".lock")); + + private readonly Dictionary> _references + = new Dictionary>(); + + public ReferenceAssemblies(string targetFramework) + { + TargetFramework = targetFramework ?? throw new ArgumentNullException(nameof(targetFramework)); + AssemblyIdentityComparer = AssemblyIdentityComparer.Default; + ReferenceAssemblyPath = null; + Assemblies = ImmutableArray.Empty; + LanguageSpecificAssemblies = ImmutableDictionary>.Empty; + Packages = ImmutableArray.Empty; + } + + public ReferenceAssemblies(string targetFramework, PackageIdentity referenceAssemblyPackage, string referenceAssemblyPath) + { + TargetFramework = targetFramework ?? throw new ArgumentNullException(nameof(targetFramework)); + AssemblyIdentityComparer = AssemblyIdentityComparer.Default; + ReferenceAssemblyPackage = referenceAssemblyPackage ?? throw new ArgumentNullException(nameof(referenceAssemblyPackage)); + ReferenceAssemblyPath = referenceAssemblyPath; + Assemblies = ImmutableArray.Empty; + LanguageSpecificAssemblies = ImmutableDictionary>.Empty; + Packages = ImmutableArray.Empty; + } + + private ReferenceAssemblies( + string targetFramework, + AssemblyIdentityComparer assemblyIdentityComparer, + PackageIdentity? referenceAssemblyPackage, + string? referenceAssemblyPath, + ImmutableArray assemblies, + ImmutableDictionary> languageSpecificAssemblies, + ImmutableArray packages) + { + TargetFramework = targetFramework; + AssemblyIdentityComparer = assemblyIdentityComparer; + ReferenceAssemblyPackage = referenceAssemblyPackage; + ReferenceAssemblyPath = referenceAssemblyPath; + Assemblies = assemblies.IsDefault ? ImmutableArray.Empty : assemblies; + LanguageSpecificAssemblies = languageSpecificAssemblies; + Packages = packages.IsDefault ? ImmutableArray.Empty : packages; + } + + public static ReferenceAssemblies Default + { + get + { +#if NETSTANDARD1_5 + return NetStandard.NetStandard15; +#elif NETSTANDARD2_0 + return NetStandard.NetStandard20; +#elif NET452 + return NetFramework.Net452.Default; +#elif NET46 + return NetFramework.Net46.Default; +#elif NET472 + return NetFramework.Net472.Default; +#endif + } + } + + public string TargetFramework { get; } + + public AssemblyIdentityComparer AssemblyIdentityComparer { get; } + + public PackageIdentity? ReferenceAssemblyPackage { get; } + + public string? ReferenceAssemblyPath { get; } + + public ImmutableArray Assemblies { get; } + + public ImmutableDictionary> LanguageSpecificAssemblies { get; } + + public ImmutableArray Packages { get; } + + public ReferenceAssemblies WithAssemblyIdentityComparer(AssemblyIdentityComparer assemblyIdentityComparer) + => new ReferenceAssemblies(TargetFramework, assemblyIdentityComparer, ReferenceAssemblyPackage, ReferenceAssemblyPath, Assemblies, LanguageSpecificAssemblies, Packages); + + public ReferenceAssemblies WithAssemblies(ImmutableArray assemblies) + => new ReferenceAssemblies(TargetFramework, AssemblyIdentityComparer, ReferenceAssemblyPackage, ReferenceAssemblyPath, assemblies, LanguageSpecificAssemblies, Packages); + + public ReferenceAssemblies AddAssemblies(ImmutableArray assemblies) + => WithAssemblies(Assemblies.AddRange(assemblies)); + + public ReferenceAssemblies WithLanguageSpecificAssemblies(ImmutableDictionary> languageSpecificAssemblies) + => new ReferenceAssemblies(TargetFramework, AssemblyIdentityComparer, ReferenceAssemblyPackage, ReferenceAssemblyPath, Assemblies, languageSpecificAssemblies, Packages); + + public ReferenceAssemblies WithLanguageSpecificAssemblies(string language, ImmutableArray assemblies) + => WithLanguageSpecificAssemblies(LanguageSpecificAssemblies.SetItem(language, assemblies)); + + public ReferenceAssemblies AddLanguageSpecificAssemblies(string language, ImmutableArray assemblies) + { + if (!LanguageSpecificAssemblies.TryGetValue(language, out var existing)) + { + existing = ImmutableArray.Empty; + } + + return WithLanguageSpecificAssemblies(language, existing.AddRange(assemblies)); + } + + public ReferenceAssemblies WithPackages(ImmutableArray packages) + => new ReferenceAssemblies(TargetFramework, AssemblyIdentityComparer, ReferenceAssemblyPackage, ReferenceAssemblyPath, Assemblies, LanguageSpecificAssemblies, packages); + + public ReferenceAssemblies AddPackages(ImmutableArray packages) + => WithPackages(Packages.AddRange(packages)); + + public async Task> ResolveAsync(string? language, CancellationToken cancellationToken) + { + if (language is object) + { + if (LanguageSpecificAssemblies.IsEmpty + || !LanguageSpecificAssemblies.TryGetValue(language, out var languageSpecificAssemblies) + || languageSpecificAssemblies.IsEmpty) + { + return await ResolveAsync(null, cancellationToken); + } + } + + language ??= string.Empty; + lock (_references) + { + if (_references.TryGetValue(language, out var references)) + { + return references; + } + } + + using (var releaser = await Semaphore.WaitAsync(cancellationToken)) + { + lock (_references) + { + if (_references.TryGetValue(language, out var references)) + { + return references; + } + } + + var computedReferences = await ResolveCoreAsync(language, cancellationToken); + lock (_references) + { + _references.Add(language, computedReferences); + } + + return computedReferences; + } + } + + /// + private async Task> ResolveCoreAsync(string language, CancellationToken cancellationToken) + { + var settings = Settings.LoadDefaultSettings(root: null); + var sourceRepositoryProvider = new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3()); + var targetFramework = NuGetFramework.ParseFolder(TargetFramework); + var logger = NullLogger.Instance; + + using (var cacheContext = new SourceCacheContext()) + { + var repositories = sourceRepositoryProvider.GetRepositories().ToImmutableArray(); + var dependencies = ImmutableDictionary.CreateBuilder(PackageIdentityComparer.Default); + + if (ReferenceAssemblyPackage is object) + { + await GetPackageDependenciesAsync(ReferenceAssemblyPackage, targetFramework, repositories, cacheContext, logger, dependencies, cancellationToken); + } + + foreach (var packageIdentity in Packages) + { + await GetPackageDependenciesAsync(packageIdentity, targetFramework, repositories, cacheContext, logger, dependencies, cancellationToken); + } + + var availablePackages = dependencies.ToImmutable(); + + var packagesToInstall = new List(); + if (ReferenceAssemblyPackage is object) + { + packagesToInstall.Add(ReferenceAssemblyPackage); + } + + if (!Packages.IsEmpty) + { + var resolverContext = new PackageResolverContext( + DependencyBehavior.Lowest, + Packages.Select(package => package.Id), + Enumerable.Empty(), + Enumerable.Empty(), + Enumerable.Empty(), + availablePackages.Values, + sourceRepositoryProvider.GetRepositories().Select(repository => repository.PackageSource), + logger); + var resolver = new PackageResolver(); + + packagesToInstall.AddRange(resolver.Resolve(resolverContext, cancellationToken)); + } + + var globalPathResolver = new PackagePathResolver(SettingsUtility.GetGlobalPackagesFolder(settings)); + var temporaryPackagesFolder = Path.Combine(Path.GetTempPath(), "test-packages"); + Directory.CreateDirectory(temporaryPackagesFolder); + var localPathResolver = new PackagePathResolver(temporaryPackagesFolder); +#if NET452 + var packageExtractionContext = new PackageExtractionContext(logger); +#elif NET46 || NET472 || NETSTANDARD2_0 + var packageExtractionContext = new PackageExtractionContext( + PackageSaveMode.Defaultv3, + XmlDocFileSaveMode.None, + ClientPolicyContext.GetClientPolicy(settings, logger), + logger); +#elif NETSTANDARD1_5 + var packageExtractionContext = new PackageExtractionContext( + PackageSaveMode.Defaultv3, + XmlDocFileSaveMode.None, + logger, + new PackageSignatureVerifier( + SignatureVerificationProviderFactory.GetSignatureVerificationProviders(), + SignedPackageVerifierSettings.Default)); +#else +#error The current target framework is not supported. +#endif + + var frameworkReducer = new FrameworkReducer(); + + var resolvedAssemblies = new HashSet(); + foreach (var packageToInstall in packagesToInstall) + { + PackageReaderBase packageReader; + var installedPath = GetInstalledPath(localPathResolver, packageToInstall) + ?? GetInstalledPath(globalPathResolver, packageToInstall); + if (installedPath is null) + { + var downloadResource = await availablePackages[packageToInstall].Source.GetResourceAsync(cancellationToken); + var downloadResult = await downloadResource.GetDownloadResourceResultAsync( + packageToInstall, + new PackageDownloadContext(cacheContext), + SettingsUtility.GetGlobalPackagesFolder(settings), + logger, + cancellationToken); + + if (!PackageIdentityComparer.Default.Equals(packageToInstall, ReferenceAssemblyPackage) + && !downloadResult.PackageReader.GetItems(PackagingConstants.Folders.Lib).Any() + && !downloadResult.PackageReader.GetItems(PackagingConstants.Folders.Ref).Any()) + { + // This package has no compile time impact + continue; + } + + await PackageExtractor.ExtractPackageAsync( +#if !NET452 && !NETSTANDARD1_5 +#pragma warning disable SA1114 // Parameter list should follow declaration + downloadResult.PackageSource, +#pragma warning restore SA1114 // Parameter list should follow declaration +#endif + downloadResult.PackageStream, + localPathResolver, + packageExtractionContext, + cancellationToken); + + installedPath = localPathResolver.GetInstalledPath(packageToInstall); + packageReader = downloadResult.PackageReader; + } + else + { + packageReader = new PackageFolderReader(installedPath); + } + + var libItems = await packageReader.GetLibItemsAsync(cancellationToken); + var nearestLib = frameworkReducer.GetNearest(targetFramework, libItems.Select(x => x.TargetFramework)); + var frameworkItems = await packageReader.GetFrameworkItemsAsync(cancellationToken); + var nearestFramework = frameworkReducer.GetNearest(targetFramework, frameworkItems.Select(x => x.TargetFramework)); + var refItems = await packageReader.GetItemsAsync(PackagingConstants.Folders.Ref, cancellationToken); + var nearestRef = frameworkReducer.GetNearest(targetFramework, refItems.Select(x => x.TargetFramework)); + if (nearestRef is object) + { + var nearestRefItems = refItems.Single(x => x.TargetFramework == nearestRef); + foreach (var item in nearestRefItems.Items) + { + if (!string.Equals(Path.GetExtension(item), ".dll", StringComparison.OrdinalIgnoreCase)) + { + continue; + } + + resolvedAssemblies.Add(Path.Combine(installedPath, item)); + } + } + else if (nearestLib is object) + { + var nearestLibItems = libItems.Single(x => x.TargetFramework == nearestLib); + foreach (var item in nearestLibItems.Items) + { + if (!string.Equals(Path.GetExtension(item), ".dll", StringComparison.OrdinalIgnoreCase)) + { + continue; + } + + resolvedAssemblies.Add(Path.Combine(installedPath, item)); + } + } + + if (nearestFramework is object) + { + var nearestFrameworkItems = frameworkItems.Single(x => x.TargetFramework == nearestFramework); + foreach (var item in nearestFrameworkItems.Items) + { + var installedFrameworkPath = localPathResolver.GetInstalledPath(ReferenceAssemblyPackage) + ?? globalPathResolver.GetInstalledPath(ReferenceAssemblyPackage); + if (File.Exists(Path.Combine(installedFrameworkPath, ReferenceAssemblyPath, item + ".dll"))) + { + resolvedAssemblies.Add(Path.GetFullPath(Path.Combine(installedFrameworkPath, ReferenceAssemblyPath, item + ".dll"))); + break; + } + } + } + } + + foreach (var assembly in Assemblies) + { + var installedPath = localPathResolver.GetInstalledPath(ReferenceAssemblyPackage) + ?? globalPathResolver.GetInstalledPath(ReferenceAssemblyPackage); + if (File.Exists(Path.Combine(installedPath, ReferenceAssemblyPath, assembly + ".dll"))) + { + resolvedAssemblies.Add(Path.GetFullPath(Path.Combine(installedPath, ReferenceAssemblyPath, assembly + ".dll"))); + break; + } + } + + if (LanguageSpecificAssemblies.TryGetValue(language, out var languageSpecificAssemblies)) + { + foreach (var assembly in languageSpecificAssemblies) + { + var installedPath = localPathResolver.GetInstalledPath(ReferenceAssemblyPackage) + ?? globalPathResolver.GetInstalledPath(ReferenceAssemblyPackage); + if (File.Exists(Path.Combine(installedPath, ReferenceAssemblyPath, assembly + ".dll"))) + { + resolvedAssemblies.Add(Path.GetFullPath(Path.Combine(installedPath, ReferenceAssemblyPath, assembly + ".dll"))); + break; + } + } + } + + // Add the facade assemblies + if (ReferenceAssemblyPackage is object) + { + var installedPath = localPathResolver.GetInstalledPath(ReferenceAssemblyPackage) + ?? globalPathResolver.GetInstalledPath(ReferenceAssemblyPackage); + var facadesPath = Path.Combine(installedPath, ReferenceAssemblyPath, "Facades"); + if (Directory.Exists(facadesPath)) + { + foreach (var path in Directory.GetFiles(facadesPath, "*.dll")) + { + resolvedAssemblies.Add(Path.GetFullPath(path)); + } + } + } + + return resolvedAssemblies.Select(MetadataReferences.CreateReferenceFromFile).ToImmutableArray(); + + static string? GetInstalledPath(PackagePathResolver resolver, PackageIdentity id) + { + try + { + return resolver.GetInstalledPath(id); + } + catch (PathTooLongException) + { + return null; + } + } + } + } + + private static async Task GetPackageDependenciesAsync( + PackageIdentity packageIdentity, + NuGetFramework targetFramework, + ImmutableArray repositories, + SourceCacheContext cacheContext, + ILogger logger, + ImmutableDictionary.Builder dependencies, + CancellationToken cancellationToken) + { + if (dependencies.ContainsKey(packageIdentity)) + { + return; + } + + foreach (var sourceRepository in repositories) + { + var dependencyInfoResource = await sourceRepository.GetResourceAsync(cancellationToken); + var dependencyInfo = await dependencyInfoResource.ResolvePackage( + packageIdentity, + targetFramework, +#if !NET452 + cacheContext, +#endif + logger, + cancellationToken); + if (dependencyInfo is null) + { + continue; + } + + dependencies.Add(packageIdentity, dependencyInfo); + foreach (var dependency in dependencyInfo.Dependencies) + { + await GetPackageDependenciesAsync(new PackageIdentity(dependency.Id, dependency.VersionRange.MinVersion), targetFramework, repositories, cacheContext, logger, dependencies, cancellationToken); + } + + break; + } + } + + public static class NetFramework + { + public static class Net20 + { + public static ReferenceAssemblies Default { get; } + = new ReferenceAssemblies( + "net20", + new PackageIdentity( + "Microsoft.NETFramework.ReferenceAssemblies.net20", + NuGetVersion.Parse(ReferenceAssembliesPackageVersion)), + @"build\.NETFramework\v2.0") + .WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default) + .AddAssemblies(ImmutableArray.Create("mscorlib", "System", "System.Data", "System.Xml")) + .AddLanguageSpecificAssemblies(LanguageNames.VisualBasic, ImmutableArray.Create("Microsoft.VisualBasic")); + + public static ReferenceAssemblies WindowsForms { get; } + = Default.AddAssemblies(ImmutableArray.Create("System.Drawing", "System.Windows.Forms")); + } + + public static class Net40 + { + public static ReferenceAssemblies Default { get; } + = new ReferenceAssemblies( + "net40", + new PackageIdentity( + "Microsoft.NETFramework.ReferenceAssemblies.net40", + NuGetVersion.Parse(ReferenceAssembliesPackageVersion)), + @"build\.NETFramework\v4.0") + .WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default) + .AddAssemblies(ImmutableArray.Create("mscorlib", "System", "System.Core", "System.Data", "System.Data.DataSetExtensions", "System.Xml", "System.Xml.Linq")) + .AddLanguageSpecificAssemblies(LanguageNames.CSharp, ImmutableArray.Create("Microsoft.CSharp")) + .AddLanguageSpecificAssemblies(LanguageNames.VisualBasic, ImmutableArray.Create("Microsoft.VisualBasic")); + + public static ReferenceAssemblies WindowsForms { get; } + = Default.AddAssemblies(ImmutableArray.Create("System.Deployment", "System.Drawing", "System.Windows.Forms")); + + public static ReferenceAssemblies Wpf { get; } + = Default.AddAssemblies(ImmutableArray.Create("PresentationCore", "PresentationFramework", "System.Xaml", "WindowsBase")); + } + + public static class Net45 + { + public static ReferenceAssemblies Default { get; } + = new ReferenceAssemblies( + "net45", + new PackageIdentity( + "Microsoft.NETFramework.ReferenceAssemblies.net45", + NuGetVersion.Parse(ReferenceAssembliesPackageVersion)), + @"build\.NETFramework\v4.5") + .WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default) + .AddAssemblies(ImmutableArray.Create("mscorlib", "System", "System.Core", "System.Data", "System.Data.DataSetExtensions", "System.Net.Http", "System.Xml", "System.Xml.Linq")) + .AddLanguageSpecificAssemblies(LanguageNames.CSharp, ImmutableArray.Create("Microsoft.CSharp")) + .AddLanguageSpecificAssemblies(LanguageNames.VisualBasic, ImmutableArray.Create("Microsoft.VisualBasic")); + + public static ReferenceAssemblies WindowsForms { get; } + = Default.AddAssemblies(ImmutableArray.Create("System.Deployment", "System.Drawing", "System.Windows.Forms")); + + public static ReferenceAssemblies Wpf { get; } + = Default.AddAssemblies(ImmutableArray.Create("PresentationCore", "PresentationFramework", "System.Xaml", "WindowsBase")); + } + + public static class Net451 + { + public static ReferenceAssemblies Default { get; } + = new ReferenceAssemblies( + "net451", + new PackageIdentity( + "Microsoft.NETFramework.ReferenceAssemblies.net451", + NuGetVersion.Parse(ReferenceAssembliesPackageVersion)), + @"build\.NETFramework\v4.5.1") + .WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default) + .AddAssemblies(ImmutableArray.Create("mscorlib", "System", "System.Core", "System.Data", "System.Data.DataSetExtensions", "System.Net.Http", "System.Xml", "System.Xml.Linq")) + .AddLanguageSpecificAssemblies(LanguageNames.CSharp, ImmutableArray.Create("Microsoft.CSharp")) + .AddLanguageSpecificAssemblies(LanguageNames.VisualBasic, ImmutableArray.Create("Microsoft.VisualBasic")); + + public static ReferenceAssemblies WindowsForms { get; } + = Default.AddAssemblies(ImmutableArray.Create("System.Deployment", "System.Drawing", "System.Windows.Forms")); + + public static ReferenceAssemblies Wpf { get; } + = Default.AddAssemblies(ImmutableArray.Create("PresentationCore", "PresentationFramework", "System.Xaml", "WindowsBase")); + } + + public static class Net452 + { + public static ReferenceAssemblies Default { get; } + = new ReferenceAssemblies( + "net452", + new PackageIdentity( + "Microsoft.NETFramework.ReferenceAssemblies.net452", + NuGetVersion.Parse(ReferenceAssembliesPackageVersion)), + @"build\.NETFramework\v4.5.2") + .WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default) + .AddAssemblies(ImmutableArray.Create("mscorlib", "System", "System.Core", "System.Data", "System.Data.DataSetExtensions", "System.Net.Http", "System.Xml", "System.Xml.Linq")) + .AddLanguageSpecificAssemblies(LanguageNames.CSharp, ImmutableArray.Create("Microsoft.CSharp")) + .AddLanguageSpecificAssemblies(LanguageNames.VisualBasic, ImmutableArray.Create("Microsoft.VisualBasic")); + + public static ReferenceAssemblies WindowsForms { get; } + = Default.AddAssemblies(ImmutableArray.Create("System.Deployment", "System.Drawing", "System.Windows.Forms")); + + public static ReferenceAssemblies Wpf { get; } + = Default.AddAssemblies(ImmutableArray.Create("PresentationCore", "PresentationFramework", "System.Xaml", "WindowsBase")); + } + + public static class Net46 + { + public static ReferenceAssemblies Default { get; } + = new ReferenceAssemblies( + "net46", + new PackageIdentity( + "Microsoft.NETFramework.ReferenceAssemblies.net46", + NuGetVersion.Parse(ReferenceAssembliesPackageVersion)), + @"build\.NETFramework\v4.6") + .WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default) + .AddAssemblies(ImmutableArray.Create("mscorlib", "System", "System.Core", "System.Data", "System.Data.DataSetExtensions", "System.Net.Http", "System.Xml", "System.Xml.Linq")) + .AddLanguageSpecificAssemblies(LanguageNames.CSharp, ImmutableArray.Create("Microsoft.CSharp")) + .AddLanguageSpecificAssemblies(LanguageNames.VisualBasic, ImmutableArray.Create("Microsoft.VisualBasic")); + + public static ReferenceAssemblies WindowsForms { get; } + = Default.AddAssemblies(ImmutableArray.Create("System.Deployment", "System.Drawing", "System.Windows.Forms")); + + public static ReferenceAssemblies Wpf { get; } + = Default.AddAssemblies(ImmutableArray.Create("PresentationCore", "PresentationFramework", "System.Xaml", "WindowsBase")); + } + + public static class Net461 + { + public static ReferenceAssemblies Default { get; } + = new ReferenceAssemblies( + "net461", + new PackageIdentity( + "Microsoft.NETFramework.ReferenceAssemblies.net461", + NuGetVersion.Parse(ReferenceAssembliesPackageVersion)), + @"build\.NETFramework\v4.6.1") + .WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default) + .AddAssemblies(ImmutableArray.Create("mscorlib", "System", "System.Core", "System.Data", "System.Data.DataSetExtensions", "System.Net.Http", "System.Xml", "System.Xml.Linq")) + .AddLanguageSpecificAssemblies(LanguageNames.CSharp, ImmutableArray.Create("Microsoft.CSharp")) + .AddLanguageSpecificAssemblies(LanguageNames.VisualBasic, ImmutableArray.Create("Microsoft.VisualBasic")); + + public static ReferenceAssemblies WindowsForms { get; } + = Default.AddAssemblies(ImmutableArray.Create("System.Deployment", "System.Drawing", "System.Windows.Forms")); + + public static ReferenceAssemblies Wpf { get; } + = Default.AddAssemblies(ImmutableArray.Create("PresentationCore", "PresentationFramework", "System.Xaml", "WindowsBase")); + } + + public static class Net462 + { + public static ReferenceAssemblies Default { get; } + = new ReferenceAssemblies( + "net462", + new PackageIdentity( + "Microsoft.NETFramework.ReferenceAssemblies.net462", + NuGetVersion.Parse(ReferenceAssembliesPackageVersion)), + @"build\.NETFramework\v4.6.2") + .WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default) + .AddAssemblies(ImmutableArray.Create("mscorlib", "System", "System.Core", "System.Data", "System.Data.DataSetExtensions", "System.Net.Http", "System.Xml", "System.Xml.Linq")) + .AddLanguageSpecificAssemblies(LanguageNames.CSharp, ImmutableArray.Create("Microsoft.CSharp")) + .AddLanguageSpecificAssemblies(LanguageNames.VisualBasic, ImmutableArray.Create("Microsoft.VisualBasic")); + + public static ReferenceAssemblies WindowsForms { get; } + = Default.AddAssemblies(ImmutableArray.Create("System.Deployment", "System.Drawing", "System.Windows.Forms")); + + public static ReferenceAssemblies Wpf { get; } + = Default.AddAssemblies(ImmutableArray.Create("PresentationCore", "PresentationFramework", "System.Xaml", "WindowsBase")); + } + + public static class Net47 + { + public static ReferenceAssemblies Default { get; } + = new ReferenceAssemblies( + "net47", + new PackageIdentity( + "Microsoft.NETFramework.ReferenceAssemblies.net47", + NuGetVersion.Parse(ReferenceAssembliesPackageVersion)), + @"build\.NETFramework\v4.7") + .WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default) + .AddAssemblies(ImmutableArray.Create("mscorlib", "System", "System.Core", "System.Data", "System.Data.DataSetExtensions", "System.Net.Http", "System.Xml", "System.Xml.Linq")) + .AddLanguageSpecificAssemblies(LanguageNames.CSharp, ImmutableArray.Create("Microsoft.CSharp")) + .AddLanguageSpecificAssemblies(LanguageNames.VisualBasic, ImmutableArray.Create("Microsoft.VisualBasic")); + + public static ReferenceAssemblies WindowsForms { get; } + = Default.AddAssemblies(ImmutableArray.Create("System.Deployment", "System.Drawing", "System.Windows.Forms")); + + public static ReferenceAssemblies Wpf { get; } + = Default.AddAssemblies(ImmutableArray.Create("PresentationCore", "PresentationFramework", "System.Xaml", "WindowsBase")); + } + + public static class Net471 + { + public static ReferenceAssemblies Default { get; } + = new ReferenceAssemblies( + "net471", + new PackageIdentity( + "Microsoft.NETFramework.ReferenceAssemblies.net471", + NuGetVersion.Parse(ReferenceAssembliesPackageVersion)), + @"build\.NETFramework\v4.7.1") + .WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default) + .AddAssemblies(ImmutableArray.Create("mscorlib", "System", "System.Core", "System.Data", "System.Data.DataSetExtensions", "System.Net.Http", "System.Xml", "System.Xml.Linq")) + .AddLanguageSpecificAssemblies(LanguageNames.CSharp, ImmutableArray.Create("Microsoft.CSharp")) + .AddLanguageSpecificAssemblies(LanguageNames.VisualBasic, ImmutableArray.Create("Microsoft.VisualBasic")); + + public static ReferenceAssemblies WindowsForms { get; } + = Default.AddAssemblies(ImmutableArray.Create("System.Deployment", "System.Drawing", "System.Windows.Forms")); + + public static ReferenceAssemblies Wpf { get; } + = Default.AddAssemblies(ImmutableArray.Create("PresentationCore", "PresentationFramework", "System.Xaml", "WindowsBase")); + } + + public static class Net472 + { + public static ReferenceAssemblies Default { get; } + = new ReferenceAssemblies( + "net472", + new PackageIdentity( + "Microsoft.NETFramework.ReferenceAssemblies.net472", + NuGetVersion.Parse(ReferenceAssembliesPackageVersion)), + @"build\.NETFramework\v4.7.2") + .WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default) + .AddAssemblies(ImmutableArray.Create("mscorlib", "System", "System.Core", "System.Data", "System.Data.DataSetExtensions", "System.Net.Http", "System.Xml", "System.Xml.Linq")) + .AddLanguageSpecificAssemblies(LanguageNames.CSharp, ImmutableArray.Create("Microsoft.CSharp")) + .AddLanguageSpecificAssemblies(LanguageNames.VisualBasic, ImmutableArray.Create("Microsoft.VisualBasic")); + + public static ReferenceAssemblies WindowsForms { get; } + = Default.AddAssemblies(ImmutableArray.Create("System.Deployment", "System.Drawing", "System.Windows.Forms")); + + public static ReferenceAssemblies Wpf { get; } + = Default.AddAssemblies(ImmutableArray.Create("PresentationCore", "PresentationFramework", "System.Xaml", "WindowsBase")); + } + + public static class Net48 + { + public static ReferenceAssemblies Default { get; } + = new ReferenceAssemblies( + "net48", + new PackageIdentity( + "Microsoft.NETFramework.ReferenceAssemblies.net48", + NuGetVersion.Parse(ReferenceAssembliesPackageVersion)), + @"build\.NETFramework\v4.8") + .WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default) + .AddAssemblies(ImmutableArray.Create("mscorlib", "System", "System.Core", "System.Data", "System.Data.DataSetExtensions", "System.Net.Http", "System.Xml", "System.Xml.Linq")) + .AddLanguageSpecificAssemblies(LanguageNames.CSharp, ImmutableArray.Create("Microsoft.CSharp")) + .AddLanguageSpecificAssemblies(LanguageNames.VisualBasic, ImmutableArray.Create("Microsoft.VisualBasic")); + + public static ReferenceAssemblies WindowsForms { get; } + = Default.AddAssemblies(ImmutableArray.Create("System.Deployment", "System.Drawing", "System.Windows.Forms")); + + public static ReferenceAssemblies Wpf { get; } + = Default.AddAssemblies(ImmutableArray.Create("PresentationCore", "PresentationFramework", "System.Xaml", "WindowsBase")); + } + } + + public static class NetCore + { + public static ReferenceAssemblies NetCoreApp10 { get; } + = new ReferenceAssemblies("netcoreapp1.0") + .AddPackages(ImmutableArray.Create(new PackageIdentity("Microsoft.NETCore.App", NuGetVersion.Parse("1.0.16")))); + + public static ReferenceAssemblies NetCoreApp11 { get; } + = new ReferenceAssemblies("netcoreapp1.1") + .AddPackages(ImmutableArray.Create(new PackageIdentity("Microsoft.NETCore.App", NuGetVersion.Parse("1.1.13")))); + + public static ReferenceAssemblies NetCoreApp20 { get; } + = new ReferenceAssemblies("netcoreapp2.0") + .AddPackages(ImmutableArray.Create(new PackageIdentity("Microsoft.NETCore.App", NuGetVersion.Parse("2.0.9")))); + + public static ReferenceAssemblies NetCoreApp21 { get; } + = new ReferenceAssemblies("netcoreapp2.1") + .AddPackages(ImmutableArray.Create(new PackageIdentity("Microsoft.NETCore.App", NuGetVersion.Parse("2.1.13")))); + } + + public static class NetStandard + { + public static ReferenceAssemblies NetStandard10 { get; } + = new ReferenceAssemblies("netstandard1.0") + .AddPackages(ImmutableArray.Create(new PackageIdentity("NETStandard.Library", NuGetVersion.Parse("1.6.1")))); + + public static ReferenceAssemblies NetStandard11 { get; } + = new ReferenceAssemblies("netstandard1.1") + .AddPackages(ImmutableArray.Create(new PackageIdentity("NETStandard.Library", NuGetVersion.Parse("1.6.1")))); + + public static ReferenceAssemblies NetStandard12 { get; } + = new ReferenceAssemblies("netstandard1.2") + .AddPackages(ImmutableArray.Create(new PackageIdentity("NETStandard.Library", NuGetVersion.Parse("1.6.1")))); + + public static ReferenceAssemblies NetStandard13 { get; } + = new ReferenceAssemblies("netstandard1.3") + .AddPackages(ImmutableArray.Create(new PackageIdentity("NETStandard.Library", NuGetVersion.Parse("1.6.1")))); + + public static ReferenceAssemblies NetStandard14 { get; } + = new ReferenceAssemblies("netstandard1.4") + .AddPackages(ImmutableArray.Create(new PackageIdentity("NETStandard.Library", NuGetVersion.Parse("1.6.1")))); + + public static ReferenceAssemblies NetStandard15 { get; } + = new ReferenceAssemblies("netstandard1.5") + .AddPackages(ImmutableArray.Create(new PackageIdentity("NETStandard.Library", NuGetVersion.Parse("1.6.1")))); + + public static ReferenceAssemblies NetStandard16 { get; } + = new ReferenceAssemblies("netstandard1.6") + .AddPackages(ImmutableArray.Create(new PackageIdentity("NETStandard.Library", NuGetVersion.Parse("1.6.1")))); + + public static ReferenceAssemblies NetStandard20 { get; } + = new ReferenceAssemblies( + "netstandard2.0", + new PackageIdentity( + "NETStandard.Library", + NuGetVersion.Parse("2.0.3")), + @"build\netstandard2.0\ref") + .AddAssemblies(ImmutableArray.Create("netstandard")); + } + } +} diff --git a/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.CodeFix.Testing/CodeFixTest`1.cs b/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.CodeFix.Testing/CodeFixTest`1.cs index 240428e68..82865ff60 100644 --- a/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.CodeFix.Testing/CodeFixTest`1.cs +++ b/src/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.CodeFix.Testing/CodeFixTest`1.cs @@ -328,7 +328,7 @@ private async Task VerifyFixAsync( IVerifier verifier, CancellationToken cancellationToken) { - var project = CreateProject(oldState.Sources.ToArray(), oldState.AdditionalFiles.ToArray(), oldState.AdditionalProjects.ToArray(), oldState.AdditionalReferences.ToArray(), language); + var project = await CreateProjectAsync(oldState.Sources.ToArray(), oldState.AdditionalFiles.ToArray(), oldState.AdditionalProjects.ToArray(), oldState.AdditionalReferences.ToArray(), language, cancellationToken); var compilerDiagnostics = await GetCompilerDiagnosticsAsync(project, cancellationToken).ConfigureAwait(false); project = await getFixedProject(analyzers, codeFixProviders, CodeFixIndex, CodeFixEquivalenceKey, project, numberOfIterations, verifier, cancellationToken).ConfigureAwait(false); diff --git a/src/VisualStudio.Roslyn.SDK/Roslyn.SDK/ProjectTemplates/CSharp/Diagnostic/Test/DiagnosticVerifier.Helper.cs b/src/VisualStudio.Roslyn.SDK/Roslyn.SDK/ProjectTemplates/CSharp/Diagnostic/Test/DiagnosticVerifier.Helper.cs index de72e54f8..d0ac9bdd6 100644 --- a/src/VisualStudio.Roslyn.SDK/Roslyn.SDK/ProjectTemplates/CSharp/Diagnostic/Test/DiagnosticVerifier.Helper.cs +++ b/src/VisualStudio.Roslyn.SDK/Roslyn.SDK/ProjectTemplates/CSharp/Diagnostic/Test/DiagnosticVerifier.Helper.cs @@ -15,10 +15,10 @@ namespace TestHelper /// public abstract partial class DiagnosticVerifier { - private static readonly MetadataReference CorlibReference = MetadataReference.CreateFromFile(typeof(object).Assembly.Location); - private static readonly MetadataReference SystemCoreReference = MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location); - private static readonly MetadataReference CSharpSymbolsReference = MetadataReference.CreateFromFile(typeof(CSharpCompilation).Assembly.Location); - private static readonly MetadataReference CodeAnalysisReference = MetadataReference.CreateFromFile(typeof(Compilation).Assembly.Location); + private static readonly MetadataReference CorlibReference = CreateReferenceFromFile(typeof(object).Assembly.Location); + private static readonly MetadataReference SystemCoreReference = CreateReferenceFromFile(typeof(Enumerable).Assembly.Location); + private static readonly MetadataReference CSharpSymbolsReference = CreateReferenceFromFile(typeof(CSharpCompilation).Assembly.Location); + private static readonly MetadataReference CodeAnalysisReference = CreateReferenceFromFile(typeof(Compilation).Assembly.Location); internal static string DefaultFilePathPrefix = "Test"; internal static string CSharpDefaultFileExt = "cs"; diff --git a/tests/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing.UnitTests/CompilerErrorTests.cs b/tests/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing.UnitTests/CompilerErrorTests.cs index b0e020223..6ccc853e4 100644 --- a/tests/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing.UnitTests/CompilerErrorTests.cs +++ b/tests/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing.UnitTests/CompilerErrorTests.cs @@ -2,8 +2,11 @@ using System; using System.Collections.Generic; +using System.Collections.Immutable; using System.Threading.Tasks; using Microsoft.CodeAnalysis.Diagnostics; +using NuGet.Packaging.Core; +using NuGet.Versioning; using Xunit; namespace Microsoft.CodeAnalysis.Testing @@ -214,7 +217,7 @@ End Class } [Fact] - public async Task TestCSharpValueTupleUsage() + public async Task TestCSharpValueTupleUsageNet46() { var testCode = @" class TestClass { @@ -222,7 +225,94 @@ class TestClass { } "; - await new CSharpTest { TestCode = testCode }.RunAsync(); + await new CSharpTest + { + TestState = + { + Sources = { testCode }, + }, + ReferenceAssemblies = ReferenceAssemblies.NetFramework.Net46.Default + .AddPackages(ImmutableArray.Create(new PackageIdentity("System.ValueTuple", NuGetVersion.Parse("4.5.0")))), + }.RunAsync(); + } + + [Fact] + public async Task TestCSharpValueTupleUsageNet472() + { + var testCode = @" +class TestClass { + (int x, int y) TestMethod() { return (0, 1); } +} +"; + + await new CSharpTest + { + TestCode = testCode, + ReferenceAssemblies = ReferenceAssemblies.NetFramework.Net472.Default, + }.RunAsync(); + } + + [Fact] + public async Task TestRoslynCompilerUsage_1() + { + var testCode = @" +using Microsoft.CodeAnalysis.CSharp; +class TestClass { + SyntaxKind TestMethod() => SyntaxKind.CloseBraceToken; +} +"; + + await new CSharpTest + { + TestState = + { + Sources = { testCode }, + }, + ReferenceAssemblies = ReferenceAssemblies.NetFramework.Net452.Default + .AddPackages(ImmutableArray.Create(new PackageIdentity("Microsoft.CodeAnalysis", NuGetVersion.Parse("1.0.1")))), + }.RunAsync(); + } + + [Fact] + public async Task TestRoslynCompilerUsage_2() + { + var testCode = @" +using Microsoft.CodeAnalysis.CSharp; +class TestClass { + SyntaxKind TestMethod() => SyntaxKind.TupleType; +} +"; + + await new CSharpTest + { + TestState = + { + Sources = { testCode }, + }, + ReferenceAssemblies = ReferenceAssemblies.NetFramework.Net46.Default + .AddPackages(ImmutableArray.Create(new PackageIdentity("Microsoft.CodeAnalysis", NuGetVersion.Parse("2.8.2")))), + }.RunAsync(); + } + + [Fact] + public async Task TestRoslynCompilerUsage_3() + { + var testCode = @" +using Microsoft.CodeAnalysis.CSharp; +class TestClass { + SyntaxKind TestMethod() => SyntaxKind.DotDotToken; +} +"; + + await new CSharpTest + { + TestState = + { + Sources = { testCode }, + }, + ReferenceAssemblies = ReferenceAssemblies.NetFramework.Net472.Default + .AddPackages(ImmutableArray.Create(new PackageIdentity("Microsoft.CodeAnalysis", NuGetVersion.Parse("3.3.1")))), + }.RunAsync(); } private class CSharpTest : AnalyzerTest diff --git a/tests/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing.UnitTests/MetadataReferenceTests.cs b/tests/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing.UnitTests/MetadataReferenceTests.cs new file mode 100644 index 000000000..368fad5c3 --- /dev/null +++ b/tests/Microsoft.CodeAnalysis.Testing/Microsoft.CodeAnalysis.Analyzer.Testing.UnitTests/MetadataReferenceTests.cs @@ -0,0 +1,387 @@ +// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System.Threading; +using System.Threading.Tasks; +using Xunit; + +namespace Microsoft.CodeAnalysis.Testing +{ + public class MetadataReferenceTests + { + [Fact] + public async Task ResolveReferenceAssemblies_Net20() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net20.Default; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net20_WindowsForms() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net20.WindowsForms; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net40() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net40.Default; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net40_WindowsForms() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net40.WindowsForms; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net40_Wpf() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net40.Wpf; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net45() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net45.Default; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net45_WindowsForms() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net45.WindowsForms; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net45_Wpf() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net45.Wpf; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net451() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net451.Default; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net451_WindowsForms() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net451.WindowsForms; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net451_Wpf() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net451.Wpf; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net452() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net452.Default; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net452_WindowsForms() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net452.WindowsForms; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net452_Wpf() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net452.Wpf; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net46() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net46.Default; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net46_WindowsForms() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net46.WindowsForms; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net46_Wpf() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net46.Wpf; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net461() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net461.Default; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net461_WindowsForms() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net461.WindowsForms; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net461_Wpf() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net461.Wpf; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net462() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net462.Default; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net462_WindowsForms() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net462.WindowsForms; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net462_Wpf() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net462.Wpf; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net47() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net47.Default; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net47_WindowsForms() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net47.WindowsForms; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net47_Wpf() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net47.Wpf; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net471() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net471.Default; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net471_WindowsForms() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net471.WindowsForms; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net471_Wpf() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net471.Wpf; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net472() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net472.Default; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net472_WindowsForms() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net472.WindowsForms; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net472_Wpf() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net472.Wpf; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net48() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net48.Default; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net48_WindowsForms() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net48.WindowsForms; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_Net48_Wpf() + { + var referenceAssemblies = ReferenceAssemblies.NetFramework.Net48.Wpf; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_NetStandard10() + { + var referenceAssemblies = ReferenceAssemblies.NetStandard.NetStandard10; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_NetStandard11() + { + var referenceAssemblies = ReferenceAssemblies.NetStandard.NetStandard11; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_NetStandard12() + { + var referenceAssemblies = ReferenceAssemblies.NetStandard.NetStandard12; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_NetStandard13() + { + var referenceAssemblies = ReferenceAssemblies.NetStandard.NetStandard13; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_NetStandard14() + { + var referenceAssemblies = ReferenceAssemblies.NetStandard.NetStandard14; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_NetStandard15() + { + var referenceAssemblies = ReferenceAssemblies.NetStandard.NetStandard15; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_NetStandard16() + { + var referenceAssemblies = ReferenceAssemblies.NetStandard.NetStandard16; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_NetStandard20() + { + var referenceAssemblies = ReferenceAssemblies.NetStandard.NetStandard20; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_NetCoreApp10() + { + var referenceAssemblies = ReferenceAssemblies.NetCore.NetCoreApp10; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_NetCoreApp11() + { + var referenceAssemblies = ReferenceAssemblies.NetCore.NetCoreApp11; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_NetCoreApp20() + { + var referenceAssemblies = ReferenceAssemblies.NetCore.NetCoreApp20; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + + [Fact] + public async Task ResolveReferenceAssemblies_NetCoreApp21() + { + var referenceAssemblies = ReferenceAssemblies.NetCore.NetCoreApp21; + var resolved = await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); + Assert.NotEmpty(resolved); + } + } +}