Add support for using different editions of .NET in unit tests

Author: siegfriedpammer

ICSharpCode.Decompiler.Tests/Helpers/RoslynToolset.cs

@@ -18,19 +18,22 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 
-using ICSharpCode.Decompiler.Util;
+using ICSharpCode.Decompiler.Metadata;
 
 using NuGet.Common;
 using NuGet.Packaging;
 using NuGet.Protocol;
 using NuGet.Protocol.Core.Types;
 using NuGet.Versioning;
 
+using NUnit.Framework;
+
 namespace ICSharpCode.Decompiler.Tests.Helpers
 {
 	abstract class AbstractToolset
@@ -50,29 +53,45 @@ public AbstractToolset(string baseDir)
 
 		protected async Task FetchPackage(string packageName, string version, string sourcePath, string outputPath)
 		{
+			if (!Directory.Exists(Path.Combine(Roundtrip.RoundtripAssembly.TestDir, "nuget")))
+				Assert.Fail("No nuget cache found!");
+
 			ILogger logger = NullLogger.Instance;
 			CancellationToken cancellationToken = CancellationToken.None;
-			using MemoryStream packageStream = new MemoryStream();
-
-			await resource.CopyNupkgToStreamAsync(
-				packageName,
-				NuGetVersion.Parse(version),
-				packageStream,
-				cache,
-				logger,
-				cancellationToken).ConfigureAwait(false);
-
-			using PackageArchiveReader packageReader = new PackageArchiveReader(packageStream);
-			NuspecReader nuspecReader = await packageReader.GetNuspecReaderAsync(cancellationToken).ConfigureAwait(false);
-
-			var files = (await packageReader.GetFilesAsync(cancellationToken).ConfigureAwait(false)).ToArray();
-			files = files.Where(f => f.StartsWith(sourcePath, StringComparison.OrdinalIgnoreCase)).ToArray();
-			await packageReader.CopyFilesAsync(outputPath, files,
-				(sourceFile, targetPath, fileStream) => {
-					fileStream.CopyToFile(targetPath);
-					return targetPath;
-				},
-				logger, cancellationToken).ConfigureAwait(false);
+			string pathToPackage = Path.Combine(Roundtrip.RoundtripAssembly.TestDir, "nuget", $"{packageName}-{version}.nupkg");
+			Stream packageStream;
+			if (File.Exists(pathToPackage))
+			{
+				packageStream = File.OpenRead(pathToPackage);
+			}
+			else
+			{
+				packageStream = new MemoryStream();
+
+				await resource.CopyNupkgToStreamAsync(
+					packageName,
+					NuGetVersion.Parse(version),
+					packageStream,
+					cache,
+					logger,
+					cancellationToken).ConfigureAwait(false);
+
+				packageStream.Position = 0;
+			}
+			using (packageStream)
+			{
+				using PackageArchiveReader packageReader = new PackageArchiveReader(packageStream);
+				NuspecReader nuspecReader = await packageReader.GetNuspecReaderAsync(cancellationToken).ConfigureAwait(false);
+
+				var files = (await packageReader.GetFilesAsync(cancellationToken).ConfigureAwait(false)).ToArray();
+				files = files.Where(f => f.StartsWith(sourcePath, StringComparison.OrdinalIgnoreCase)).ToArray();
+				await packageReader.CopyFilesAsync(outputPath, files,
+					(sourceFile, targetPath, fileStream) => {
+						fileStream.CopyToFile(targetPath);
+						return targetPath;
+					},
+					logger, cancellationToken).ConfigureAwait(false);
+			}
 		}
 	}
 
@@ -145,4 +164,44 @@ public async Task Fetch()
 
 		public string GetVsWhere() => vswherePath;
 	}
