Remove warnings from terminal when compiling the test runner.

nicrowe00 · nicrowe00 · commit fe2701b72b0b · 2025-02-20T12:46:21.000Z
A fix for the test runner that patches most of the warnings
that are reported in the terminal when compiling the test runner.
Some warnings were suppressed as it was too time-consuming or
there were impacts to other parts of the test runner when they
were fixed.
diff --git a/Turkey/BashTest.cs b/Turkey/BashTest.cs
@@ -38,7 +38,7 @@ protected override async Task<TestResult> InternalRunAsync(Action<string> logger
                 startInfo.EnvironmentVariables.Add(key, value);
             }
 
-            int exitCode = await ProcessRunner.RunAsync(startInfo, logger, cancellationToken);
+            int exitCode = await ProcessRunner.RunAsync(startInfo, logger, cancellationToken).ConfigureAwait(false);
 
             return exitCode == 0 ? TestResult.Passed : TestResult.Failed;
         }
diff --git a/Turkey/Cleaner.cs b/Turkey/Cleaner.cs
@@ -36,7 +36,9 @@ public static IEnumerable<string> LocalProjectCruft()
             yield return "project.lock.json";
         }
 
-        public async Task CleanProjectLocalDotNetCruftAsync()
+#pragma warning disable CA1822 // Mark members as static
+        public Task CleanProjectLocalDotNetCruftAsync()
+#pragma warning restore CA1822 // Mark members as static
         {
 
             foreach(var name in LocalProjectCruft())
@@ -51,9 +53,12 @@ public async Task CleanProjectLocalDotNetCruftAsync()
                     File.Delete(name);
                 }
             }
+            return Task.CompletedTask;
         }
 
-        public async Task CleanLocalDotNetCacheAsync()
+#pragma warning disable CA1822 // Mark members as static
+        public Task CleanLocalDotNetCacheAsync()
+#pragma warning restore CA1822 // Mark members as static
         {
             foreach (var path in CruftDirectoryGlobs())
             {
@@ -77,12 +82,14 @@ public async Task CleanLocalDotNetCacheAsync()
                     Console.WriteLine($"WARNING: unable to expand {path}");
                 }
             }
-            return;
+            return Task.CompletedTask;
         }
 
+#pragma warning disable CA1822 // Mark members as static
         public IEnumerable<string> ExpandPath(string pathWithGlob)
+#pragma warning restore CA1822 // Mark members as static
         {
-            if (pathWithGlob.StartsWith("~"))
+            if (pathWithGlob.StartsWith("~", StringComparison.Ordinal))
             {
                 pathWithGlob = Environment.GetEnvironmentVariable("HOME") + pathWithGlob.Substring(1);
             }
diff --git a/Turkey/DotNet.cs b/Turkey/DotNet.cs
@@ -43,7 +43,7 @@ public List<Version> RuntimeVersions
                     string output = p.StandardOutput.ReadToEnd();
                     var list = output
                         .Split("\n", StringSplitOptions.RemoveEmptyEntries)
-                        .Where(line => line.StartsWith("Microsoft.NETCore.App"))
+                        .Where(line => line.StartsWith("Microsoft.NETCore.App", StringComparison.Ordinal))
                         .Select(line => line.Split(" ")[1])
                         .Select(versionString => Version.Parse(versionString))
                         .OrderBy(x => x)
@@ -137,7 +137,7 @@ private async Task<int> RunDotNetCommandAsync(DirectoryInfo workingDirectory, st
                 startInfo.EnvironmentVariables.Add(key, value);
             }
 
-            return await ProcessRunner.RunAsync(startInfo, logger, token);
+            return await ProcessRunner.RunAsync(startInfo, logger, token).ConfigureAwait(false);
         }
 
         private static bool IsCoreClrRuntime(string dotnetRoot, Version version)
@@ -159,7 +159,9 @@ private static bool IsCoreClrRuntime(string dotnetRoot, Version version)
             return File.Exists(Path.Combine(runtimeDir, "libcoreclrtraceptprovider.so"));
         }
 
+        #nullable enable
         private static string? FindProgramInPath(string program)
