chore: Add setting to skip long running tests on draft PR (#3121)

filzrev · web-flow · commit 8ab56fefeb85 · 2026-05-11T05:46:21.000-04:00
* chore: add logics to detect github draft pr

* chore: add skip tests logics when ci running on draft pr
diff --git a/.github/workflows/run-tests.yaml b/.github/workflows/run-tests.yaml
@@ -3,9 +3,13 @@ run-name: Run tests / ${{ github.event.head_commit.message }}
 
 on:
   pull_request:
+    types: [opened, synchronize, reopened, ready_for_review]
   push:
   workflow_dispatch:
 
+env:
+  IS_DRAFT_PR: ${{ github.event.pull_request.draft }}
+
 concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.ref || github.run_id }}
   cancel-in-progress: true
@@ -24,6 +28,7 @@ jobs:
       - uses: ./.github/actions/add-windowsdefender-exclusions
       # Setup additional tools
       - name: Setup additional tools for Wasm/NativeAot tests
+        if: ${{ github.event.pull_request.draft != true }}
         uses: ./.github/actions/setup-additional-tools
       # Build and Test
       - name: Run task 'build'
@@ -66,6 +71,7 @@ jobs:
       - uses: ./.github/actions/add-windowsdefender-exclusions
       # Setup additional tools
       - name: Setup additional tools for Wasm/NativeAot tests
+        if: ${{ github.event.pull_request.draft != true }}
         uses: ./.github/actions/setup-additional-tools
       # Build and Test
       - name: Run task 'build'
@@ -105,6 +111,7 @@ jobs:
       - uses: actions/checkout@v6
       # Setup additional tools
       - name: Setup additional tools for Wasm/NativeAot tests
+        if: ${{ github.event.pull_request.draft != true }}
         uses: ./.github/actions/setup-additional-tools
       # Build and Test
       - name: Run task 'build'
@@ -145,6 +152,7 @@ jobs:
       - uses: actions/checkout@v6
       # Setup additional tools
       - name: Setup additional tools for Wasm/NativeAot tests
+        if: ${{ github.event.pull_request.draft != true }}
         uses: ./.github/actions/setup-additional-tools
       # Build and Test
       - name: Run task 'build'
diff --git a/tests/BenchmarkDotNet.IntegrationTests/ArgumentsTests.cs b/tests/BenchmarkDotNet.IntegrationTests/ArgumentsTests.cs
@@ -11,11 +11,14 @@ namespace BenchmarkDotNet.IntegrationTests
     public class ArgumentsTests : BenchmarkTestExecutor
     {
         public static IEnumerable<object[]> GetToolchains()
-            =>
-                [
-                    [Job.Default.GetToolchain()],
-                    [InProcessEmitToolchain.Default],
-                ];
+        {
+            yield return [InProcessEmitToolchain.Default];
+
+            if (ContinuousIntegration.IsGitHubDraftPR())
+                yield break;
+
+            yield return [Job.Default.GetToolchain()];
+        }
 
         public ArgumentsTests(ITestOutputHelper output) : base(output) { }
 
diff --git a/tests/BenchmarkDotNet.IntegrationTests/CancellationTokenTests.cs b/tests/BenchmarkDotNet.IntegrationTests/CancellationTokenTests.cs
@@ -52,7 +52,7 @@ public void BenchmarkWithCancellationTokenProperty_ReceivesToken_InProcessEmit()
         CanExecute<BenchmarkWithCancellationToken>(config);
     }
 
-    [TheoryEnvSpecific("JSVU does not support ARM on Windows or Linux", EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm)]
+    [TheoryEnvSpecific("JSVU does not support ARM on Windows or Linux", EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm, EnvRequirement.NonGitHubDraftPR)]
     [InlineData("v8")]
     [InlineData("node")]
     public void BenchmarkWithCancellationTokenProperty_ReceivesToken_Wasm(string javaScriptEngine)
@@ -116,7 +116,7 @@ public async Task RunWithCancellationTokenIsCancelled_InProcessEmit()
     }
 
     [Theory]
