From b7e9946145510c6bc19ef4086d95e185dcadfa3a Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Tue, 28 Feb 2023 00:01:41 +0000
Subject: [PATCH 01/11] [wasm] Wasm.Build.Tests: Add blazor+aot run test

---
 .../Blazor/BuildPublishTests.cs               | 39 +++++++++++++++++++
 .../Wasm.Build.Tests/WasmTemplateTests.cs     | 15 -------
 2 files changed, 39 insertions(+), 15 deletions(-)

diff --git a/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs b/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs
index 3b670a42aa07f..2166042a17368 100644
--- a/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs
@@ -197,4 +197,43 @@ public void BugRegression_60479_WithRazorClassLib()
 
         Assert.Contains("RazorClassLibrary.dll", lazyVal.EnumerateObject().Select(jp => jp.Name));
     }
+
+    [ConditionalTheory(typeof(BuildTestBase), nameof(IsUsingWorkloads))]
+    [InlineData("Debug")]
+    [InlineData("Release")]
+    public async Task BlazorBuildRunTest(string config)
+    {
+        string id = $"blazor_{config}_{Path.GetRandomFileName()}";
+        string projectFile = CreateWasmTemplateProject(id, "blazorwasm");
+
+        new DotNetCommand(s_buildEnv, _testOutput)
+                .WithWorkingDirectory(_projectDir!)
+                .Execute($"build -c {config} -bl:{Path.Combine(s_buildEnv.LogRootPath, $"{id}.binlog")}")
+                .EnsureSuccessful();
+
+        await BlazorRun(config);
+    }
+
+    [ConditionalTheory(typeof(BuildTestBase), nameof(IsUsingWorkloads))]
+#if TEST_DEBUG_CONFIG_ALSO
+    [InlineData("Debug", false)]
+    [InlineData("Debug", true)]
+#endif
+    [InlineData("Release", false)]
+    [InlineData("Release", true)]
+    public async Task BlazorPublishRunTest(string config, bool aot)
+    {
+        string id = $"blazor_{config}_{Path.GetRandomFileName()}";
+        string projectFile = CreateWasmTemplateProject(id, "blazorwasm");
+        if (aot)
+            AddItemsPropertiesToProject(projectFile, "<RunAOTCompilation>true</RunAOTCompilation>");
+
+        new DotNetCommand(s_buildEnv, _testOutput)
+                .WithWorkingDirectory(_projectDir!)
+                .Execute($"publish -c {config} -bl:{Path.Combine(s_buildEnv.LogRootPath, $"{id}.binlog")}")
+                .EnsureSuccessful();
+
+        await BlazorRun(config);
+    }
+
 }
diff --git a/src/mono/wasm/Wasm.Build.Tests/WasmTemplateTests.cs b/src/mono/wasm/Wasm.Build.Tests/WasmTemplateTests.cs
index 63bb4ff0bff96..2d9100b6832d5 100644
--- a/src/mono/wasm/Wasm.Build.Tests/WasmTemplateTests.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/WasmTemplateTests.cs
@@ -418,21 +418,6 @@ public void ConsolePublishAndRun(string config, bool aot, bool relinking)
             Assert.Contains("args[2] = z", res.Output);
         }
 
-        [ConditionalFact(typeof(BuildTestBase), nameof(IsUsingWorkloads))]
-        public async Task BlazorRunTest()
-        {
-            string config = "Debug";
-            string id = $"blazor_{config}_{Path.GetRandomFileName()}";
-            string projectFile = CreateWasmTemplateProject(id, "blazorwasm");
-
-            new DotNetCommand(s_buildEnv, _testOutput)
-                    .WithWorkingDirectory(_projectDir!)
-                    .Execute($"build -c {config} -bl:{Path.Combine(s_buildEnv.LogRootPath, $"{id}.binlog")}")
-                    .EnsureSuccessful();
-
-            await BlazorRun(config);
-        }
-
         [ConditionalTheory(typeof(BuildTestBase), nameof(IsUsingWorkloads))]
         [InlineData("", BuildTestBase.DefaultTargetFramework)]
         // [ActiveIssue("https://github.com/dotnet/runtime/issues/79313")]

From fcc38bb76b249c751950c9015658052d2032a49b Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Tue, 28 Feb 2023 00:12:16 +0000
Subject: [PATCH 02/11] cleanup

---
 src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs | 4 ++--
 src/mono/wasm/Wasm.Build.Tests/Blazor/MiscTests.cs         | 2 +-
 src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs            | 6 +++---
 src/mono/wasm/Wasm.Build.Tests/CleanTests.cs               | 4 ++--
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs b/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs
index 2166042a17368..a58d275f6b66d 100644
--- a/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs
@@ -32,11 +32,11 @@ public void DefaultTemplate_WithoutWorkload(string config)
         CreateBlazorWasmTemplateProject(id);
 
         // Build
-        BuildInternal(id, config, publish: false);
+        BlazorBuildInternal(id, config, publish: false);
         AssertBlazorBootJson(config, isPublish: false);
 
         // Publish
-        BuildInternal(id, config, publish: true);
+        BlazorBuildInternal(id, config, publish: true);
         AssertBlazorBootJson(config, isPublish: true);
     }
 