+        #nullable disable
         {
             string[] paths = Environment.GetEnvironmentVariable("PATH")?.Split(':', StringSplitOptions.RemoveEmptyEntries) ?? Array.Empty<string>();
             foreach (string p in paths)
diff --git a/Turkey/IEnumerableExtensions.cs b/Turkey/IEnumerableExtensions.cs
@@ -10,7 +10,7 @@ public static async Task ForEachAsync<T>(this IEnumerable<T> items, Func<T, Task
         {
             foreach (T item in items)
             {
-                await task(item);
+                await task(item).ConfigureAwait(false);
             }
         }
     }
diff --git a/Turkey/NuGet.cs b/Turkey/NuGet.cs
@@ -21,27 +21,34 @@ public NuGet(HttpClient client)
         public async Task<bool> IsPackageLiveAsync(string name, Version version)
         {
             var url = $"https://api-v2v3search-0.nuget.org/autocomplete?id={name}&prerelease=true";
-            var result = await _client.GetStringAsync(url);
-            return await IsPackageLiveAsync(name, version, result);
+            Uri uri = new(url);
+            var result = await _client.GetStringAsync(uri).ConfigureAwait(false);
+            return await IsPackageLiveAsync(name, version, result).ConfigureAwait(false);
         }
 
-        public async Task<bool> IsPackageLiveAsync(string name, Version version, string json)
+#pragma warning disable CA1801 // Remove unused parameter
+#pragma warning disable CA1822 // Mark members as static
+        public Task<bool> IsPackageLiveAsync(string name, Version version, string json)
+#pragma warning restore CA1822 // Mark members as static
+#pragma warning restore CA1801 // Remove unused parameter
         {
             JObject deserialized = (JObject) JsonConvert.DeserializeObject(json);
-            JArray versions = (JArray) deserialized.GetValue("data");
+            JArray versions = (JArray) deserialized.GetValue("data", StringComparison.Ordinal);
             var found = versions.Children<JToken>()
-                .Where(v => v.Value<string>().Equals(version.ToString()))
+                .Where(v => v.Value<string>().Equals(version.ToString(), StringComparison.Ordinal))
                 .Any();
-            return found;
+            return Task.FromResult(found);
         }
 
-        public async Task<string> GenerateNuGetConfig(List<string> urls, string nugetConfig = null)
+#pragma warning disable CA1822 // Mark members as static
+        public Task<string> GenerateNuGetConfig(List<string> urls, string nugetConfig = null)
+#pragma warning restore CA1822 // Mark members as static
         {
-            if( !urls.Any() && nugetConfig == null )
-                throw new ArgumentNullException();
+            if (!urls.Any())
+                ArgumentNullException.ThrowIfNull(nugetConfig);
 
             string sources = null;
-            if( urls.Any() )
+            if (urls.Any())
             {
                 var sourceParts = new List<string>(urls.Count);
                 for( int i = 0; i < urls.Count; i++ )
@@ -54,6 +61,7 @@ public async Task<string> GenerateNuGetConfig(List<string> urls, string nugetCon
                 {
                     sources = $"    {sources}\n";
                 }
+            
             }
 
             if( string.IsNullOrWhiteSpace(nugetConfig) )
@@ -66,9 +74,9 @@ public async Task<string> GenerateNuGetConfig(List<string> urls, string nugetCon
             }
 
             if( !string.IsNullOrWhiteSpace(sources) )
-                nugetConfig = nugetConfig.Replace("</packageSources>", sources + "</packageSources>");
+                nugetConfig = nugetConfig.Replace("</packageSources>", sources + "</packageSources>", StringComparison.Ordinal);
 
-            return nugetConfig;
+            return Task.FromResult(nugetConfig);
         }
 
     }
diff --git a/Turkey/PlatformId.cs b/Turkey/PlatformId.cs
@@ -18,7 +18,9 @@ public List<string> CurrentIds
 
         public List<string> ComputePlatformIds(string[] osReleaseLines, string lddVersionOutput)
         {
-            string arch = Enum.GetName(typeof(Architecture), RuntimeInformation.OSArchitecture).ToLowerInvariant();
+            #pragma warning disable CA1308 // Normalize strings to uppercase
+            string arch = RuntimeInformation.OSArchitecture.ToString().ToLowerInvariant();
+            #pragma warning restore CA1308 // Normalize strings to uppercase
             return ComputePlatformIds(osReleaseLines, arch, lddVersionOutput);
         }
 
@@ -63,25 +65,27 @@ public List<string> ComputePlatformIds(string[] osReleaseLines, string architect
             return platforms.ToList();
         }
 
-        private string GetValue(string key, string[] lines)
+        private static string GetValue(string key, string[] lines)
         {
             return lines.Where(line => line.StartsWith(key + "=", StringComparison.Ordinal)).Last().Substring((key + "=").Length);
         }
 
-        private string Unquote(string text)
+        private static string Unquote(string text)
         {
             // TODO implement proper un-escaping
             // This is a limited shell-style syntax described at
             // https://www.freedesktop.org/software/systemd/man/os-release.html
-            if (text.StartsWith("\"") && text.EndsWith("\""))
+            if (text.StartsWith("\"", StringComparison.Ordinal) && text.EndsWith("\"", StringComparison.Ordinal))
             {
                 return text.Substring(1, text.Length - 2);
             }
 
             return text;
         }
 
+#pragma warning disable CA1822 // Mark members as static
         internal string GetLddVersion()
+#pragma warning restore CA1822 // Mark members as static
         {
             using (Process p = new Process())
             {
diff --git a/Turkey/ProcessExtensions.cs b/Turkey/ProcessExtensions.cs
@@ -12,7 +12,7 @@ public static async Task<int> RunAsync(ProcessStartInfo psi, Action<string> logg
         {
             logger($"Executing {psi.FileName} with arguments {psi.Arguments} in working directory {psi.WorkingDirectory}");
             using var process = Process.Start(psi);
-            await process.WaitForExitAsync(logger, token);
+            await process.WaitForExitAsync(logger, token).ConfigureAwait(false);
             return process.ExitCode;
         }
     }
@@ -43,11 +43,11 @@ public static async Task WaitForExitAsync(this Process process, Action<string> l
 
             try
             {
-                await process.WaitForExitAsync(token);
+                await process.WaitForExitAsync(token).ConfigureAwait(false);
 
                 logger($"Process Exit Code: {process.ExitCode}");
             }
-            catch (OperationCanceledException ex)
+            catch (OperationCanceledException)
             {
                 lock (logger)
                 {
diff --git a/Turkey/Program.cs b/Turkey/Program.cs
@@ -12,7 +12,9 @@
 
 namespace Turkey
 {
+#pragma warning disable CA1052 // Static holder types should be Static or NotInheritable
     public class Program
+#pragma warning restore CA1052 // Static holder types should be Static or NotInheritable
     {
         public static readonly Option<bool> verboseOption = new Option<bool>(
             new string[] { "--verbose", "-v" },
@@ -118,7 +120,7 @@ public static async Task<int> Run(string testRoot,
 
             Version packageVersion = runtimeVersion;
             string nuGetConfig = await GenerateNuGetConfigIfNeededAsync(additionalFeed, packageVersion,
-                                                                        useSourceBuildNuGetConfig: false);
+                                                                        useSourceBuildNuGetConfig: false).ConfigureAwait(false);
             if (verbose && nuGetConfig != null)
             {
                 Console.WriteLine("Using nuget.config: ");
@@ -132,7 +134,7 @@ public static async Task<int> Run(string testRoot,
                 verboseOutput: verbose,
                 nuGetConfig: nuGetConfig);
 
-            var results = await runner.ScanAndRunAsync(testOutputs, logDir.FullName, defaultTimeout);
+            var results = await runner.ScanAndRunAsync(testOutputs, logDir.FullName, defaultTimeout).ConfigureAwait(false);
 
             int exitCode = (results.Failed == 0) ? 0 : 1;
             return exitCode;
@@ -157,7 +159,7 @@ public static async Task<string> GenerateNuGetConfigIfNeededAsync(string additio
                 {
                     try
                     {
-                        nugetConfig = await sourceBuild.GetNuGetConfigAsync(netCoreAppVersion);
+                        nugetConfig = await sourceBuild.GetNuGetConfigAsync(netCoreAppVersion).ConfigureAwait(false);
                     }
                     catch( HttpRequestException exception )
                     {
@@ -173,14 +175,16 @@ public static async Task<string> GenerateNuGetConfigIfNeededAsync(string additio
                     // if the nugetConfig has a <clear/> element that removes
                     // it.
                     urls.Add("https://api.nuget.org/v3/index.json");
-                    return await nuget.GenerateNuGetConfig(urls, nugetConfig);
+                    return await nuget.GenerateNuGetConfig(urls, nugetConfig).ConfigureAwait(false);
                 }
             }
 
             return null;
         }
 
+#pragma warning disable CA1801 // Remove unused parameter
         public static IReadOnlySet<string> CreateTraits(Version runtimeVersion, Version sdkVersion, List<string> rids, bool isMonoRuntime, IEnumerable<string> additionalTraits)
+#pragma warning restore CA1801 // Remove unused parameter
         {
             var traits = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
 
@@ -199,7 +203,9 @@ public static IReadOnlySet<string> CreateTraits(Version runtimeVersion, Version
             }
 
             // Add 'arch=' trait.
+#pragma warning disable CA1308 // Normalize strings to uppercase
             string arch = RuntimeInformation.OSArchitecture.ToString().ToLowerInvariant();
+#pragma warning restore CA1308 // Normalize strings to uppercase
             traits.Add($"arch={arch}");
 
             // Add 'runtime=' trait.
@@ -231,7 +237,7 @@ static async Task<int> Main(string[] args)
             rootCommand.AddOption(traitOption);
             rootCommand.AddOption(timeoutOption);
 
-            return await rootCommand.InvokeAsync(args);
+            return await rootCommand.InvokeAsync(args).ConfigureAwait(false);
         }
     }
-}
+}
diff --git a/Turkey/SourceBuild.cs b/Turkey/SourceBuild.cs
@@ -16,11 +16,12 @@ public SourceBuild(HttpClient client)
             this._client = client;
         }
 
-        public string GetBranchContentUrl(Version version)
+        public static System.Uri GetBranchContentUrl(Version version)
         {
             var branchName = "release/" + version.MajorMinor + ".1xx";
             var url = $"https://raw.githubusercontent.com/dotnet/installer/{branchName}/";
-            return url;
+            Uri uri = new(url);
+            return uri;
         }
 
         public async Task<string> GetProdConFeedAsync(Version version)
@@ -31,9 +32,10 @@ public async Task<string> GetProdConFeedAsync(Version version)
             }
 
             var url = GetBranchContentUrl(version) + "ProdConFeed.txt";
-            var feedUrl = await _client.GetStringAsync(url);
-
-            using(var response = await _client.GetAsync(feedUrl))
+            Uri uri = new(url);
+            var feedUrl = await _client.GetStringAsync(uri).ConfigureAwait(false);
+            Uri feedUri = new(feedUrl);
+            using(var response = await _client.GetAsync(feedUri).ConfigureAwait(false))
             {
                 if (!response.IsSuccessStatusCode)
                 {
@@ -46,11 +48,12 @@ public async Task<string> GetProdConFeedAsync(Version version)
         public async Task<string> GetNuGetConfigAsync(Version version)
         {
             string url = GetBranchContentUrl(version) + "NuGet.config";
+            Uri uri = new(url);
 
             string nugetConfig = null;
             try
             {
-                nugetConfig = await _client.GetStringAsync(url);
+                nugetConfig = await _client.GetStringAsync(uri).ConfigureAwait(false);
             }
             catch( HttpRequestException e )
             {
diff --git a/Turkey/Test.cs b/Turkey/Test.cs
@@ -18,8 +18,12 @@ public class TestDescriptor
         public string Type { get; set; }
         public bool Cleanup { get; set; }
         public double TimeoutMultiplier { get; set; } = 1.0;
+
+        #pragma warning disable CA2227 // Change to be read-only by removing the property setter.
         public List<string> IgnoredRIDs { get; set; } = new();
         public List<string> SkipWhen { get; set; } = new();
+
+        #pragma warning restore CA2227
     }
 
     // TODO is this a strongly-typed enum in C#?
@@ -58,10 +62,10 @@ public async Task<TestResult> RunAsync(Action<string> logger, CancellationToken
                 {
                     Console.WriteLine($"WARNING: overwriting {path}");
                 }
-                await File.WriteAllTextAsync(path, NuGetConfig);
+                await File.WriteAllTextAsync(path, NuGetConfig).ConfigureAwait(false);
             }
 
-            var testResult = await InternalRunAsync(logger, cancelltionToken);
+            var testResult = await InternalRunAsync(logger, cancelltionToken).ConfigureAwait(false);
 
             if (!string.IsNullOrEmpty(NuGetConfig))
             {
diff --git a/Turkey/TestOutputFormat.cs b/Turkey/TestOutputFormat.cs
diff --git a/Turkey/TestParser.cs b/Turkey/TestParser.cs
diff --git a/Turkey/TestRunner.cs b/Turkey/TestRunner.cs
diff --git a/Turkey/Version.cs b/Turkey/Version.cs
diff --git a/Turkey/XUnitTest.cs b/Turkey/XUnitTest.cs

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ protected override async Task<TestResult> InternalRunAsync(Action<string> logger`
`38`	`38`	`startInfo.EnvironmentVariables.Add(key, value);`
`39`	`39`	`}`
`40`	`40`
`41`		`- int exitCode = await ProcessRunner.RunAsync(startInfo, logger, cancellationToken);`
	`41`	`+ int exitCode = await ProcessRunner.RunAsync(startInfo, logger, cancellationToken).ConfigureAwait(false);`
`42`	`42`
`43`	`43`	`return exitCode == 0 ? TestResult.Passed : TestResult.Failed;`
`44`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,9 @@ public static IEnumerable<string> LocalProjectCruft()`
`36`	`36`	`yield return "project.lock.json";`
`37`	`37`	`}`
`38`	`38`
`39`		`- public async Task CleanProjectLocalDotNetCruftAsync()`
	`39`	`+#pragma warning disable CA1822 // Mark members as static`
	`40`	`+ public Task CleanProjectLocalDotNetCruftAsync()`
	`41`	`+#pragma warning restore CA1822 // Mark members as static`
`40`	`42`	`{`
`41`	`43`
`42`	`44`	`foreach(var name in LocalProjectCruft())`
`@@ -51,9 +53,12 @@ public async Task CleanProjectLocalDotNetCruftAsync()`
`51`	`53`	`File.Delete(name);`
`52`	`54`	`}`
`53`	`55`	`}`
	`56`	`+ return Task.CompletedTask;`
`54`	`57`	`}`
`55`	`58`
`56`		`- public async Task CleanLocalDotNetCacheAsync()`
	`59`	`+#pragma warning disable CA1822 // Mark members as static`
	`60`	`+ public Task CleanLocalDotNetCacheAsync()`
	`61`	`+#pragma warning restore CA1822 // Mark members as static`
`57`	`62`	`{`
`58`	`63`	`foreach (var path in CruftDirectoryGlobs())`
`59`	`64`	`{`
`@@ -77,12 +82,14 @@ public async Task CleanLocalDotNetCacheAsync()`
`77`	`82`	`Console.WriteLine($"WARNING: unable to expand {path}");`
`78`	`83`	`}`
`79`	`84`	`}`
`80`		`- return;`
	`85`	`+ return Task.CompletedTask;`
`81`	`86`	`}`
`82`	`87`
	`88`	`+#pragma warning disable CA1822 // Mark members as static`
`83`	`89`	`public IEnumerable<string> ExpandPath(string pathWithGlob)`
	`90`	`+#pragma warning restore CA1822 // Mark members as static`
`84`	`91`	`{`
`85`		`- if (pathWithGlob.StartsWith("~"))`
	`92`	`+ if (pathWithGlob.StartsWith("~", StringComparison.Ordinal))`
`86`	`93`	`{`
`87`	`94`	`pathWithGlob = Environment.GetEnvironmentVariable("HOME") + pathWithGlob.Substring(1);`
`88`	`95`	`}`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ public List<Version> RuntimeVersions`
`43`	`43`	`string output = p.StandardOutput.ReadToEnd();`
`44`	`44`	`var list = output`
`45`	`45`	`.Split("\n", StringSplitOptions.RemoveEmptyEntries)`
`46`		`- .Where(line => line.StartsWith("Microsoft.NETCore.App"))`
	`46`	`+ .Where(line => line.StartsWith("Microsoft.NETCore.App", StringComparison.Ordinal))`
`47`	`47`	`.Select(line => line.Split(" ")[1])`
`48`	`48`	`.Select(versionString => Version.Parse(versionString))`
`49`	`49`	`.OrderBy(x => x)`
`@@ -137,7 +137,7 @@ private async Task<int> RunDotNetCommandAsync(DirectoryInfo workingDirectory, st`
`137`	`137`	`startInfo.EnvironmentVariables.Add(key, value);`
`138`	`138`	`}`
`139`	`139`
`140`		`- return await ProcessRunner.RunAsync(startInfo, logger, token);`
	`140`	`+ return await ProcessRunner.RunAsync(startInfo, logger, token).ConfigureAwait(false);`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`private static bool IsCoreClrRuntime(string dotnetRoot, Version version)`
`@@ -159,7 +159,9 @@ private static bool IsCoreClrRuntime(string dotnetRoot, Version version)`
`159`	`159`	`return File.Exists(Path.Combine(runtimeDir, "libcoreclrtraceptprovider.so"));`
`160`	`160`	`}`
`161`	`161`
	`162`	`+ #nullable enable`
`162`	`163`	`private static string? FindProgramInPath(string program)`
	`164`	`+ #nullable disable`
`163`	`165`	`{`
`164`	`166`	`string[] paths = Environment.GetEnvironmentVariable("PATH")?.Split(':', StringSplitOptions.RemoveEmptyEntries) ?? Array.Empty<string>();`
`165`	`167`	`foreach (string p in paths)`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ public static async Task ForEachAsync<T>(this IEnumerable<T> items, Func<T, Task`
`10`	`10`	`{`
`11`	`11`	`foreach (T item in items)`
`12`	`12`	`{`
`13`		`- await task(item);`
	`13`	`+ await task(item).ConfigureAwait(false);`
`14`	`14`	`}`
`15`	`15`	`}`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,27 +21,34 @@ public NuGet(HttpClient client)`
`21`	`21`	`public async Task<bool> IsPackageLiveAsync(string name, Version version)`
`22`	`22`	`{`
`23`	`23`	`var url = $"https://api-v2v3search-0.nuget.org/autocomplete?id={name}&prerelease=true";`
`24`		`- var result = await _client.GetStringAsync(url);`
`25`		`- return await IsPackageLiveAsync(name, version, result);`
	`24`	`+ Uri uri = new(url);`
	`25`	`+ var result = await _client.GetStringAsync(uri).ConfigureAwait(false);`
	`26`	`+ return await IsPackageLiveAsync(name, version, result).ConfigureAwait(false);`
`26`	`27`	`}`
`27`	`28`
`28`		`- public async Task<bool> IsPackageLiveAsync(string name, Version version, string json)`
	`29`	`+#pragma warning disable CA1801 // Remove unused parameter`
	`30`	`+#pragma warning disable CA1822 // Mark members as static`
	`31`	`+ public Task<bool> IsPackageLiveAsync(string name, Version version, string json)`
	`32`	`+#pragma warning restore CA1822 // Mark members as static`
	`33`	`+#pragma warning restore CA1801 // Remove unused parameter`
`29`	`34`	`{`
`30`	`35`	`JObject deserialized = (JObject) JsonConvert.DeserializeObject(json);`
`31`		`- JArray versions = (JArray) deserialized.GetValue("data");`
	`36`	`+ JArray versions = (JArray) deserialized.GetValue("data", StringComparison.Ordinal);`
`32`	`37`	`var found = versions.Children<JToken>()`
`33`		`- .Where(v => v.Value<string>().Equals(version.ToString()))`
	`38`	`+ .Where(v => v.Value<string>().Equals(version.ToString(), StringComparison.Ordinal))`
`34`	`39`	`.Any();`
`35`		`- return found;`
	`40`	`+ return Task.FromResult(found);`
`36`	`41`	`}`
`37`	`42`
`38`		`- public async Task<string> GenerateNuGetConfig(List<string> urls, string nugetConfig = null)`
	`43`	`+#pragma warning disable CA1822 // Mark members as static`
	`44`	`+ public Task<string> GenerateNuGetConfig(List<string> urls, string nugetConfig = null)`
	`45`	`+#pragma warning restore CA1822 // Mark members as static`
`39`	`46`	`{`
`40`		`- if( !urls.Any() && nugetConfig == null )`
`41`		`- throw new ArgumentNullException();`
	`47`	`+ if (!urls.Any())`
	`48`	`+ ArgumentNullException.ThrowIfNull(nugetConfig);`
`42`	`49`
`43`	`50`	`string sources = null;`
`44`		`- if( urls.Any() )`
	`51`	`+ if (urls.Any())`
`45`	`52`	`{`
`46`	`53`	`var sourceParts = new List<string>(urls.Count);`
`47`	`54`	`for( int i = 0; i < urls.Count; i++ )`
`@@ -54,6 +61,7 @@ public async Task<string> GenerateNuGetConfig(List<string> urls, string nugetCon`
`54`	`61`	`{`
`55`	`62`	`sources = $" {sources}\n";`
`56`	`63`	`}`
	`64`	`+`
`57`	`65`	`}`
`58`	`66`
`59`	`67`	`if( string.IsNullOrWhiteSpace(nugetConfig) )`
`@@ -66,9 +74,9 @@ public async Task<string> GenerateNuGetConfig(List<string> urls, string nugetCon`
`66`	`74`	`}`
`67`	`75`
`68`	`76`	`if( !string.IsNullOrWhiteSpace(sources) )`
`69`		`- nugetConfig = nugetConfig.Replace("</packageSources>", sources + "</packageSources>");`
	`77`	`+ nugetConfig = nugetConfig.Replace("</packageSources>", sources + "</packageSources>", StringComparison.Ordinal);`
`70`	`78`
`71`		`- return nugetConfig;`
	`79`	`+ return Task.FromResult(nugetConfig);`
`72`	`80`	`}`
`73`	`81`
`74`	`82`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,9 @@ public List<string> CurrentIds`
`18`	`18`
`19`	`19`	`public List<string> ComputePlatformIds(string[] osReleaseLines, string lddVersionOutput)`
`20`	`20`	`{`
`21`		`- string arch = Enum.GetName(typeof(Architecture), RuntimeInformation.OSArchitecture).ToLowerInvariant();`
	`21`	`+ #pragma warning disable CA1308 // Normalize strings to uppercase`
	`22`	`+ string arch = RuntimeInformation.OSArchitecture.ToString().ToLowerInvariant();`
	`23`	`+ #pragma warning restore CA1308 // Normalize strings to uppercase`
`22`	`24`	`return ComputePlatformIds(osReleaseLines, arch, lddVersionOutput);`
`23`	`25`	`}`
`24`	`26`
`@@ -63,25 +65,27 @@ public List<string> ComputePlatformIds(string[] osReleaseLines, string architect`
`63`	`65`	`return platforms.ToList();`
`64`	`66`	`}`
`65`	`67`
`66`		`- private string GetValue(string key, string[] lines)`
	`68`	`+ private static string GetValue(string key, string[] lines)`
`67`	`69`	`{`
`68`	`70`	`return lines.Where(line => line.StartsWith(key + "=", StringComparison.Ordinal)).Last().Substring((key + "=").Length);`
`69`	`71`	`}`
`70`	`72`
`71`		`- private string Unquote(string text)`
	`73`	`+ private static string Unquote(string text)`
`72`	`74`	`{`
`73`	`75`	`// TODO implement proper un-escaping`
`74`	`76`	`// This is a limited shell-style syntax described at`
`75`	`77`	`// https://www.freedesktop.org/software/systemd/man/os-release.html`
`76`		`- if (text.StartsWith("\"") && text.EndsWith("\""))`
	`78`	`+ if (text.StartsWith("\"", StringComparison.Ordinal) && text.EndsWith("\"", StringComparison.Ordinal))`
`77`	`79`	`{`
`78`	`80`	`return text.Substring(1, text.Length - 2);`
`79`	`81`	`}`
`80`	`82`
`81`	`83`	`return text;`
`82`	`84`	`}`
`83`	`85`
	`86`	`+#pragma warning disable CA1822 // Mark members as static`
`84`	`87`	`internal string GetLddVersion()`
	`88`	`+#pragma warning restore CA1822 // Mark members as static`
`85`	`89`	`{`
`86`	`90`	`using (Process p = new Process())`
`87`	`91`	`{`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public static async Task<int> RunAsync(ProcessStartInfo psi, Action<string> logg`
`12`	`12`	`{`
`13`	`13`	`logger($"Executing {psi.FileName} with arguments {psi.Arguments} in working directory {psi.WorkingDirectory}");`
`14`	`14`	`using var process = Process.Start(psi);`
`15`		`- await process.WaitForExitAsync(logger, token);`
	`15`	`+ await process.WaitForExitAsync(logger, token).ConfigureAwait(false);`
`16`	`16`	`return process.ExitCode;`
`17`	`17`	`}`
`18`	`18`	`}`
`@@ -43,11 +43,11 @@ public static async Task WaitForExitAsync(this Process process, Action<string> l`
`43`	`43`
`44`	`44`	`try`
`45`	`45`	`{`
`46`		`- await process.WaitForExitAsync(token);`
	`46`	`+ await process.WaitForExitAsync(token).ConfigureAwait(false);`
`47`	`47`
`48`	`48`	`logger($"Process Exit Code: {process.ExitCode}");`
`49`	`49`	`}`
`50`		`- catch (OperationCanceledException ex)`
	`50`	`+ catch (OperationCanceledException)`
`51`	`51`	`{`
`52`	`52`	`lock (logger)`
`53`	`53`	`{`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,9 @@`
`12`	`12`
`13`	`13`	`namespace Turkey`
`14`	`14`	`{`
	`15`	`+#pragma warning disable CA1052 // Static holder types should be Static or NotInheritable`
`15`	`16`	`public class Program`
	`17`	`+#pragma warning restore CA1052 // Static holder types should be Static or NotInheritable`
`16`	`18`	`{`
`17`	`19`	`public static readonly Option<bool> verboseOption = new Option<bool>(`
`18`	`20`	`new string[] { "--verbose", "-v" },`
`@@ -118,7 +120,7 @@ public static async Task<int> Run(string testRoot,`
`118`	`120`
`119`	`121`	`Version packageVersion = runtimeVersion;`
`120`	`122`	`string nuGetConfig = await GenerateNuGetConfigIfNeededAsync(additionalFeed, packageVersion,`
`121`		`- useSourceBuildNuGetConfig: false);`
	`123`	`+ useSourceBuildNuGetConfig: false).ConfigureAwait(false);`
`122`	`124`	`if (verbose && nuGetConfig != null)`
`123`	`125`	`{`
`124`	`126`	`Console.WriteLine("Using nuget.config: ");`
`@@ -132,7 +134,7 @@ public static async Task<int> Run(string testRoot,`
`132`	`134`	`verboseOutput: verbose,`
`133`	`135`	`nuGetConfig: nuGetConfig);`
`134`	`136`
`135`		`- var results = await runner.ScanAndRunAsync(testOutputs, logDir.FullName, defaultTimeout);`
	`137`	`+ var results = await runner.ScanAndRunAsync(testOutputs, logDir.FullName, defaultTimeout).ConfigureAwait(false);`
`136`	`138`
`137`	`139`	`int exitCode = (results.Failed == 0) ? 0 : 1;`
`138`	`140`	`return exitCode;`
`@@ -157,7 +159,7 @@ public static async Task<string> GenerateNuGetConfigIfNeededAsync(string additio`
`157`	`159`	`{`
`158`	`160`	`try`
`159`	`161`	`{`
`160`		`- nugetConfig = await sourceBuild.GetNuGetConfigAsync(netCoreAppVersion);`
	`162`	`+ nugetConfig = await sourceBuild.GetNuGetConfigAsync(netCoreAppVersion).ConfigureAwait(false);`
`161`	`163`	`}`
`162`	`164`	`catch( HttpRequestException exception )`
`163`	`165`	`{`
`@@ -173,14 +175,16 @@ public static async Task<string> GenerateNuGetConfigIfNeededAsync(string additio`
`173`	`175`	`// if the nugetConfig has a <clear/> element that removes`
`174`	`176`	`// it.`
`175`	`177`	`urls.Add("https://api.nuget.org/v3/index.json");`
`176`		`- return await nuget.GenerateNuGetConfig(urls, nugetConfig);`
	`178`	`+ return await nuget.GenerateNuGetConfig(urls, nugetConfig).ConfigureAwait(false);`
`177`	`179`	`}`
`178`	`180`	`}`
`179`	`181`
`180`	`182`	`return null;`
`181`	`183`	`}`
`182`	`184`
	`185`	`+#pragma warning disable CA1801 // Remove unused parameter`
`183`	`186`	`public static IReadOnlySet<string> CreateTraits(Version runtimeVersion, Version sdkVersion, List<string> rids, bool isMonoRuntime, IEnumerable<string> additionalTraits)`
	`187`	`+#pragma warning restore CA1801 // Remove unused parameter`
`184`	`188`	`{`
`185`	`189`	`var traits = new HashSet<string>(StringComparer.OrdinalIgnoreCase);`
`186`	`190`
`@@ -199,7 +203,9 @@ public static IReadOnlySet<string> CreateTraits(Version runtimeVersion, Version`
`199`	`203`	`}`
`200`	`204`
`201`	`205`	`// Add 'arch=' trait.`
	`206`	`+#pragma warning disable CA1308 // Normalize strings to uppercase`
`202`	`207`	`string arch = RuntimeInformation.OSArchitecture.ToString().ToLowerInvariant();`
	`208`	`+#pragma warning restore CA1308 // Normalize strings to uppercase`
`203`	`209`	`traits.Add($"arch={arch}");`
`204`	`210`
`205`	`211`	`// Add 'runtime=' trait.`
`@@ -231,7 +237,7 @@ static async Task<int> Main(string[] args)`
`231`	`237`	`rootCommand.AddOption(traitOption);`
`232`	`238`	`rootCommand.AddOption(timeoutOption);`
`233`	`239`
`234`		`- return await rootCommand.InvokeAsync(args);`
	`240`	`+ return await rootCommand.InvokeAsync(args).ConfigureAwait(false);`
`235`	`241`	`}`
`236`	`242`	`}`
`237`		`-}`
	`243`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -16,11 +16,12 @@ public SourceBuild(HttpClient client)`
`16`	`16`	`this._client = client;`
`17`	`17`	`}`
`18`	`18`
`19`		`- public string GetBranchContentUrl(Version version)`
	`19`	`+ public static System.Uri GetBranchContentUrl(Version version)`
`20`	`20`	`{`
`21`	`21`	`var branchName = "release/" + version.MajorMinor + ".1xx";`
`22`	`22`	`var url = $"https://raw.githubusercontent.com/dotnet/installer/{branchName}/";`
`23`		`- return url;`
	`23`	`+ Uri uri = new(url);`
	`24`	`+ return uri;`
`24`	`25`	`}`
`25`	`26`
`26`	`27`	`public async Task<string> GetProdConFeedAsync(Version version)`
`@@ -31,9 +32,10 @@ public async Task<string> GetProdConFeedAsync(Version version)`
`31`	`32`	`}`
`32`	`33`
`33`	`34`	`var url = GetBranchContentUrl(version) + "ProdConFeed.txt";`
`34`		`- var feedUrl = await _client.GetStringAsync(url);`
`35`		`-`
`36`		`- using(var response = await _client.GetAsync(feedUrl))`
	`35`	`+ Uri uri = new(url);`
	`36`	`+ var feedUrl = await _client.GetStringAsync(uri).ConfigureAwait(false);`
	`37`	`+ Uri feedUri = new(feedUrl);`
	`38`	`+ using(var response = await _client.GetAsync(feedUri).ConfigureAwait(false))`
`37`	`39`	`{`
`38`	`40`	`if (!response.IsSuccessStatusCode)`
`39`	`41`	`{`
`@@ -46,11 +48,12 @@ public async Task<string> GetProdConFeedAsync(Version version)`
`46`	`48`	`public async Task<string> GetNuGetConfigAsync(Version version)`
`47`	`49`	`{`
`48`	`50`	`string url = GetBranchContentUrl(version) + "NuGet.config";`
	`51`	`+ Uri uri = new(url);`
`49`	`52`
`50`	`53`	`string nugetConfig = null;`
`51`	`54`	`try`
`52`	`55`	`{`
`53`		`- nugetConfig = await _client.GetStringAsync(url);`
	`56`	`+ nugetConfig = await _client.GetStringAsync(uri).ConfigureAwait(false);`
`54`	`57`	`}`
`55`	`58`	`catch( HttpRequestException e )`
`56`	`59`	`{`
Original file line number	Diff line number	Diff line change
`@@ -18,8 +18,12 @@ public class TestDescriptor`
`18`	`18`	`public string Type { get; set; }`
`19`	`19`	`public bool Cleanup { get; set; }`
`20`	`20`	`public double TimeoutMultiplier { get; set; } = 1.0;`
	`21`	`+`
	`22`	`+ #pragma warning disable CA2227 // Change to be read-only by removing the property setter.`
`21`	`23`	`public List<string> IgnoredRIDs { get; set; } = new();`
`22`	`24`	`public List<string> SkipWhen { get; set; } = new();`
	`25`	`+`
	`26`	`+ #pragma warning restore CA2227`
`23`	`27`	`}`
`24`	`28`
`25`	`29`	`// TODO is this a strongly-typed enum in C#?`
`@@ -58,10 +62,10 @@ public async Task<TestResult> RunAsync(Action<string> logger, CancellationToken`
`58`	`62`	`{`
`59`	`63`	`Console.WriteLine($"WARNING: overwriting {path}");`
`60`	`64`	`}`
`61`		`- await File.WriteAllTextAsync(path, NuGetConfig);`
	`65`	`+ await File.WriteAllTextAsync(path, NuGetConfig).ConfigureAwait(false);`
`62`	`66`	`}`
`63`	`67`
`64`		`- var testResult = await InternalRunAsync(logger, cancelltionToken);`
	`68`	`+ var testResult = await InternalRunAsync(logger, cancelltionToken).ConfigureAwait(false);`
`65`	`69`
`66`	`70`	`if (!string.IsNullOrEmpty(NuGetConfig))`
`67`	`71`	`{`