-    [InlineDataEnvSpecific("v8", "JSVU does not support ARM on Windows or Linux", [EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm])]
+    [InlineDataEnvSpecific("v8", "JSVU does not support ARM on Windows or Linux", [EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm, EnvRequirement.NonGitHubDraftPR])]
     [InlineData("node")]
     public async Task RunWithCancellationTokenIsCancelled_Wasm(string javaScriptEngine)
     {
diff --git a/tests/BenchmarkDotNet.IntegrationTests/ContinuousIntegration.cs b/tests/BenchmarkDotNet.IntegrationTests/ContinuousIntegration.cs
@@ -1,4 +1,6 @@
 using BenchmarkDotNet.Detectors;
+using BenchmarkDotNet.Extensions;
+using BenchmarkDotNet.Tests.XUnit;
 
 namespace BenchmarkDotNet.IntegrationTests
 {
@@ -10,5 +12,8 @@ internal static bool IsGitHubActionsOnWindows()
             => OsDetector.IsWindows() && IsGitHubActions();
 
         internal static bool IsLocalRun() => !IsGitHubActions();
+
+        internal static bool IsGitHubDraftPR()
+           => EnvRequirementChecker.GetSkip(EnvRequirement.NonGitHubDraftPR).IsNotBlank();
     }
 }
diff --git a/tests/BenchmarkDotNet.IntegrationTests/DisassemblyDiagnoserTests.cs b/tests/BenchmarkDotNet.IntegrationTests/DisassemblyDiagnoserTests.cs
@@ -25,6 +25,9 @@ public static IEnumerable<object[]> GetAllJits()
         {
             yield return [JitInfo.GetCurrentJit(), RuntimeInformation.GetCurrentPlatform(), InProcessEmitToolchain.Default]; // InProcess
 
+            if (ContinuousIntegration.IsGitHubDraftPR())
+                yield break;
+
             if (RuntimeInformation.IsFullFramework)
             {
                 yield return [Jit.LegacyJit, Platform.X86, CsProjClassicNetToolchain.Net472]; // 32bit LegacyJit for desktop .NET
diff --git a/tests/BenchmarkDotNet.IntegrationTests/MemoryDiagnoserTests.cs b/tests/BenchmarkDotNet.IntegrationTests/MemoryDiagnoserTests.cs
@@ -32,12 +32,14 @@ public class MemoryDiagnoserTests
 
         public static IEnumerable<object[]> GetToolchains()
         {
-            yield return new object[] { Job.Default.GetToolchain() };
             // InProcessEmit reports flaky allocations in current .Net 8.
             if (!RuntimeInformation.IsNetCore)
-            {
                 yield return new object[] { InProcessEmitToolchain.Default };
-            }
+
+            if (ContinuousIntegration.IsGitHubDraftPR())
+                yield break;
+
+            yield return new object[] { Job.Default.GetToolchain() };
         }
 
         public class AccurateAllocations
@@ -68,7 +70,7 @@ public void MemoryDiagnoserIsAccurate(IToolchain toolchain)
             });
         }
 
-        [FactEnvSpecific("We don't want to test NativeAOT twice (for .NET Framework 4.6.2 and .NET 8.0)", EnvRequirement.DotNetCoreOnly)]
+        [FactEnvSpecific("We don't want to test NativeAOT twice (for .NET Framework 4.6.2 and .NET 8.0)", [EnvRequirement.DotNetCoreOnly, EnvRequirement.NonGitHubDraftPR])]
         public void MemoryDiagnoserSupportsNativeAOT()
         {
             if (OsDetector.IsMacOS())
@@ -77,13 +79,13 @@ public void MemoryDiagnoserSupportsNativeAOT()
             MemoryDiagnoserIsAccurate(NativeAotToolchain.Net80);
         }
 
-        [FactEnvSpecific("We don't want to test MonoVM twice (for .NET Framework 4.6.2 and .NET 8.0), and it's not supported on Windows+Arm", [EnvRequirement.DotNetCoreOnly, EnvRequirement.NonWindowsArm])]
+        [FactEnvSpecific("We don't want to test MonoVM twice (for .NET Framework 4.6.2 and .NET 8.0), and it's not supported on Windows+Arm", [EnvRequirement.DotNetCoreOnly, EnvRequirement.NonWindowsArm, EnvRequirement.NonGitHubDraftPR])]
         public void MemoryDiagnoserSupportsModernMono()
         {
             MemoryDiagnoserIsAccurate(MonoToolchain.Mono80);
         }
 
