Fix AppVeyor build (#1987)

* add Visual C++ toolset to $path so NativeAOT tests can build native executables

* set Platform for Windows build

* force the tool to not look for the .dll in platform-specific directory

* don't run some of the very time consuming tests on AppVeyor as we hit 1h limit

Author: adamsitnik

appveyor.yml

@@ -27,6 +27,10 @@ os: Visual Studio 2022
 init:
   - git config --global core.autocrlf input
 
+# add Visual C++ toolset to $path so NativeAOT tests can build native executables
+before_build:
+  - call "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat"
+
 #---------------------------------#
 #       build configuration       #
 #---------------------------------#

build/Program.cs

@@ -8,6 +8,8 @@
 using Cake.Common.IO;
 using Cake.Common.Net;
 using Cake.Common.Tools.DotNet;
+using Cake.Common.Tools.DotNet.MSBuild;
+using Cake.Common.Tools.DotNet.Restore;
 using Cake.Common.Tools.DotNet.Run;
 using Cake.Common.Tools.DotNetCore.Build;
 using Cake.Common.Tools.DotNetCore.MSBuild;
@@ -93,18 +95,29 @@ public BuildContext(ICakeContext context)
             MaxCpuCount = 1
         };
         MsBuildSettings.WithProperty("UseSharedCompilation", "false");
+
+        // NativeAOT build requires VS C++ tools to be added to $path via vcvars64.bat
+        // but once we do that, dotnet restore fails with:
+        // "Please specify a valid solution configuration using the Configuration and Platform properties"
+        if (context.IsRunningOnWindows())
+        {
+            MsBuildSettings.WithProperty("Platform", "Any CPU");
+        }
     }
 
     private DotNetCoreTestSettings GetTestSettingsParameters(FilePath logFile, string tfm)
     {
-        return new DotNetCoreTestSettings
+        var settings = new DotNetCoreTestSettings
         {
             Configuration = BuildConfiguration,
             Framework = tfm,
             NoBuild = true,
             NoRestore = true,
             Loggers = new[] { "trx", $"trx;LogFileName={logFile.FullPath}" }
         };
+        // force the tool to not look for the .dll in platform-specific directory
+        settings.EnvironmentVariables["Platform"] = "";
+        return settings;
     }
 
     public void RunTests(FilePath projectFile, string alias, string tfm)
@@ -260,7 +273,11 @@ public class RestoreTask : FrostingTask<BuildContext>
 {
     public override void Run(BuildContext context)
     {
-        context.DotNetRestore(context.SolutionFile.FullPath);
+        context.DotNetRestore(context.SolutionFile.FullPath,
+            new DotNetRestoreSettings
+            {
+                MSBuildSettings = context.MsBuildSettings
+            });
     }
 }
 
@@ -349,12 +366,14 @@ public override void Run(BuildContext context)
         {
             Configuration = context.BuildConfiguration,
             OutputDirectory = context.ArtifactsDirectory.FullPath,
-            ArgumentCustomization = args => args.Append("--include-symbols").Append("-p:SymbolPackageFormat=snupkg")
+            ArgumentCustomization = args => args.Append("--include-symbols").Append("-p:SymbolPackageFormat=snupkg"),
+            MSBuildSettings = context.MsBuildSettings
         };
         var settingsTemplate = new DotNetCorePackSettings
         {
             Configuration = context.BuildConfiguration,
-            OutputDirectory = context.ArtifactsDirectory.FullPath
+            OutputDirectory = context.ArtifactsDirectory.FullPath,
+            MSBuildSettings = context.MsBuildSettings
         };
 
         foreach (var project in context.AllPackableSrcProjects)

tests/BenchmarkDotNet.IntegrationTests/BuildTimeoutTests.cs