diff --git a/src/mono/wasm/Wasm.Build.Tests/Blazor/MiscTests.cs b/src/mono/wasm/Wasm.Build.Tests/Blazor/MiscTests.cs
index 2d65479379d4d..158c281fefbef 100644
--- a/src/mono/wasm/Wasm.Build.Tests/Blazor/MiscTests.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/Blazor/MiscTests.cs
@@ -35,7 +35,7 @@ public void NativeBuild_WithDeployOnBuild_UsedByVS(string config, bool nativeRel
         AddItemsPropertiesToProject(projectFile, extraProperties: extraProperties);
 
         // build with -p:DeployOnBuild=true, and that will trigger a publish
-        (CommandResult res, _) = BuildInternal(id, config, publish: false, setWasmDevel: false, "-p:DeployOnBuild=true");
+        (CommandResult res, _) = BlazorBuildInternal(id, config, publish: false, setWasmDevel: false, "-p:DeployOnBuild=true");
 
         var expectedFileType = nativeRelink ? NativeFilesType.Relinked : NativeFilesType.AOT;
 
diff --git a/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs b/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs
index dc367b2e12089..86117d693f3a5 100644
--- a/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs
@@ -544,7 +544,7 @@ public string CreateBlazorWasmTemplateProject(string id)
             if (options.WarnAsError)
                 extraArgs = extraArgs.Append("/warnaserror").ToArray();
 
-            var res = BuildInternal(options.Id, options.Config, publish: false, setWasmDevel: false, extraArgs);
+            var res = BlazorBuildInternal(options.Id, options.Config, publish: false, setWasmDevel: false, extraArgs);
             _testOutput.WriteLine($"BlazorBuild, options.tfm: {options.TargetFramework}");
             AssertDotNetNativeFiles(options.ExpectedFileType, options.Config, forPublish: false, targetFramework: options.TargetFramework);
             AssertBlazorBundle(options.Config,
@@ -557,7 +557,7 @@ public string CreateBlazorWasmTemplateProject(string id)
 
         protected (CommandResult, string) BlazorPublish(BlazorBuildOptions options, params string[] extraArgs)
         {
-            var res = BuildInternal(options.Id, options.Config, publish: true, setWasmDevel: false, extraArgs);
+            var res = BlazorBuildInternal(options.Id, options.Config, publish: true, setWasmDevel: false, extraArgs);
             AssertDotNetNativeFiles(options.ExpectedFileType, options.Config, forPublish: true, targetFramework: options.TargetFramework);
             AssertBlazorBundle(options.Config,
                                isPublish: true,
@@ -576,7 +576,7 @@ public string CreateBlazorWasmTemplateProject(string id)
             return res;
         }
 
-        protected (CommandResult, string) BuildInternal(string id, string config, bool publish=false, bool setWasmDevel=true, params string[] extraArgs)
+        protected (CommandResult, string) BlazorBuildInternal(string id, string config, bool publish=false, bool setWasmDevel=true, params string[] extraArgs)
         {
             string label = publish ? "publish" : "build";
             _testOutput.WriteLine($"{Environment.NewLine}** {label} **{Environment.NewLine}");
diff --git a/src/mono/wasm/Wasm.Build.Tests/CleanTests.cs b/src/mono/wasm/Wasm.Build.Tests/CleanTests.cs
index b113c8443631d..13b860680f7ad 100644
--- a/src/mono/wasm/Wasm.Build.Tests/CleanTests.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/CleanTests.cs
@@ -73,7 +73,7 @@ private void Blazor_BuildNativeNonNative_ThenCleanTest(string config, bool first
         AddItemsPropertiesToProject(projectFile, extraProperties: extraProperties);
 
         bool relink = firstBuildNative;
-        BuildInternal(id, config, publish: false,
+        BlazorBuildInternal(id, config, publish: false,
                         extraArgs: relink ? "-p:WasmBuildNative=true" : string.Empty);
 
         string relinkDir = Path.Combine(_projectDir!, "obj", config, DefaultTargetFrameworkForBlazor, "wasm", "for-build");
@@ -81,7 +81,7 @@ private void Blazor_BuildNativeNonNative_ThenCleanTest(string config, bool first
             Assert.True(Directory.Exists(relinkDir), $"Could not find expected relink dir: {relinkDir}");
 
         relink = !firstBuildNative;
-        BuildInternal(id, config, publish: false,
+        BlazorBuildInternal(id, config, publish: false,
                         extraArgs: relink ? "-p:WasmBuildNative=true" : string.Empty);
 
         if (relink)

From 4be35a729f24a2faf9106f5c93397d15e6950b2f Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Tue, 28 Feb 2023 00:40:21 +0000
Subject: [PATCH 03/11] [wasm] Wasm.Build.Tests: Use $(_IsPublishing) to avoid
 unncessary

.. relinking during "Build", when publishing.

`Publish` target triggers `Build` target to run. When publishing, we
don't want to run relinking step during the `Build`, as it will be run
for `Publish` anyway. Earlier there wasn't a good way to differentiate
the two cases of `build` when building, and `build` when publishing, but
now the sdk sets `$(_IsPublishing)=true`, which can be used here.
---
 src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs | 12 +++++++++++-
 src/mono/wasm/build/WasmApp.targets             |  5 +++--
 2 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs b/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs
index 86117d693f3a5..2e54f3b49622c 100644
--- a/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs
@@ -572,7 +572,16 @@ public string CreateBlazorWasmTemplateProject(string id)
 
                 // make sure this assembly gets skipped
                 Assert.DoesNotContain("Microsoft.JSInterop.WebAssembly.dll -> Microsoft.JSInterop.WebAssembly.dll.bc", res.Item1.Output);
+
             }
+
+            if (!options.ExpectRelinkDirWhenPublishing)
+            {
+                // Check that we linked only for publish
+                string objBuildDir = Path.Combine(_projectDir!, "obj", options.Config, options.TargetFramework, "wasm", "for-build");
+                Assert.False(Directory.Exists(objBuildDir), $"Found unexpected {objBuildDir}, which gets created when relinking during Build");
+            }
+
             return res;
         }
 
@@ -1211,7 +1220,8 @@ public record BlazorBuildOptions
         string Config,
         NativeFilesType ExpectedFileType,
         string TargetFramework = BuildTestBase.DefaultTargetFrameworkForBlazor,
-        bool WarnAsError = true
+        bool WarnAsError = true,
+        bool ExpectRelinkDirWhenPublishing=false
     );
 
     public enum GlobalizationMode
diff --git a/src/mono/wasm/build/WasmApp.targets b/src/mono/wasm/build/WasmApp.targets
index 31e9087416d36..db8f3d660b1aa 100644
--- a/src/mono/wasm/build/WasmApp.targets
+++ b/src/mono/wasm/build/WasmApp.targets
@@ -108,7 +108,8 @@
     <_WasmNestedPublishAppPreTarget Condition="'$(DisableAutoWasmPublishApp)' != 'true'">Publish</_WasmNestedPublishAppPreTarget>
 
     <EnableDefaultWasmAssembliesToBundle Condition="'$(EnableDefaultWasmAssembliesToBundle)' == ''">true</EnableDefaultWasmAssembliesToBundle>
-    <WasmBuildOnlyAfterPublish Condition="'$(WasmBuildOnlyAfterPublish)' == '' and '$(DeployOnBuild)' == 'true'">true</WasmBuildOnlyAfterPublish>
+    <!-- VS uses DeployOnBuild, and sdk sets _IsPublishing -->
+    <WasmBuildOnlyAfterPublish Condition="'$(WasmBuildOnlyAfterPublish)' == '' and ('$(DeployOnBuild)' == 'true' or '$(_IsPublishing)' == 'true')">true</WasmBuildOnlyAfterPublish>
     <WasmGenerateAppBundle Condition="'$(WasmGenerateAppBundle)' == '' and '$(OutputType)' != 'Library'">true</WasmGenerateAppBundle>
     <WasmGenerateAppBundle Condition="'$(WasmGenerateAppBundle)' == ''">false</WasmGenerateAppBundle>
     <UseAppHost>false</UseAppHost>
@@ -172,7 +173,7 @@
     <!-- Use a unique property, so the already run wasm targets can also run -->
     <MSBuild Projects="$(MSBuildProjectFile)"
              Targets="WasmNestedPublishApp"
-             Properties="_WasmInNestedPublish_UniqueProperty_XYZ=true;;WasmBuildingForNestedPublish=true;DeployOnBuild=">
+             Properties="_WasmInNestedPublish_UniqueProperty_XYZ=true;;WasmBuildingForNestedPublish=true;DeployOnBuild=;_IsPublishing=">
       <Output TaskParameter="TargetOutputs" ItemName="WasmNestedPublishAppResultItems" />
     </MSBuild>
 

From 306eb0393826e1b953dfd3e7cb4058c06695e87f Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Tue, 28 Feb 2023 02:56:11 +0000
Subject: [PATCH 04/11] fix blazor tests

---
 .../wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs  |  8 ++++----
 src/mono/wasm/Wasm.Build.Tests/Blazor/MiscTests.cs     |  2 +-
 .../wasm/Wasm.Build.Tests/Blazor/NativeRefTests.cs     |  6 +++---
 src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs        | 10 +++++-----
 4 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs b/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs
index a58d275f6b66d..0395a7414c834 100644
--- a/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs
@@ -52,11 +52,11 @@ public void DefaultTemplate_NoAOT_WithWorkload(string config)
         if (config == "Release")
         {
             // relinking in publish for Release config
-            BlazorPublish(new BlazorBuildOptions(id, config, NativeFilesType.Relinked));
+            BlazorPublish(new BlazorBuildOptions(id, config, NativeFilesType.Relinked, ExpectRelinkDirWhenPublishing: true));
         }
         else
         {
-            BlazorPublish(new BlazorBuildOptions(id, config, NativeFilesType.FromRuntimePack));
+            BlazorPublish(new BlazorBuildOptions(id, config, NativeFilesType.FromRuntimePack, ExpectRelinkDirWhenPublishing: true));
         }
     }
 
@@ -121,7 +121,7 @@ public static class MyDllImports
         BlazorBuild(new BlazorBuildOptions(id, config, NativeFilesType.Relinked));
         CheckNativeFileLinked(forPublish: false);
 
-        BlazorPublish(new BlazorBuildOptions(id, config, NativeFilesType.Relinked));
+        BlazorPublish(new BlazorBuildOptions(id, config, NativeFilesType.Relinked, ExpectRelinkDirWhenPublishing: true));
         CheckNativeFileLinked(forPublish: true);
 
         await BlazorRun(config, async (page) =>
@@ -181,7 +181,7 @@ public void BugRegression_60479_WithRazorClassLib()
         BlazorBuild(new BlazorBuildOptions(id, config, NativeFilesType.FromRuntimePack));
 
         // will relink
-        BlazorPublish(new BlazorBuildOptions(id, config, NativeFilesType.Relinked));
+        BlazorPublish(new BlazorBuildOptions(id, config, NativeFilesType.Relinked, ExpectRelinkDirWhenPublishing: true));
 
         // publish/wwwroot/_framework/blazor.boot.json
         string frameworkDir = FindBlazorBinFrameworkDir(config, forPublish: true);
diff --git a/src/mono/wasm/Wasm.Build.Tests/Blazor/MiscTests.cs b/src/mono/wasm/Wasm.Build.Tests/Blazor/MiscTests.cs
index 158c281fefbef..9a094d9d10265 100644
--- a/src/mono/wasm/Wasm.Build.Tests/Blazor/MiscTests.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/Blazor/MiscTests.cs
@@ -83,7 +83,7 @@ public void DefaultTemplate_AOT_InProjectFile(string config)
         BlazorBuild(new BlazorBuildOptions(id, config, NativeFilesType.FromRuntimePack));
 
         // will aot
-        BlazorPublish(new BlazorBuildOptions(id, config, NativeFilesType.AOT));
+        BlazorPublish(new BlazorBuildOptions(id, config, NativeFilesType.AOT, ExpectRelinkDirWhenPublishing: true));
 
         // build again
         BlazorBuild(new BlazorBuildOptions(id, config, NativeFilesType.FromRuntimePack));
diff --git a/src/mono/wasm/Wasm.Build.Tests/Blazor/NativeRefTests.cs b/src/mono/wasm/Wasm.Build.Tests/Blazor/NativeRefTests.cs
index 7fa5eb2475e43..c9b34d0652b2c 100644
--- a/src/mono/wasm/Wasm.Build.Tests/Blazor/NativeRefTests.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/Blazor/NativeRefTests.cs
@@ -32,7 +32,7 @@ public void WithNativeReference_AOTInProjectFile(string config)
 
         BlazorBuild(new BlazorBuildOptions(id, config, NativeFilesType.Relinked));
 
-        BlazorPublish(new BlazorBuildOptions(id, config, NativeFilesType.AOT));
+        BlazorPublish(new BlazorBuildOptions(id, config, NativeFilesType.AOT, ExpectRelinkDirWhenPublishing: true));
 
         // will relink
         BlazorBuild(new BlazorBuildOptions(id, config, NativeFilesType.Relinked));
@@ -53,10 +53,10 @@ public void WithNativeReference_AOTOnCommandLine(string config)
 
         BlazorBuild(new BlazorBuildOptions(id, config, NativeFilesType.Relinked));
 
-        BlazorPublish(new BlazorBuildOptions(id, config, NativeFilesType.AOT), "-p:RunAOTCompilation=true");
+        BlazorPublish(new BlazorBuildOptions(id, config, NativeFilesType.AOT, ExpectRelinkDirWhenPublishing: true), "-p:RunAOTCompilation=true");
 
         // no aot!
-        BlazorPublish(new BlazorBuildOptions(id, config, NativeFilesType.Relinked));
+        BlazorPublish(new BlazorBuildOptions(id, config, NativeFilesType.Relinked, ExpectRelinkDirWhenPublishing: true));
     }
 }
 
diff --git a/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs b/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs
index 2e54f3b49622c..724605df7f02e 100644
--- a/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs
@@ -575,12 +575,12 @@ public string CreateBlazorWasmTemplateProject(string id)
 
             }
 
-            if (!options.ExpectRelinkDirWhenPublishing)
-            {
-                // Check that we linked only for publish
-                string objBuildDir = Path.Combine(_projectDir!, "obj", options.Config, options.TargetFramework, "wasm", "for-build");
+            string objBuildDir = Path.Combine(_projectDir!, "obj", options.Config, options.TargetFramework, "wasm", "for-build");
+            // Check that we linked only for publish
+            if (options.ExpectRelinkDirWhenPublishing)
+                Assert.True(Directory.Exists(objBuildDir), $"Could not find expected {objBuildDir}, which gets created when relinking during Build. This is liokely a test authoring error");
+            else
                 Assert.False(Directory.Exists(objBuildDir), $"Found unexpected {objBuildDir}, which gets created when relinking during Build");
-            }
 
             return res;
         }

From 8950797b3b1c4a9b05d689309369121eb97030eb Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Tue, 28 Feb 2023 20:34:07 +0000
Subject: [PATCH 05/11] Wasm.Build.Tests: Add support for running published
 blazor projects

`dotnet run` uses the regular build output. Published blazor app, like
when using AOT, needs to be run more "manually" by starting a web server
in the publish folder. This is accomplished here by using the new
xharness command `wasm webserver`.
---
 .../Blazor/BuildPublishTests.cs               | 48 +++++++++++++------
 .../wasm/Wasm.Build.Tests/BrowserRunner.cs    |  2 +-
 .../Wasm.Build.Tests/BuildPublishTests.cs     |  1 -
 .../wasm/Wasm.Build.Tests/BuildTestBase.cs    | 15 ++++--
 4 files changed, 47 insertions(+), 19 deletions(-)

diff --git a/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs b/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs
index 0395a7414c834..206ade3aecefa 100644
--- a/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs
@@ -82,12 +82,23 @@ public void DefaultTemplate_NoAOT_WithWorkload(string config)
     //}
 
     [Theory]
-    [InlineData("Debug")]
-    [InlineData("Release")]
-    public async Task WithDllImportInMainAssembly(string config)
+    [InlineData("Debug", /*build*/true, /*publish*/false)]
+    [InlineData("Debug", /*build*/false, /*publish*/true)]
+    [InlineData("Debug", /*build*/true, /*publish*/true)]
+    [InlineData("Release", /*build*/true, /*publish*/false)]
+    [InlineData("Release", /*build*/false, /*publish*/true)]
+    [InlineData("Release", /*build*/true, /*publish*/true)]
+    public async Task WithDllImportInMainAssembly(string config, bool build, bool publish)
     {
         // Based on https://github.com/dotnet/runtime/issues/59255
-        string id = $"blz_dllimp_{config}";
+        string id = $"blz_dllimp_{config}_";
+        if (build && publish)
+            id += "build_then_publish";
+        else if (build)
+            id += "build";
+        else
+            id += "publish";
+
         string projectFile = CreateProjectWithNativeReference(id);
         string nativeSource = @"
             #include <stdio.h>
@@ -118,18 +129,29 @@ public static class MyDllImports
             outputText = $"{result}";
         """);
 
-        BlazorBuild(new BlazorBuildOptions(id, config, NativeFilesType.Relinked));
-        CheckNativeFileLinked(forPublish: false);
+        if (build)
+        {
+            BlazorBuild(new BlazorBuildOptions(id, config, NativeFilesType.Relinked));
+            CheckNativeFileLinked(forPublish: false);
+        }
+
+        if (publish)
+        {
+            BlazorPublish(new BlazorBuildOptions(id, config, NativeFilesType.Relinked, ExpectRelinkDirWhenPublishing: build));
+            CheckNativeFileLinked(forPublish: true);
+        }
 
-        BlazorPublish(new BlazorBuildOptions(id, config, NativeFilesType.Relinked, ExpectRelinkDirWhenPublishing: true));
-        CheckNativeFileLinked(forPublish: true);
+        if (publish)
+            await BlazorRunForPublishWithWebServer(config, TestDllImport);
+        else
+            await BlazorRunForBuildWithDotnetRun(config, TestDllImport);
 
-        await BlazorRun(config, async (page) =>
+        async Task TestDllImport(IPage page)
         {
             await page.Locator("text=\"cpp_add\"").ClickAsync();
             var txt = await page.Locator("p[role='test']").InnerHTMLAsync();
             Assert.Equal("Output: 22", txt);
-        });
+        }
 
         void CheckNativeFileLinked(bool forPublish)
         {
@@ -211,14 +233,12 @@ public async Task BlazorBuildRunTest(string config)
                 .Execute($"build -c {config} -bl:{Path.Combine(s_buildEnv.LogRootPath, $"{id}.binlog")}")
                 .EnsureSuccessful();
 
-        await BlazorRun(config);
+        await BlazorRunForBuildWithDotnetRun(config);
     }
 
     [ConditionalTheory(typeof(BuildTestBase), nameof(IsUsingWorkloads))]
-#if TEST_DEBUG_CONFIG_ALSO
     [InlineData("Debug", false)]
     [InlineData("Debug", true)]
-#endif
     [InlineData("Release", false)]
     [InlineData("Release", true)]
     public async Task BlazorPublishRunTest(string config, bool aot)
@@ -233,7 +253,7 @@ public async Task BlazorPublishRunTest(string config, bool aot)
                 .Execute($"publish -c {config} -bl:{Path.Combine(s_buildEnv.LogRootPath, $"{id}.binlog")}")
                 .EnsureSuccessful();
 
-        await BlazorRun(config);
+        await BlazorRunForPublishWithWebServer(config);
     }
 
 }
diff --git a/src/mono/wasm/Wasm.Build.Tests/BrowserRunner.cs b/src/mono/wasm/Wasm.Build.Tests/BrowserRunner.cs
index e1d8a110e895d..f7be214f24f94 100644
--- a/src/mono/wasm/Wasm.Build.Tests/BrowserRunner.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/BrowserRunner.cs
@@ -77,7 +77,7 @@ public async Task<IPage> RunAsync(ToolCommand cmd, string args, bool headless =
             throw new Exception($"Process ended before the url was found");
         }
         if (!urlAvailable.Task.IsCompleted)
-            throw new Exception("Timed out waiting for the app host url");
+            throw new Exception("Timed out waiting for the web server url");
 
         var url = new Uri(urlAvailable.Task.Result);
         Playwright = await Microsoft.Playwright.Playwright.CreateAsync();
diff --git a/src/mono/wasm/Wasm.Build.Tests/BuildPublishTests.cs b/src/mono/wasm/Wasm.Build.Tests/BuildPublishTests.cs
index c798c79cd041f..f307f20e63b2f 100644
--- a/src/mono/wasm/Wasm.Build.Tests/BuildPublishTests.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/BuildPublishTests.cs
@@ -41,7 +41,6 @@ public void BuildThenPublishNoAOT(BuildArgs buildArgs, RunHost host, string id)
                         Publish: false
                         ));
 
-
             Run();
 
             if (!_buildContext.TryGetBuildFor(buildArgs, out BuildProduct? product))
diff --git a/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs b/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs
index 724605df7f02e..a676898494956 100644
--- a/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs
@@ -932,13 +932,22 @@ public void BlazorAddRazorButton(string buttonText, string customCode, string me
             File.WriteAllText(counterRazorPath, oldContent + additionalCode);
         }
 
-        public async Task BlazorRun(string config, Func<IPage, Task>? test=null, string extraArgs="--no-build")
+        public Task BlazorRunForBuildWithDotnetRun(string config, Func<IPage, Task>? test=null, string extraArgs="--no-build")
+            => BlazorRunTest($"run -c {config} {extraArgs}", _projectDir!, test);
+
+
+        public Task BlazorRunForPublishWithWebServer(string config, Func<IPage, Task>? test=null, string extraArgs="")
+            => BlazorRunTest($"{s_xharnessRunnerCommand} wasm webserver --app=. --web-server-use-default-files {extraArgs}",
+                             Path.GetFullPath(Path.Combine(FindBlazorBinFrameworkDir(config, forPublish: true), "..")),
+                             test);
+
+        public async Task BlazorRunTest(string runArgs, string workingDirectory, Func<IPage, Task>? test=null)
         {
             using var runCommand = new RunCommand(s_buildEnv, _testOutput)
-                                        .WithWorkingDirectory(_projectDir!);
+                                        .WithWorkingDirectory(workingDirectory);
 
             await using var runner = new BrowserRunner(_testOutput);
-            var page = await runner.RunAsync(runCommand, $"run -c {config} {extraArgs}", onConsoleMessage: OnConsoleMessage);
+            var page = await runner.RunAsync(runCommand, runArgs, onConsoleMessage: OnConsoleMessage);
 
             await page.Locator("text=Counter").ClickAsync();
             var txt = await page.Locator("p[role='status']").InnerHTMLAsync();

From e5c4c0db80421a13e35633c62b2eb24f66e81ebe Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Wed, 1 Mar 2023 00:44:18 +0000
Subject: [PATCH 06/11] Detect runtime assertions in blazor runs

---
 src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs b/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs
index a676898494956..68a6b9d6beb39 100644
--- a/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/BuildTestBase.cs
@@ -932,16 +932,20 @@ public void BlazorAddRazorButton(string buttonText, string customCode, string me
             File.WriteAllText(counterRazorPath, oldContent + additionalCode);
         }
 
+        // Keeping these methods with explicit Build/Publish in the name
+        // so in the test code it is evident which is being run!
         public Task BlazorRunForBuildWithDotnetRun(string config, Func<IPage, Task>? test=null, string extraArgs="--no-build")
             => BlazorRunTest($"run -c {config} {extraArgs}", _projectDir!, test);
 
-
         public Task BlazorRunForPublishWithWebServer(string config, Func<IPage, Task>? test=null, string extraArgs="")
             => BlazorRunTest($"{s_xharnessRunnerCommand} wasm webserver --app=. --web-server-use-default-files {extraArgs}",
                              Path.GetFullPath(Path.Combine(FindBlazorBinFrameworkDir(config, forPublish: true), "..")),
                              test);
 
-        public async Task BlazorRunTest(string runArgs, string workingDirectory, Func<IPage, Task>? test=null)
+        public async Task BlazorRunTest(string runArgs,
+                                        string workingDirectory,
+                                        Func<IPage, Task>? test = null,
+                                        bool detectRuntimeFailures = true)
         {
             using var runCommand = new RunCommand(s_buildEnv, _testOutput)
                                         .WithWorkingDirectory(workingDirectory);
@@ -965,6 +969,12 @@ void OnConsoleMessage(IConsoleMessage msg)
                 if (EnvironmentVariables.ShowBuildOutput)
                     Console.WriteLine($"[{msg.Type}] {msg.Text}");
                 _testOutput.WriteLine($"[{msg.Type}] {msg.Text}");
+
+                if (detectRuntimeFailures)
+                {
+                    if (msg.Text.Contains("[MONO] * Assertion") || msg.Text.Contains("Error: [MONO] "))
+                        throw new XunitException($"Detected a runtime failure at line: {msg.Text}");
+                }
             }
         }
 

From 5e7c9684169dde29877a9d12d8e28b72bd1b7cb2 Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Wed, 1 Mar 2023 05:46:15 +0000
Subject: [PATCH 07/11] Update test to track changes

---
 src/mono/wasm/Wasm.Build.Tests/WasmNativeDefaultsTests.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/mono/wasm/Wasm.Build.Tests/WasmNativeDefaultsTests.cs b/src/mono/wasm/Wasm.Build.Tests/WasmNativeDefaultsTests.cs
index 00674bf4630dc..95354ee41b6f8 100644
--- a/src/mono/wasm/Wasm.Build.Tests/WasmNativeDefaultsTests.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/WasmNativeDefaultsTests.cs
@@ -40,7 +40,9 @@ public void Defaults(string config, string extraProperties, bool aot, bool build
         {
             string output = CheckWasmNativeDefaultValue("native_defaults_publish", config, extraProperties, aot, dotnetWasmFromRuntimePack: !publishValue);
 
-            Assert.Contains($"** WasmBuildNative: '{buildValue.ToString().ToLower()}', WasmBuildingForNestedPublish: ''", output);
+            // for build
+            Assert.DoesNotContain($"** WasmBuildNative: '{buildValue.ToString().ToLower()}', WasmBuildingForNestedPublish: ''", output);
+            // for publish
             Assert.Contains($"** WasmBuildNative: '{publishValue.ToString().ToLower()}', WasmBuildingForNestedPublish: 'true'", output);
             Assert.Contains("Stopping the build", output);
         }

From 09052b655ff2f55ee420c8350343934884256c4b Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Wed, 1 Mar 2023 08:35:50 +0000
Subject: [PATCH 08/11] cleanup

---
 .../Wasm.Build.Tests/Blazor/BuildPublishTests.cs     | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

diff --git a/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs b/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs
index 206ade3aecefa..8b0b12a8cf914 100644
--- a/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs
@@ -228,11 +228,7 @@ public async Task BlazorBuildRunTest(string config)
         string id = $"blazor_{config}_{Path.GetRandomFileName()}";
         string projectFile = CreateWasmTemplateProject(id, "blazorwasm");
 
-        new DotNetCommand(s_buildEnv, _testOutput)
-                .WithWorkingDirectory(_projectDir!)
-                .Execute($"build -c {config} -bl:{Path.Combine(s_buildEnv.LogRootPath, $"{id}.binlog")}")
-                .EnsureSuccessful();
-
+        BlazorBuild(new BlazorBuildOptions(id, config, NativeFilesType.FromRuntimePack));
         await BlazorRunForBuildWithDotnetRun(config);
     }
 
@@ -248,11 +244,7 @@ public async Task BlazorPublishRunTest(string config, bool aot)
         if (aot)
             AddItemsPropertiesToProject(projectFile, "<RunAOTCompilation>true</RunAOTCompilation>");
 
-        new DotNetCommand(s_buildEnv, _testOutput)
-                .WithWorkingDirectory(_projectDir!)
-                .Execute($"publish -c {config} -bl:{Path.Combine(s_buildEnv.LogRootPath, $"{id}.binlog")}")
-                .EnsureSuccessful();
-
+        BlazorPublish(new BlazorBuildOptions(id, config, aot ? NativeFilesType.AOT : NativeFilesType.Relinked));
         await BlazorRunForPublishWithWebServer(config);
     }
 

From 17a82559daa33b154b6bab9da39ec6cf196862c6 Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Wed, 1 Mar 2023 08:42:03 +0000
Subject: [PATCH 09/11] Disable BlazorPublishRunTest because of
 https://github.com/dotnet/runtime/issues/82481

---
 src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs b/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs
index 8b0b12a8cf914..63e2caeb46b85 100644
--- a/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/Blazor/BuildPublishTests.cs
@@ -232,6 +232,7 @@ public async Task BlazorBuildRunTest(string config)
         await BlazorRunForBuildWithDotnetRun(config);
     }
 
+    [ActiveIssue("https://github.com/dotnet/runtime/issues/82481")]
     [ConditionalTheory(typeof(BuildTestBase), nameof(IsUsingWorkloads))]
     [InlineData("Debug", false)]
     [InlineData("Debug", true)]

From 5ff3c1c873be3f7ac7f4bc4db3aae7326a12bbc4 Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Wed, 1 Mar 2023 08:46:25 +0000
Subject: [PATCH 10/11] Update test to track changes

---
 src/mono/wasm/Wasm.Build.Tests/WasmNativeDefaultsTests.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/mono/wasm/Wasm.Build.Tests/WasmNativeDefaultsTests.cs b/src/mono/wasm/Wasm.Build.Tests/WasmNativeDefaultsTests.cs
index 95354ee41b6f8..defc01d905783 100644
--- a/src/mono/wasm/Wasm.Build.Tests/WasmNativeDefaultsTests.cs
+++ b/src/mono/wasm/Wasm.Build.Tests/WasmNativeDefaultsTests.cs
@@ -63,7 +63,9 @@ public void WithNativeReference(string config, string extraProperties, bool buil
                                                         dotnetWasmFromRuntimePack: !publishValue,
                                                         extraItems: nativeRefItem);
 
-            Assert.Contains($"** WasmBuildNative: '{buildValue.ToString().ToLower()}', WasmBuildingForNestedPublish: ''", output);
+            // for build
+            Assert.DoesNotContain($"** WasmBuildNative: '{buildValue.ToString().ToLower()}', WasmBuildingForNestedPublish: ''", output);
+            // for publish
             Assert.Contains($"** WasmBuildNative: '{publishValue.ToString().ToLower()}', WasmBuildingForNestedPublish: 'true'", output);
             Assert.Contains("Stopping the build", output);
         }

From 2ba2ac7e77ad9907e0c8f37e6c799d793d9add67 Mon Sep 17 00:00:00 2001
From: Ankit Jain <radical@gmail.com>
Date: Thu, 2 Mar 2023 03:06:49 -0500
Subject: [PATCH 11/11] Update xharness dependency

Updating 'Microsoft.DotNet.XHarness.CLI': '1.0.0-prerelease.23117.1' => '1.0.0-prerelease.23151.1' (from build '20230301.1' of 'https://github.com/dotnet/xharness')
Updating 'Microsoft.DotNet.XHarness.TestRunners.Common': '1.0.0-prerelease.23117.1' => '1.0.0-prerelease.23151.1' (from build '20230301.1' of 'https://github.com/dotnet/xharness')
Updating 'Microsoft.DotNet.XHarness.TestRunners.Xunit': '1.0.0-prerelease.23117.1' => '1.0.0-prerelease.23151.1' (from build '20230301.1' of 'https://github.com/dotnet/xharness')
---
 .config/dotnet-tools.json |  2 +-
 eng/Version.Details.xml   | 12 ++++++------
 eng/Versions.props        |  6 +++---
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json
index f8fcfe0c53fe8..90b0fe051ae14 100644
--- a/.config/dotnet-tools.json
+++ b/.config/dotnet-tools.json
@@ -15,7 +15,7 @@
       ]
     },
     "microsoft.dotnet.xharness.cli": {
-      "version": "1.0.0-prerelease.23117.1",
+      "version": "1.0.0-prerelease.23151.1",
       "commands": [
         "xharness"
       ]
diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index 8e688f35afc0e..810e6717969fa 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -284,17 +284,17 @@
       <Uri>https://github.com/dotnet/runtime</Uri>
       <Sha>252018c3d3fffdb592413cf61d5b80cf751e0a59</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XHarness.TestRunners.Common" Version="1.0.0-prerelease.23117.1">
+    <Dependency Name="Microsoft.DotNet.XHarness.TestRunners.Common" Version="1.0.0-prerelease.23151.1">
       <Uri>https://github.com/dotnet/xharness</Uri>
-      <Sha>8d789cbeecb6c89bf470fdc7727a8f501724fc8a</Sha>
+      <Sha>05d4d5fc8634fa68ec53a9a3b31271797f4a0c7c</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XHarness.TestRunners.Xunit" Version="1.0.0-prerelease.23117.1">
+    <Dependency Name="Microsoft.DotNet.XHarness.TestRunners.Xunit" Version="1.0.0-prerelease.23151.1">
       <Uri>https://github.com/dotnet/xharness</Uri>
-      <Sha>8d789cbeecb6c89bf470fdc7727a8f501724fc8a</Sha>
+      <Sha>05d4d5fc8634fa68ec53a9a3b31271797f4a0c7c</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.XHarness.CLI" Version="1.0.0-prerelease.23117.1">
+    <Dependency Name="Microsoft.DotNet.XHarness.CLI" Version="1.0.0-prerelease.23151.1">
       <Uri>https://github.com/dotnet/xharness</Uri>
-      <Sha>8d789cbeecb6c89bf470fdc7727a8f501724fc8a</Sha>
+      <Sha>05d4d5fc8634fa68ec53a9a3b31271797f4a0c7c</Sha>
     </Dependency>
     <Dependency Name="Microsoft.DotNet.PackageTesting" Version="8.0.0-beta.23123.2">
       <Uri>https://github.com/dotnet/arcade</Uri>
diff --git a/eng/Versions.props b/eng/Versions.props
index 4c349fc88b82e..dc8dd280a1597 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -185,9 +185,9 @@
     <!-- Testing -->
     <MicrosoftNETCoreCoreDisToolsVersion>1.1.0</MicrosoftNETCoreCoreDisToolsVersion>
     <MicrosoftNETTestSdkVersion>17.4.0-preview-20220707-01</MicrosoftNETTestSdkVersion>
-    <MicrosoftDotNetXHarnessTestRunnersCommonVersion>1.0.0-prerelease.23117.1</MicrosoftDotNetXHarnessTestRunnersCommonVersion>
-    <MicrosoftDotNetXHarnessTestRunnersXunitVersion>1.0.0-prerelease.23117.1</MicrosoftDotNetXHarnessTestRunnersXunitVersion>
-    <MicrosoftDotNetXHarnessCLIVersion>1.0.0-prerelease.23117.1</MicrosoftDotNetXHarnessCLIVersion>
+    <MicrosoftDotNetXHarnessTestRunnersCommonVersion>1.0.0-prerelease.23151.1</MicrosoftDotNetXHarnessTestRunnersCommonVersion>
+    <MicrosoftDotNetXHarnessTestRunnersXunitVersion>1.0.0-prerelease.23151.1</MicrosoftDotNetXHarnessTestRunnersXunitVersion>
+    <MicrosoftDotNetXHarnessCLIVersion>1.0.0-prerelease.23151.1</MicrosoftDotNetXHarnessCLIVersion>
     <MicrosoftDotNetHotReloadUtilsGeneratorBuildToolVersion>1.1.0-alpha.0.23113.1</MicrosoftDotNetHotReloadUtilsGeneratorBuildToolVersion>
     <XUnitVersion>2.4.2</XUnitVersion>
     <XUnitAnalyzersVersion>1.0.0</XUnitAnalyzersVersion>