-        [TheoryEnvSpecific("JSVU does not support ARM on Windows or Linux", EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm)]
+        [TheoryEnvSpecific("JSVU does not support ARM on Windows or Linux", [EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm, EnvRequirement.NonGitHubDraftPR])]
         [InlineData(MonoAotCompilerMode.mini)]
         // BUG: https://github.com/dotnet/BenchmarkDotNet/issues/3036
         [InlineData(MonoAotCompilerMode.wasm, Skip = "AOT is broken")]
diff --git a/tests/BenchmarkDotNet.IntegrationTests/MonoTests.cs b/tests/BenchmarkDotNet.IntegrationTests/MonoTests.cs
@@ -12,7 +12,7 @@ public class MonoTests : BenchmarkTestExecutor
     {
         public MonoTests(ITestOutputHelper output) : base(output) { }
 
-        [FactEnvSpecific("UseMonoRuntime option is available in .NET Core only starting from .NET 6, and it's not supported on Windows+Arm", [EnvRequirement.DotNetCoreOnly, EnvRequirement.NonWindowsArm])]
+        [FactEnvSpecific("UseMonoRuntime option is available in .NET Core only starting from .NET 6, and it's not supported on Windows+Arm", [EnvRequirement.DotNetCoreOnly, EnvRequirement.NonWindowsArm, EnvRequirement.NonGitHubDraftPR])]
         public void Mono80IsSupported()
         {
             var logger = new OutputLogger(Output);
diff --git a/tests/BenchmarkDotNet.IntegrationTests/NativeAotTests.cs b/tests/BenchmarkDotNet.IntegrationTests/NativeAotTests.cs
@@ -33,7 +33,7 @@ private ManualConfig GetConfig()
                     .WithEnvironmentVariable(NativeAotBenchmark.EnvVarKey, IsAvx2Supported().ToString().ToLower()));
         }
 
-        [FactEnvSpecific("It's impossible to reliably detect the version of NativeAOT if the process is not a .NET Core or NativeAOT process", EnvRequirement.DotNetCoreOnly)]
+        [FactEnvSpecific("It's impossible to reliably detect the version of NativeAOT if the process is not a .NET Core or NativeAOT process", EnvRequirement.DotNetCoreOnly, EnvRequirement.NonGitHubDraftPR)]
         public void LatestNativeAotVersionIsSupported()
         {
             if (!GetShouldRunTest())
@@ -52,7 +52,7 @@ public void LatestNativeAotVersionIsSupported()
             }
         }
 
-        [FactEnvSpecific("It's impossible to reliably detect the version of NativeAOT if the process is not a .NET Core or NativeAOT process", EnvRequirement.DotNetCoreOnly)]
+        [FactEnvSpecific("It's impossible to reliably detect the version of NativeAOT if the process is not a .NET Core or NativeAOT process", EnvRequirement.DotNetCoreOnly, EnvRequirement.NonGitHubDraftPR)]
         public void NativeAotSupportsInProcessDiagnosers()
         {
             if (!GetShouldRunTest())
diff --git a/tests/BenchmarkDotNet.IntegrationTests/ParamSourceTests.cs b/tests/BenchmarkDotNet.IntegrationTests/ParamSourceTests.cs
@@ -14,11 +14,14 @@ public class ParamSourceTests : BenchmarkTestExecutor
         public ParamSourceTests(ITestOutputHelper output) : base(output) { }
 
         public static IEnumerable<object[]> GetToolchains()
-            =>
-                [
-                    [Job.Default.GetToolchain()],
-                    [InProcessEmitToolchain.Default],
-                ];
+        {
+            yield return [InProcessEmitToolchain.Default];
+
+            if (ContinuousIntegration.IsGitHubDraftPR())
+                yield break;
+
+            yield return [Job.Default.GetToolchain()];
+        }
 
         [Fact]
         public void ParamSourceCanHandleStringWithSurrogates()
diff --git a/tests/BenchmarkDotNet.IntegrationTests/R2RTests.cs b/tests/BenchmarkDotNet.IntegrationTests/R2RTests.cs
@@ -54,7 +54,7 @@ private static R2RRuntime GetCurrentR2RRuntime()
 #endif
         }
 