@@ -19,7 +19,7 @@ public void WhenBuildTakesMoreTimeThanTheTimeoutTheBuildIsCancelled()
         {
             if (!RuntimeInformation.Is64BitPlatform()) // NativeAOT does not support 32bit yet
                 return;
-            if (GitHubActions.IsRunningOnWindows()) // no native dependencies installed
+            if (ContinuousIntegration.IsGitHubActionsOnWindows()) // no native dependencies installed
                 return;
 
             // we use NativeAOT on purpose because it takes a LOT of time to build it

tests/BenchmarkDotNet.IntegrationTests/ContinuousIntegration.cs

@@ -0,0 +1,14 @@
+using BenchmarkDotNet.Portability;
+using System;
+
+namespace BenchmarkDotNet.IntegrationTests
+{
+    internal static class ContinuousIntegration
+    {
+        internal static bool IsGitHubActionsOnWindows()
+            => RuntimeInformation.IsWindows() && !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("GITHUB_ACTION"));
+
+        internal static bool IsAppVeyorOnWindows()
+            => RuntimeInformation.IsWindows() && !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("APPVEYOR"));
+    }
+}

tests/BenchmarkDotNet.IntegrationTests/GitHubActions.cs

@@ -38,18 +38,6 @@ public static IEnumerable<object[]> GetToolchains()
 
             yield return new object[] { Job.Default.GetToolchain() };
             yield return new object[] { InProcessEmitToolchain.Instance };
-
-#if !NETFRAMEWORK
-            if (!GitHubActions.IsRunningOnWindows())
-            {
-                // we don't want to test NativeAOT twice (for .NET 4.6 and 5.0) when running the integration tests (these tests take a lot of time)
-                // we test against specific version to keep this test stable
-                yield return new object[] { NativeAotToolchain.CreateBuilder()
-                .UseNuGet(
-                    "6.0.0-rc.1.21420.1",
-                    "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-experimental/nuget/v3/index.json").ToToolchain() };
-            }
-#endif
         }
 
         public class AccurateAllocations
@@ -76,6 +64,20 @@ public void MemoryDiagnoserIsAccurate(IToolchain toolchain)
             });
         }
 
+        [FactDotNetCoreOnly("We don't want to test NativeAOT twice (for .NET Framework 4.6.1 and .NET 6.0)")]
+        public void MemoryDiagnoserSupportsNativeAOT()
+        {
+            if (ContinuousIntegration.IsGitHubActionsOnWindows())
+                return;
+
+            MemoryDiagnoserIsAccurate(
+                NativeAotToolchain.CreateBuilder()
+                    .UseNuGet(
+                        "6.0.0-rc.1.21420.1", // we test against specific version to keep this test stable
+                        "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-experimental/nuget/v3/index.json")
+                    .ToToolchain());
+        }
+
         public class AllocatingGlobalSetupAndCleanup
         {
             private List<int> list;

tests/BenchmarkDotNet.IntegrationTests/MemoryDiagnoserTests.cs

@@ -18,7 +18,9 @@ public void LatestNativeAotVersionIsSupported()
         {
             if (!RuntimeInformation.Is64BitPlatform()) // NativeAOT does not support 32bit yet
                 return;
-            if (GitHubActions.IsRunningOnWindows()) // no native dependencies installed
+            if (ContinuousIntegration.IsGitHubActionsOnWindows()) // no native dependencies installed
+                return;
+            if (ContinuousIntegration.IsAppVeyorOnWindows()) // too time consuming for AppVeyor (1h limit)
                 return;
 
             var config = ManualConfig.CreateEmpty()

tests/BenchmarkDotNet.IntegrationTests/NativeAotTests.cs

@@ -29,11 +29,14 @@ public static IEnumerable<object[]> GetToolchains()
         {
             yield return new object[] { Job.Default.GetToolchain() };
 
-            if (!GitHubActions.IsRunningOnWindows())
+            if (!ContinuousIntegration.IsGitHubActionsOnWindows() // no native dependencies
+                && !ContinuousIntegration.IsAppVeyorOnWindows()) // too time consuming for AppVeyor (1h limit)
+            {
                 yield return new object[]{ NativeAotToolchain.CreateBuilder()
                     .UseNuGet(
                         "6.0.0-rc.1.21420.1",
                         "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-experimental/nuget/v3/index.json").ToToolchain() };
+            }
             // TODO: Support InProcessEmitToolchain.Instance
             // yield return new object[] { InProcessEmitToolchain.Instance };
         }