+
+	class RefAssembliesToolset : AbstractToolset
+	{
+		readonly Dictionary<string, string> installedFrameworks = new Dictionary<string, string> {
+			{ "legacy", Path.Combine(Roundtrip.RoundtripAssembly.TestDir, "dotnet", "legacy") },
+			{ "2.2.0", Path.Combine(Roundtrip.RoundtripAssembly.TestDir, "dotnet", "netcore-2.2") },
+		};
+
+		public RefAssembliesToolset()
+			: base(Path.Combine(AppContext.BaseDirectory, "netfx"))
+		{
+		}
+
+		public async Task Fetch(string version, string packageName = "Microsoft.NETCore.App.Ref", string sourcePath = "ref/net5.0")
+		{
+			string path = Path.Combine(baseDir, version, sourcePath);
+			if (!Directory.Exists(path))
+			{
+				await FetchPackage(packageName, version, sourcePath, Path.Combine(baseDir, version)).ConfigureAwait(false);
+			}
+
+			installedFrameworks.Add(RoslynToolset.SanitizeVersion(version), path);
+		}
+
+		internal string GetPath(string targetFramework)
+		{
+			var (id, version) = UniversalAssemblyResolver.ParseTargetFramework(targetFramework);
+			string path;
+			if (id == TargetFrameworkIdentifier.NETFramework)
+			{
+				path = installedFrameworks["legacy"];
+			}
+			else
+			{
+				path = installedFrameworks[version.ToString(3)];
+			}
+			Debug.Assert(Path.Exists(path));
+			return path;
+		}
+	}
 }

ICSharpCode.Decompiler.Tests/Helpers/Tester.VB.cs

@@ -16,12 +16,9 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 using System;
-using System.CodeDom.Compiler;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Linq;
-using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 
@@ -49,27 +46,30 @@ public static async Task<CompilerResults> CompileVB(string sourceFileName, Compi
 				CompilerResults results = new CompilerResults();
 				results.PathToAssembly = outputFileName;
 
-				var (roslynVersion, languageVersion) = (flags & CompilerOptions.UseRoslynMask) switch {
-					0 => ("legacy", "11"),
-					CompilerOptions.UseRoslyn1_3_2 => ("1.3.2", "14"),
-					CompilerOptions.UseRoslyn2_10_0 => ("2.10.0", "latest"),
-					CompilerOptions.UseRoslyn3_11_0 => ("3.11.0", "latest"),
-					_ => (roslynLatestVersion, flags.HasFlag(CompilerOptions.Preview) ? "preview" : "latest")
+				bool targetNet40 = (flags & CompilerOptions.TargetNet40) != 0;
+
+				var (roslynVersion, languageVersion, targetFramework) = (flags & CompilerOptions.UseRoslynMask) switch {
+					0 => ("legacy", "11", null),
+					CompilerOptions.UseRoslyn1_3_2 => ("1.3.2", "14", null),
+					CompilerOptions.UseRoslyn2_10_0 => ("2.10.0", "latest", targetNet40 ? null : ".NETCoreApp,Version=v2.2"),
+					CompilerOptions.UseRoslyn3_11_0 => ("3.11.0", "latest", targetNet40 ? null : ".NETCoreApp,Version=v5.0"),
+					_ => (roslynLatestVersion, flags.HasFlag(CompilerOptions.Preview) ? "preview" : "latest", targetNet40 ? null : ".NETCoreApp,Version=v10.0")
 				};
 
 				var vbcPath = roslynToolset.GetVBCompiler(roslynVersion);
 
 				IEnumerable<string> references;
 				string libPath;
-				if ((flags & CompilerOptions.UseRoslynMask) != 0 && (flags & CompilerOptions.TargetNet40) == 0)
+				if ((flags & CompilerOptions.UseRoslynMask) != 0 && targetFramework != null)
 				{
+					var coreRefAsmPath = RefAssembliesToolset.GetPath(targetFramework);
 					references = coreDefaultReferences.Select(r => "-r:\"" + r + "\"");
 					libPath = coreRefAsmPath;
 				}
 				else
 				{
 					references = defaultReferences.Select(r => "-r:\"" + r + "\"");
-					libPath = RefAsmPath;
+					libPath = RefAssembliesToolset.GetPath("legacy");
 				}
 				if (flags.HasFlag(CompilerOptions.ReferenceVisualBasic))
 				{
@@ -121,7 +121,7 @@ public static async Task<CompilerResults> CompileVB(string sourceFileName, Compi
 				var command = Cli.Wrap(vbcPath)
 					.WithArguments($"{otherOptions}-libpath:\"{libPath}\" {string.Join(" ", references)} -out:\"{Path.GetFullPath(results.PathToAssembly)}\" {string.Join(" ", sourceFileNames.Select(fn => '"' + Path.GetFullPath(fn) + '"'))}")
 					.WithValidation(CommandResultValidation.None);
-				Console.WriteLine($"\"{command.TargetFilePath}\" {command.Arguments}");
+				//Console.WriteLine($"\"{command.TargetFilePath}\" {command.Arguments}");
 
 				var result = await command.ExecuteBufferedAsync().ConfigureAwait(false);