-        [FactEnvSpecific("R2R requires .NET Core runtime", EnvRequirement.DotNetCoreOnly)]
+        [FactEnvSpecific("R2R requires .NET Core runtime", EnvRequirement.DotNetCoreOnly, EnvRequirement.NonGitHubDraftPR)]
         public void R2RToolchainCanExecuteBenchmarks()
         {
             try
diff --git a/tests/BenchmarkDotNet.IntegrationTests/ThreadingDiagnoserTests.cs b/tests/BenchmarkDotNet.IntegrationTests/ThreadingDiagnoserTests.cs
@@ -13,6 +13,7 @@
 using BenchmarkDotNet.Toolchains.NativeAot;
 using BenchmarkDotNet.Detectors;
 using BenchmarkDotNet.IntegrationTests.Xunit;
+using BenchmarkDotNet.Tests.XUnit;
 
 namespace BenchmarkDotNet.IntegrationTests
 {
@@ -26,6 +27,9 @@ public static IEnumerable<object[]> GetToolchains()
         {
             yield return new object[] { InProcessEmitToolchain.Default };
 
+            if (ContinuousIntegration.IsGitHubDraftPR())
+                yield break;
+
             yield return new object[] { Job.Default.GetToolchain() };
 
             if (!ContinuousIntegration.IsGitHubActionsOnWindows() // no native dependencies
@@ -35,7 +39,8 @@ public static IEnumerable<object[]> GetToolchains()
             }
         }
 
-        [Theory, MemberData(nameof(GetToolchains), DisableDiscoveryEnumeration = true)]
+        [TheoryEnvSpecific(EnvRequirement.NonGitHubDraftPR)]
+        [MemberData(nameof(GetToolchains), DisableDiscoveryEnumeration = true)]
         public void CompletedWorkItemCountIsAccurate(IToolchain toolchain)
         {
             var config = CreateConfig(toolchain);
@@ -76,7 +81,8 @@ public void CompleteOneWorkItem()
             public void DoNothing() { }
         }
 
-        [Theory, MemberData(nameof(GetToolchains), DisableDiscoveryEnumeration = true)]
+        [TheoryEnvSpecific(EnvRequirement.NonGitHubDraftPR)]
+        [MemberData(nameof(GetToolchains), DisableDiscoveryEnumeration = true)]
         public void LockContentionCountIsAccurate(IToolchain toolchain)
         {
             var config = CreateConfig(toolchain);
diff --git a/tests/BenchmarkDotNet.IntegrationTests/WasmTests.cs b/tests/BenchmarkDotNet.IntegrationTests/WasmTests.cs
@@ -23,7 +23,7 @@ public class WasmTests(ITestOutputHelper output) : BenchmarkTestExecutor(output)
     {
         private const string V8SkipReason = "JSVU does not support ARM on Windows or Linux";
 
-        [Theory]
+        [TheoryEnvSpecific(EnvRequirement.NonGitHubDraftPR)]
         [InlineDataEnvSpecific([MonoAotCompilerMode.mini, "v8"], V8SkipReason, [EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm])]
         [InlineData(MonoAotCompilerMode.mini, "node")]
         // BUG: https://github.com/dotnet/BenchmarkDotNet/issues/3036
@@ -34,7 +34,7 @@ public void WasmIsSupported(MonoAotCompilerMode aotCompilerMode, string javaScri
             CanExecute<WasmBenchmark>(GetConfig(aotCompilerMode, javaScriptEngine));
         }
 
-        [Theory]
+        [TheoryEnvSpecific(EnvRequirement.NonGitHubDraftPR)]
         [InlineDataEnvSpecific([MonoAotCompilerMode.mini, "v8"], V8SkipReason, [EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm])]
         [InlineData(MonoAotCompilerMode.mini, "node")]
         // BUG: https://github.com/dotnet/BenchmarkDotNet/issues/3036
@@ -58,7 +58,7 @@ public void WasmSupportsInProcessDiagnosers(MonoAotCompilerMode aotCompilerMode,
             }
         }
 
-        [Theory]
+        [TheoryEnvSpecific(EnvRequirement.NonGitHubDraftPR)]
         [InlineDataEnvSpecific(["v8", "custom-main-v8.mjs", WasmIpcType.FileStdOut], V8SkipReason, [EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm])]
         [InlineData("node", "custom-main-node.mjs", WasmIpcType.WebSocket)]
         public void WasmSupportsCustomMainJs(string javaScriptEngine, string customMainJs, WasmIpcType ipcType)
diff --git a/tests/BenchmarkDotNet.Tests/Shared/XUnit/EnvRequirement.cs b/tests/BenchmarkDotNet.Tests/Shared/XUnit/EnvRequirement.cs
@@ -10,5 +10,6 @@ public enum EnvRequirement
     FullFrameworkOnly,
     NonFullFramework,
     DotNetCoreOnly,
-    NeedsPrivilegedProcess
+    NeedsPrivilegedProcess,
+    NonGitHubDraftPR,
 }
diff --git a/tests/BenchmarkDotNet.Tests/Shared/XUnit/EnvRequirementChecker.cs b/tests/BenchmarkDotNet.Tests/Shared/XUnit/EnvRequirementChecker.cs
@@ -1,4 +1,5 @@
 using BenchmarkDotNet.Environments;
+using BenchmarkDotNet.Extensions;
 using System.Runtime.InteropServices;
 using System.Security.Principal;
 using BdnRuntimeInformation = BenchmarkDotNet.Portability.RuntimeInformation;
@@ -20,6 +21,7 @@ public static class EnvRequirementChecker
         EnvRequirement.NonFullFramework => !BdnRuntimeInformation.IsFullFramework ? null : "Non-Full .NET Framework test",
         EnvRequirement.DotNetCoreOnly => BdnRuntimeInformation.IsNetCore ? null : ".NET/.NET Core-only test",
         EnvRequirement.NeedsPrivilegedProcess => IsPrivilegedProcess() ? null : "Needs authorization to perform security-relevant functions",
+        EnvRequirement.NonGitHubDraftPR => !IsGitHubDraftPR() ? null : "GitHub draft PR",
         _ => throw new ArgumentOutOfRangeException(nameof(requirement), requirement, "Unknown value")
     };
 
@@ -35,4 +37,11 @@ private static bool IsPrivilegedProcess()
 
     private static bool IsArm()
         => BdnRuntimeInformation.GetCurrentPlatform() is Platform.Arm64 or Platform.Arm or Platform.Armv6;
-}
+
+    /// <summary>
+    /// Check current test is running on GitHub Actions and PR is a draft PR.
+    /// </summary>
+    private static bool IsGitHubDraftPR()
+        => Environment.GetEnvironmentVariable("GITHUB_ACTION").IsNotBlank()
+        && Environment.GetEnvironmentVariable("IS_DRAFT_PR") == "true"; // `IS_DRAFT_PR` is set by CI workflow
+}

Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ public void BenchmarkWithCancellationTokenProperty_ReceivesToken_InProcessEmit()`
`52`	`52`	`CanExecute<BenchmarkWithCancellationToken>(config);`
`53`	`53`	`}`
`54`	`54`
`55`		`- [TheoryEnvSpecific("JSVU does not support ARM on Windows or Linux", EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm)]`
	`55`	`+ [TheoryEnvSpecific("JSVU does not support ARM on Windows or Linux", EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm, EnvRequirement.NonGitHubDraftPR)]`
`56`	`56`	`[InlineData("v8")]`
`57`	`57`	`[InlineData("node")]`
`58`	`58`	`public void BenchmarkWithCancellationTokenProperty_ReceivesToken_Wasm(string javaScriptEngine)`
`@@ -116,7 +116,7 @@ public async Task RunWithCancellationTokenIsCancelled_InProcessEmit()`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`[Theory]`
`119`		`- [InlineDataEnvSpecific("v8", "JSVU does not support ARM on Windows or Linux", [EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm])]`
	`119`	`+ [InlineDataEnvSpecific("v8", "JSVU does not support ARM on Windows or Linux", [EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm, EnvRequirement.NonGitHubDraftPR])]`
`120`	`120`	`[InlineData("node")]`
`121`	`121`	`public async Task RunWithCancellationTokenIsCancelled_Wasm(string javaScriptEngine)`
`122`	`122`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,6 @@`
`1`	`1`	`using BenchmarkDotNet.Detectors;`
	`2`	`+using BenchmarkDotNet.Extensions;`
	`3`	`+using BenchmarkDotNet.Tests.XUnit;`
`2`	`4`
`3`	`5`	`namespace BenchmarkDotNet.IntegrationTests`
`4`	`6`	`{`
`@@ -10,5 +12,8 @@ internal static bool IsGitHubActionsOnWindows()`
`10`	`12`	`=> OsDetector.IsWindows() && IsGitHubActions();`
`11`	`13`
`12`	`14`	`internal static bool IsLocalRun() => !IsGitHubActions();`
	`15`	`+`
	`16`	`+ internal static bool IsGitHubDraftPR()`
	`17`	`+ => EnvRequirementChecker.GetSkip(EnvRequirement.NonGitHubDraftPR).IsNotBlank();`
`13`	`18`	`}`
`14`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,9 @@ public static IEnumerable<object[]> GetAllJits()`
`25`	`25`	`{`
`26`	`26`	`yield return [JitInfo.GetCurrentJit(), RuntimeInformation.GetCurrentPlatform(), InProcessEmitToolchain.Default]; // InProcess`
`27`	`27`
	`28`	`+ if (ContinuousIntegration.IsGitHubDraftPR())`
	`29`	`+ yield break;`
	`30`	`+`
`28`	`31`	`if (RuntimeInformation.IsFullFramework)`
`29`	`32`	`{`
`30`	`33`	`yield return [Jit.LegacyJit, Platform.X86, CsProjClassicNetToolchain.Net472]; // 32bit LegacyJit for desktop .NET`
Original file line number	Diff line number	Diff line change
`@@ -32,12 +32,14 @@ public class MemoryDiagnoserTests`
`32`	`32`
`33`	`33`	`public static IEnumerable<object[]> GetToolchains()`
`34`	`34`	`{`
`35`		`- yield return new object[] { Job.Default.GetToolchain() };`
`36`	`35`	`// InProcessEmit reports flaky allocations in current .Net 8.`
`37`	`36`	`if (!RuntimeInformation.IsNetCore)`
`38`		`- {`
`39`	`37`	`yield return new object[] { InProcessEmitToolchain.Default };`
`40`		`- }`
	`38`	`+`
	`39`	`+ if (ContinuousIntegration.IsGitHubDraftPR())`
	`40`	`+ yield break;`
	`41`	`+`
	`42`	`+ yield return new object[] { Job.Default.GetToolchain() };`
`41`	`43`	`}`
`42`	`44`
`43`	`45`	`public class AccurateAllocations`
`@@ -68,7 +70,7 @@ public void MemoryDiagnoserIsAccurate(IToolchain toolchain)`
`68`	`70`	`});`
`69`	`71`	`}`
`70`	`72`
`71`		`- [FactEnvSpecific("We don't want to test NativeAOT twice (for .NET Framework 4.6.2 and .NET 8.0)", EnvRequirement.DotNetCoreOnly)]`
	`73`	`+ [FactEnvSpecific("We don't want to test NativeAOT twice (for .NET Framework 4.6.2 and .NET 8.0)", [EnvRequirement.DotNetCoreOnly, EnvRequirement.NonGitHubDraftPR])]`
`72`	`74`	`public void MemoryDiagnoserSupportsNativeAOT()`
`73`	`75`	`{`
`74`	`76`	`if (OsDetector.IsMacOS())`
`@@ -77,13 +79,13 @@ public void MemoryDiagnoserSupportsNativeAOT()`
`77`	`79`	`MemoryDiagnoserIsAccurate(NativeAotToolchain.Net80);`
`78`	`80`	`}`
`79`	`81`
`80`		`- [FactEnvSpecific("We don't want to test MonoVM twice (for .NET Framework 4.6.2 and .NET 8.0), and it's not supported on Windows+Arm", [EnvRequirement.DotNetCoreOnly, EnvRequirement.NonWindowsArm])]`
	`82`	`+ [FactEnvSpecific("We don't want to test MonoVM twice (for .NET Framework 4.6.2 and .NET 8.0), and it's not supported on Windows+Arm", [EnvRequirement.DotNetCoreOnly, EnvRequirement.NonWindowsArm, EnvRequirement.NonGitHubDraftPR])]`
`81`	`83`	`public void MemoryDiagnoserSupportsModernMono()`
`82`	`84`	`{`
`83`	`85`	`MemoryDiagnoserIsAccurate(MonoToolchain.Mono80);`
`84`	`86`	`}`
`85`	`87`
`86`		`- [TheoryEnvSpecific("JSVU does not support ARM on Windows or Linux", EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm)]`
	`88`	`+ [TheoryEnvSpecific("JSVU does not support ARM on Windows or Linux", [EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm, EnvRequirement.NonGitHubDraftPR])]`
`87`	`89`	`[InlineData(MonoAotCompilerMode.mini)]`
`88`	`90`	`// BUG: https://github.com/dotnet/BenchmarkDotNet/issues/3036`
`89`	`91`	`[InlineData(MonoAotCompilerMode.wasm, Skip = "AOT is broken")]`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public class MonoTests : BenchmarkTestExecutor`
`12`	`12`	`{`
`13`	`13`	`public MonoTests(ITestOutputHelper output) : base(output) { }`
`14`	`14`
`15`		`- [FactEnvSpecific("UseMonoRuntime option is available in .NET Core only starting from .NET 6, and it's not supported on Windows+Arm", [EnvRequirement.DotNetCoreOnly, EnvRequirement.NonWindowsArm])]`
	`15`	`+ [FactEnvSpecific("UseMonoRuntime option is available in .NET Core only starting from .NET 6, and it's not supported on Windows+Arm", [EnvRequirement.DotNetCoreOnly, EnvRequirement.NonWindowsArm, EnvRequirement.NonGitHubDraftPR])]`
`16`	`16`	`public void Mono80IsSupported()`
`17`	`17`	`{`
`18`	`18`	`var logger = new OutputLogger(Output);`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ private ManualConfig GetConfig()`
`33`	`33`	`.WithEnvironmentVariable(NativeAotBenchmark.EnvVarKey, IsAvx2Supported().ToString().ToLower()));`
`34`	`34`	`}`
`35`	`35`
`36`		`- [FactEnvSpecific("It's impossible to reliably detect the version of NativeAOT if the process is not a .NET Core or NativeAOT process", EnvRequirement.DotNetCoreOnly)]`
	`36`	`+ [FactEnvSpecific("It's impossible to reliably detect the version of NativeAOT if the process is not a .NET Core or NativeAOT process", EnvRequirement.DotNetCoreOnly, EnvRequirement.NonGitHubDraftPR)]`
`37`	`37`	`public void LatestNativeAotVersionIsSupported()`
`38`	`38`	`{`
`39`	`39`	`if (!GetShouldRunTest())`
`@@ -52,7 +52,7 @@ public void LatestNativeAotVersionIsSupported()`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`
`55`		`- [FactEnvSpecific("It's impossible to reliably detect the version of NativeAOT if the process is not a .NET Core or NativeAOT process", EnvRequirement.DotNetCoreOnly)]`
	`55`	`+ [FactEnvSpecific("It's impossible to reliably detect the version of NativeAOT if the process is not a .NET Core or NativeAOT process", EnvRequirement.DotNetCoreOnly, EnvRequirement.NonGitHubDraftPR)]`
`56`	`56`	`public void NativeAotSupportsInProcessDiagnosers()`
`57`	`57`	`{`
`58`	`58`	`if (!GetShouldRunTest())`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ private static R2RRuntime GetCurrentR2RRuntime()`
`54`	`54`	`#endif`
`55`	`55`	`}`
`56`	`56`
`57`		`- [FactEnvSpecific("R2R requires .NET Core runtime", EnvRequirement.DotNetCoreOnly)]`
	`57`	`+ [FactEnvSpecific("R2R requires .NET Core runtime", EnvRequirement.DotNetCoreOnly, EnvRequirement.NonGitHubDraftPR)]`
`58`	`58`	`public void R2RToolchainCanExecuteBenchmarks()`
`59`	`59`	`{`
`60`	`60`	`try`