Move Integration into test

22 files changed, 3107 insertions, 0 deletions

diff --git a/src/test/burn/WixToolsetTest.BurnE2E/BasicFunctionalityTests.cs b/src/test/burn/WixToolsetTest.BurnE2E/BasicFunctionalityTests.cs
new file mode 100644
index 00000000..5df86fff
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/BasicFunctionalityTests.cs
@@ -0,0 +1,176 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using System;
+    using System.IO;
+    using Xunit;
+    using Xunit.Abstractions;
+
+    public class BasicFunctionalityTests : BurnE2ETests
+    {
+        public BasicFunctionalityTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
+
+        [Fact]
+        public void CanInstallAndUninstallSimpleBundle_x86_wixstdba()
+        {
+            var packageA = this.CreatePackageInstaller("PackageA");
+
+            var bundleA = this.CreateBundleInstaller("BundleA");
+
+            var packageASourceCodeInstalled = packageA.GetInstalledFilePath("Package.wxs");
+
+            // Source file should *not* be installed
+            Assert.False(File.Exists(packageASourceCodeInstalled), $"Package A payload should not be there on test start: {packageASourceCodeInstalled}");
+
+            bundleA.Install();
+
+            var cachedBundlePath = bundleA.VerifyRegisteredAndInPackageCache();
+
+            // Source file should be installed
+            Assert.True(File.Exists(packageASourceCodeInstalled), String.Concat("Should have found Package A payload installed at: ", packageASourceCodeInstalled));
+
+            bundleA.Uninstall(cachedBundlePath);
+
+            // Source file should *not* be installed
+            Assert.False(File.Exists(packageASourceCodeInstalled), String.Concat("Package A payload should have been removed by uninstall from: ", packageASourceCodeInstalled));
+
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache(cachedBundlePath);
+        }
+
+        [Fact]
+        public void CanInstallAndUninstallSimpleBundle_x86_testba()
+        {
+            var packageA = this.CreatePackageInstaller("PackageA");
+
+            var bundleB = this.CreateBundleInstaller("BundleB");
+
+            var packageASourceCodeInstalled = packageA.GetInstalledFilePath("Package.wxs");
+
+            // Source file should *not* be installed
+            Assert.False(File.Exists(packageASourceCodeInstalled), $"Package A payload should not be there on test start: {packageASourceCodeInstalled}");
+
+            bundleB.Install();
+
+            var cachedBundlePath = bundleB.VerifyRegisteredAndInPackageCache();
+
+            // Source file should be installed
+            Assert.True(File.Exists(packageASourceCodeInstalled), String.Concat("Should have found Package A payload installed at: ", packageASourceCodeInstalled));
+
+            bundleB.Uninstall(cachedBundlePath);
+
+            // Source file should *not* be installed
+            Assert.False(File.Exists(packageASourceCodeInstalled), String.Concat("Package A payload should have been removed by uninstall from: ", packageASourceCodeInstalled));
+
+            bundleB.VerifyUnregisteredAndRemovedFromPackageCache(cachedBundlePath);
+        }
+
+        [Fact]
+        public void CanInstallAndUninstallSimpleBundle_x86_dnctestba()
+        {
+            var packageA = this.CreatePackageInstaller("PackageA");
+
+            var bundleC = this.CreateBundleInstaller("BundleC");
+
+            var packageASourceCodeInstalled = packageA.GetInstalledFilePath("Package.wxs");
+
+            // Source file should *not* be installed
+            Assert.False(File.Exists(packageASourceCodeInstalled), $"Package A payload should not be there on test start: {packageASourceCodeInstalled}");
+
+            bundleC.Install();
+
+            var cachedBundlePath = bundleC.VerifyRegisteredAndInPackageCache();
+
+            // Source file should be installed
+            Assert.True(File.Exists(packageASourceCodeInstalled), String.Concat("Should have found Package A payload installed at: ", packageASourceCodeInstalled));
+
+            bundleC.Uninstall(cachedBundlePath);
+
+            // Source file should *not* be installed
+            Assert.False(File.Exists(packageASourceCodeInstalled), String.Concat("Package A payload should have been removed by uninstall from: ", packageASourceCodeInstalled));
+
+            bundleC.VerifyUnregisteredAndRemovedFromPackageCache(cachedBundlePath);
+        }
+
+        [Fact]
+        public void CanInstallAndUninstallSimpleBundle_x64_wixstdba()
+        {
+            var packageA_x64 = this.CreatePackageInstaller("PackageA_x64");
+
+            var bundleA_x64 = this.CreateBundleInstaller("BundleA_x64");
+
+            var packageASourceCodeInstalled = packageA_x64.GetInstalledFilePath("Package.wxs");
+
+            // Source file should *not* be installed
+            Assert.False(File.Exists(packageASourceCodeInstalled), $"Package A x64 payload should not be there on test start: {packageASourceCodeInstalled}");
+
+            bundleA_x64.Install();
+
+            var cachedBundlePath = bundleA_x64.VerifyRegisteredAndInPackageCache();
+
+            // Source file should be installed
+            Assert.True(File.Exists(packageASourceCodeInstalled), String.Concat("Should have found Package A x64 payload installed at: ", packageASourceCodeInstalled));
+
+            bundleA_x64.Uninstall(cachedBundlePath);
+
+            // Source file should *not* be installed
+            Assert.False(File.Exists(packageASourceCodeInstalled), String.Concat("Package A x64 payload should have been removed by uninstall from: ", packageASourceCodeInstalled));
+
+            bundleA_x64.VerifyUnregisteredAndRemovedFromPackageCache(cachedBundlePath);
+        }
+
+        [Fact]
+        public void CanInstallAndUninstallSimpleBundle_x64_testba()
+        {
+            var packageA_x64 = this.CreatePackageInstaller("PackageA_x64");
+
+            var bundleB_x64 = this.CreateBundleInstaller("BundleB_x64");
+
+            var packageASourceCodeInstalled = packageA_x64.GetInstalledFilePath("Package.wxs");
+
+            // Source file should *not* be installed
+            Assert.False(File.Exists(packageASourceCodeInstalled), $"Package A x64 payload should not be there on test start: {packageASourceCodeInstalled}");
+
+            bundleB_x64.Install();
+
+            var cachedBundlePath = bundleB_x64.VerifyRegisteredAndInPackageCache();
+
+            // Source file should be installed
+            Assert.True(File.Exists(packageASourceCodeInstalled), String.Concat("Should have found Package A x64 payload installed at: ", packageASourceCodeInstalled));
+
+            bundleB_x64.Uninstall(cachedBundlePath);
+
+            // Source file should *not* be installed
+            Assert.False(File.Exists(packageASourceCodeInstalled), String.Concat("Package A x64 payload should have been removed by uninstall from: ", packageASourceCodeInstalled));
+
+            bundleB_x64.VerifyUnregisteredAndRemovedFromPackageCache(cachedBundlePath);
+        }
+
+        [Fact]
+        public void CanInstallAndUninstallSimpleBundle_x64_dnctestba()
+        {
+            var packageA_x64 = this.CreatePackageInstaller("PackageA_x64");
+
+            var bundleC_x64 = this.CreateBundleInstaller("BundleC_x64");
+
+            var packageASourceCodeInstalled = packageA_x64.GetInstalledFilePath("Package.wxs");
+
+            // Source file should *not* be installed
+            Assert.False(File.Exists(packageASourceCodeInstalled), $"Package A x64 payload should not be there on test start: {packageASourceCodeInstalled}");
+
+            bundleC_x64.Install();
+
+            var cachedBundlePath = bundleC_x64.VerifyRegisteredAndInPackageCache();
+
+            // Source file should be installed
+            Assert.True(File.Exists(packageASourceCodeInstalled), String.Concat("Should have found Package A x64 payload installed at: ", packageASourceCodeInstalled));
+
+            bundleC_x64.Uninstall(cachedBundlePath);
+
+            // Source file should *not* be installed
+            Assert.False(File.Exists(packageASourceCodeInstalled), String.Concat("Package A x64 payload should have been removed by uninstall from: ", packageASourceCodeInstalled));
+
+            bundleC_x64.VerifyUnregisteredAndRemovedFromPackageCache(cachedBundlePath);
+        }
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/BurnE2EFixture.cs b/src/test/burn/WixToolsetTest.BurnE2E/BurnE2EFixture.cs
new file mode 100644
index 00000000..babfcbc3
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/BurnE2EFixture.cs
@@ -0,0 +1,28 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using System;
+    using System.Security.Principal;
+
+    public class BurnE2EFixture
+    {
+        const string RequiredEnvironmentVariableName = "RuntimeTestsEnabled";
+
+        public BurnE2EFixture()
+        {
+            using var identity = WindowsIdentity.GetCurrent();
+            var principal = new WindowsPrincipal(identity);
+            if (!principal.IsInRole(WindowsBuiltInRole.Administrator))
+            {
+                throw new InvalidOperationException("These tests must run elevated.");
+            }
+
+            var testsEnabledString = Environment.GetEnvironmentVariable(RequiredEnvironmentVariableName);
+            if (!bool.TryParse(testsEnabledString, out var testsEnabled) || !testsEnabled)
+            {
+                throw new InvalidOperationException($"These tests affect machine state. Set the {RequiredEnvironmentVariableName} environment variable to true to accept the consequences.");
+            }
+        }
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/BurnE2ETests.cs b/src/test/burn/WixToolsetTest.BurnE2E/BurnE2ETests.cs
new file mode 100644
index 00000000..392b675d
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/BurnE2ETests.cs
@@ -0,0 +1,63 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using System;
+    using System.Collections.Generic;
+    using WixTestTools;
+    using Xunit;
+    using Xunit.Abstractions;
+
+    [Collection("BurnE2E")]
+    public abstract class BurnE2ETests : WixTestBase, IDisposable
+    {
+        protected BurnE2ETests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
+
+        private Stack<IDisposable> Installers { get; } = new Stack<IDisposable>();
+
+        protected BundleInstaller CreateBundleInstaller(string name)
+        {
+            var installer = new BundleInstaller(this.TestContext, name);
+            this.Installers.Push(installer);
+            return installer;
+        }
+
+        protected PackageInstaller CreatePackageInstaller(string filename)
+        {
+            var installer = new PackageInstaller(this.TestContext, filename);
+            this.Installers.Push(installer);
+            return installer;
+        }
+
+        protected TestBAController CreateTestBAController()
+        {
+            var controller = new TestBAController(this.TestContext);
+            this.Installers.Push(controller);
+            return controller;
+        }
+
+        protected IWebServer CreateWebServer()
+        {
+            var webServer = new CoreOwinWebServer();
+            this.Installers.Push(webServer);
+            return webServer;
+        }
+
+        public void Dispose()
+        {
+            while (this.Installers.TryPop(out var installer))
+            {
+                try
+                {
+                    installer.Dispose();
+                }
+                catch { }
+            }
+        }
+    }
+
+    [CollectionDefinition("BurnE2E", DisableParallelization = true)]
+    public class BurnE2ECollectionDefinition : ICollectionFixture<BurnE2EFixture>
+    {
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/CacheTests.cs b/src/test/burn/WixToolsetTest.BurnE2E/CacheTests.cs
new file mode 100644
index 00000000..e8d37aef
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/CacheTests.cs
@@ -0,0 +1,133 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using System.Collections.Generic;
+    using System.IO;
+    using WixBuildTools.TestSupport;
+    using WixTestTools;
+    using WixToolset.Mba.Core;
+    using Xunit;
+    using Xunit.Abstractions;
+
+    public class CacheTests : BurnE2ETests
+    {
+        public CacheTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
+
+        [Fact]
+        public void CanCache5GBFile()
+        {
+            var packageA = this.CreatePackageInstaller("PackageA");
+            var bundleC = this.CreateBundleInstaller("BundleC");
+
+            packageA.VerifyInstalled(false);
+
+            // Recreate the 5GB payload to avoid having to copy it to the VM to run the tests.
+            var targetFilePath = Path.Combine(this.TestContext.TestDataFolder, "fivegb.file");
+            if (!File.Exists(targetFilePath))
+            {
+                var testTool = new TestTool(Path.Combine(TestData.Get(), "win-x86", "TestExe.exe"))
+                {
+                    Arguments = "/lf \"" + targetFilePath + "|5368709120\"",
+                    ExpectedExitCode = 0,
+                };
+                testTool.Run(true);
+            }
+
+            bundleC.Install();
+            bundleC.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+        }
+
+        [Fact]
+        public void CanDownloadPayloadsFromMissingAttachedContainer()
+        {
+            var packageA = this.CreatePackageInstaller("PackageA");
+            var packageB = this.CreatePackageInstaller("PackageB");
+            var bundleA = this.CreateBundleInstaller("BundleA");
+            var testBAController = this.CreateTestBAController();
+            var webServer = this.CreateWebServer();
+
+            webServer.AddFiles(new Dictionary<string, string>
+            {
+                { "/BundleA/PackageA.msi", Path.Combine(this.TestContext.TestDataFolder, "PackageA.msi") },
+                { "/BundleA/PackageB.msi", Path.Combine(this.TestContext.TestDataFolder, "PackageB.msi") },
+            });
+            webServer.Start();
+
+            // Don't install PackageB initially so it will be installed when run from the package cache.
+            testBAController.SetPackageRequestedState("PackageB", RequestState.Absent);
+
+            packageA.VerifyInstalled(false);
+            packageB.VerifyInstalled(false);
+
+            // Manually copy bundle to separate directory, install from there, and then delete it
+            // so that when run from the package cache, it can't find the attached container.
+            using (var dfs = new DisposableFileSystem())
+            {
+                var tempDirectory = dfs.GetFolder(true);
+
+                var bundleAFileInfo = new FileInfo(bundleA.Bundle);
+                var bundleACopiedPath = Path.Combine(tempDirectory, bundleAFileInfo.Name);
+                bundleAFileInfo.CopyTo(bundleACopiedPath);
+
+                bundleA.Install(bundleACopiedPath);
+            }
+
+            var bundlePackageCachePath = bundleA.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageB.VerifyInstalled(false);
+
+            testBAController.SetPackageRequestedState("PackageB", RequestState.Present);
+
+            bundleA.Modify(bundlePackageCachePath);
+            bundleA.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageB.VerifyInstalled(true);
+        }
+
+        [Fact]
+        public void CanFindAttachedContainerFromRenamedBundle()
+        {
+            var packageA = this.CreatePackageInstaller("PackageA");
+            var packageB = this.CreatePackageInstaller("PackageB");
+            var bundleB = this.CreateBundleInstaller("BundleB");
+            var testBAController = this.CreateTestBAController();
+
+            // Don't install PackageB initially so it will be installed when run from the package cache.
+            testBAController.SetPackageRequestedState("PackageB", RequestState.Absent);
+
+            packageA.VerifyInstalled(false);
+            packageB.VerifyInstalled(false);
+
+            // Manually copy bundle to separate directory with new name and install from there
+            // so that when run from the package cache, it has to get the attached container from the renamed bundle.
+            using (var dfs = new DisposableFileSystem())
+            {
+                var tempDirectory = dfs.GetFolder(true);
+
+                var bundleBFileInfo = new FileInfo(bundleB.Bundle);
+                var bundleBCopiedPath = Path.Combine(tempDirectory, "RenamedBundle.exe");
+                bundleBFileInfo.CopyTo(bundleBCopiedPath);
+
+                bundleB.Install(bundleBCopiedPath);
+
+                var bundlePackageCachePath = bundleB.VerifyRegisteredAndInPackageCache();
+
+                packageA.VerifyInstalled(true);
+                packageB.VerifyInstalled(false);
+
+                testBAController.SetPackageRequestedState("PackageB", RequestState.Present);
+
+                bundleB.Modify(bundlePackageCachePath);
+                bundleB.VerifyRegisteredAndInPackageCache();
+
+                packageA.VerifyInstalled(true);
+                packageB.VerifyInstalled(true);
+            }
+        }
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/DependencyTests.cs b/src/test/burn/WixToolsetTest.BurnE2E/DependencyTests.cs
new file mode 100644
index 00000000..d563bbe7
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/DependencyTests.cs
@@ -0,0 +1,611 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using System;
+    using WixTestTools;
+    using WixToolset.Mba.Core;
+    using Xunit;
+    using Xunit.Abstractions;
+
+    public class DependencyTests : BurnE2ETests
+    {
+        public DependencyTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
+
+        [Fact]
+        public void CanKeepSameExactPackageAfterUpgradingBundle()
+        {
+            var packageF = this.CreatePackageInstaller("PackageF");
+            var bundleKv1 = this.CreateBundleInstaller("BundleKv1");
+            var bundleKv2 = this.CreateBundleInstaller("BundleKv2");
+
+            packageF.VerifyInstalled(false);
+
+            bundleKv1.Install();
+            bundleKv1.VerifyRegisteredAndInPackageCache();
+
+            packageF.VerifyInstalled(true);
+
+            bundleKv2.Install();
+            bundleKv2.VerifyRegisteredAndInPackageCache();
+            bundleKv1.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageF.VerifyInstalled(true);
+
+            bundleKv2.VerifyPackageIsCached("PackageF");
+
+            bundleKv2.Uninstall();
+            bundleKv2.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageF.VerifyInstalled(false);
+        }
+
+        [Fact (Skip = "https://github.com/wixtoolset/issues/issues/6387")]
+        public void CanKeepSameExactPackageAfterUpgradingBundleWithSlipstreamedPatch()
+        {
+            var originalVersion = "1.0.0.0";
+            var patchedVersion = "1.0.1.0";
+            var testRegistryValue = "PackageA";
+            var testRegistryValueExe = "ExeA";
+
+            var packageA = this.CreatePackageInstaller("PackageAv1");
+            var bundleA = this.CreateBundleInstaller("BundleAv1");
+            var bundleC = this.CreateBundleInstaller("BundleC");
+
+            packageA.VerifyInstalled(false);
+
+            bundleA.Install();
+            bundleA.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageA.VerifyTestRegistryValue(testRegistryValue, originalVersion);
+            bundleA.VerifyExeTestRegistryValue(testRegistryValueExe, originalVersion);
+
+            // Verify https://github.com/wixtoolset/issues/issues/3294 - Uninstalling bundle registers a dependency on a package
+            bundleC.Install();
+            bundleC.VerifyRegisteredAndInPackageCache();
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageA.VerifyTestRegistryValue(testRegistryValue, patchedVersion);
+            bundleA.VerifyExeTestRegistryRootDeleted(testRegistryValueExe);
+
+            // Verify https://github.com/wixtoolset/issues/issues/2915 - Update bundle removes previously cached MSIs
+            bundleC.Repair();
+
+            bundleC.Uninstall();
+            bundleC.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(false);
+        }
+
+        [Fact(Skip = "https://github.com/wixtoolset/issues/issues/exea")]
+        public void CanKeepUpgradedPackageAfterUninstallUpgradedBundle()
+        {
+            var testRegistryValueExe = "ExeA";
+
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var packageAv101 = this.CreatePackageInstaller("PackageAv1_0_1");
+            var packageB = this.CreatePackageInstaller("PackageB");
+            var bundleAv1 = this.CreateBundleInstaller("BundleAv1");
+            var bundleAv101 = this.CreateBundleInstaller("BundleAv1_0_1");
+            var bundleB = this.CreateBundleInstaller("BundleB");
+
+            packageAv1.VerifyInstalledWithVersion(false);
+            packageAv101.VerifyInstalledWithVersion(false);
+            packageB.VerifyInstalled(false);
+
+            bundleAv1.Install();
+            bundleAv1.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalledWithVersion(true);
+            bundleAv1.VerifyExeTestRegistryValue(testRegistryValueExe, "1.0.0.0");
+
+            bundleB.Install();
+            bundleB.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalledWithVersion(true);
+            bundleAv1.VerifyExeTestRegistryValue(testRegistryValueExe, "1.0.0.0");
+            packageB.VerifyInstalled(true);
+
+            bundleAv101.Install();
+            bundleAv101.VerifyRegisteredAndInPackageCache();
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageAv1.VerifyInstalledWithVersion(false);
+            packageAv101.VerifyInstalledWithVersion(true);
+            bundleAv1.VerifyExeTestRegistryValue(testRegistryValueExe, "1.0.1.0");
+
+            bundleAv101.Uninstall();
+            bundleAv101.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageAv101.VerifyInstalledWithVersion(true);
+            bundleAv1.VerifyExeTestRegistryValue(testRegistryValueExe, "1.0.1.0");
+        }
+
+#if SUPPORT_ADDON_AND_PATCH_RELATED_BUNDLES
+        [Fact(Skip = "https://github.com/wixtoolset/issues/issues/6387")]
+#else
+        [Fact(Skip = "addon/patch related bundle")]
+#endif
+        public void CanMinorUpgradeDependencyPackageFromPatchBundle()
+        {
+            var originalVersion = "1.0.0.0";
+            var patchedVersion = "1.0.1.0";
+            var testRegistryValue = "PackageA";
+
+            var packageA = this.CreatePackageInstaller("PackageAv1");
+            var packageBv1 = this.CreatePackageInstaller("PackageBv1");
+            var packageBv101 = this.CreatePackageInstaller("PackageBv1_0_1");
+            var bundleJ = this.CreateBundleInstaller("BundleJ");
+            var bundleJ_Patch = this.CreateBundleInstaller("BundleJ_Patch");
+
+            packageA.VerifyInstalled(false);
+            packageBv1.VerifyInstalled(false);
+            packageBv101.VerifyInstalled(false);
+
+            bundleJ.Install();
+            bundleJ.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageA.VerifyTestRegistryValue(testRegistryValue, originalVersion);
+            packageBv1.VerifyInstalled(true);
+
+            bundleJ_Patch.Install();
+            bundleJ_Patch.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageA.VerifyTestRegistryValue(testRegistryValue, patchedVersion);
+            packageBv1.VerifyInstalled(false);
+            packageBv101.VerifyInstalled(true);
+
+            bundleJ.Uninstall();
+            bundleJ.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleJ_Patch.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(false);
+            packageBv1.VerifyInstalled(false);
+            packageBv101.VerifyInstalled(false);
+        }
+
+#if SUPPORT_ADDON_AND_PATCH_RELATED_BUNDLES
+        [Fact(Skip = "https://github.com/wixtoolset/issues/issues/6387")]
+#else
+        [Fact(Skip = "addon/patch related bundle")]
+#endif
+        public void CanMinorUpgradeDependencyPackageFromPatchBundleThenUninstallToRestoreBase()
+        {
+            var originalVersion = "1.0.0.0";
+            var patchedVersion = "1.0.1.0";
+            var testRegistryValue = "PackageA";
+
+            var packageA = this.CreatePackageInstaller("PackageAv1");
+            var packageBv1 = this.CreatePackageInstaller("PackageBv1");
+            var packageBv101 = this.CreatePackageInstaller("PackageBv1_0_1");
+            var bundleJ = this.CreateBundleInstaller("BundleJ");
+            var bundleJ_Patch = this.CreateBundleInstaller("BundleJ_Patch");
+
+            packageA.VerifyInstalled(false);
+            packageBv1.VerifyInstalled(false);
+            packageBv101.VerifyInstalled(false);
+
+            bundleJ.Install();
+            bundleJ.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageA.VerifyTestRegistryValue(testRegistryValue, originalVersion);
+            packageBv1.VerifyInstalled(true);
+
+            bundleJ_Patch.Install();
+            bundleJ_Patch.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageA.VerifyTestRegistryValue(testRegistryValue, patchedVersion);
+            packageBv1.VerifyInstalled(false);
+            packageBv101.VerifyInstalled(true);
+
+            bundleJ_Patch.Uninstall();
+            bundleJ_Patch.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageA.VerifyTestRegistryValue(testRegistryValue, originalVersion);
+            packageBv1.VerifyInstalled(true);
+            packageBv101.VerifyInstalled(false);
+
+            bundleJ.Uninstall();
+            bundleJ.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(false);
+            packageBv1.VerifyInstalled(false);
+            packageBv101.VerifyInstalled(false);
+        }
+
+#if SUPPORT_ADDON_AND_PATCH_RELATED_BUNDLES
+        [Fact]
+#else
+        [Fact(Skip = "addon/patch related bundle")]
+#endif
+        public void CanUninstallBaseWithAddOnsWhenAllSharePackages()
+        {
+            var testRegistryValueExe = "ExeA";
+
+            var packageA = this.CreatePackageInstaller("PackageAv1");
+            var packageB = this.CreatePackageInstaller("PackageB");
+            var bundleF = this.CreateBundleInstaller("BundleF");
+            var bundleF_AddOnA = this.CreateBundleInstaller("BundleF_AddOnA");
+            var bundleF_AddOnB = this.CreateBundleInstaller("BundleF_AddOnB");
+
+            packageA.VerifyInstalled(false);
+            packageB.VerifyInstalled(false);
+
+            bundleF.Install();
+            bundleF.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageB.VerifyInstalled(true);
+
+            bundleF_AddOnA.Install();
+            bundleF_AddOnA.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            bundleF.VerifyExeTestRegistryValue(testRegistryValueExe, "1.0.0.0");
+            packageB.VerifyInstalled(true);
+
+            bundleF_AddOnB.Install();
+            bundleF_AddOnB.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            bundleF.VerifyExeTestRegistryValue(testRegistryValueExe, "1.0.0.0");
+            packageB.VerifyInstalled(true);
+
+            bundleF.Uninstall();
+            bundleF.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleF_AddOnA.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleF_AddOnB.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(false);
+            bundleF.VerifyExeTestRegistryRootDeleted(testRegistryValueExe);
+            packageB.VerifyInstalled(false);
+        }
+
+        [Fact]
+        public void CanUninstallDependencyPackagesWithBundlesUninstalledInFifoOrder()
+        {
+            var testRegistryValueExe = "ExeA";
+
+            var packageA = this.CreatePackageInstaller("PackageAv1");
+            var packageB = this.CreatePackageInstaller("PackageB");
+            var bundleA = this.CreateBundleInstaller("BundleAv1");
+            var bundleB = this.CreateBundleInstaller("BundleB");
+
+            packageA.VerifyInstalled(false);
+            packageB.VerifyInstalled(false);
+
+            bundleA.Install();
+            bundleA.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            bundleA.VerifyExeTestRegistryValue(testRegistryValueExe, "1.0.0.0");
+
+            bundleB.Install();
+            bundleB.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            bundleA.VerifyExeTestRegistryValue(testRegistryValueExe, "1.0.0.0");
+            packageB.VerifyInstalled(true);
+
+            bundleA.Uninstall();
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(true);
+            bundleA.VerifyExeTestRegistryValue(testRegistryValueExe, "1.0.0.0");
+            packageB.VerifyInstalled(true);
+
+            bundleB.Uninstall();
+            bundleB.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(false);
+            bundleA.VerifyExeTestRegistryRootDeleted(testRegistryValueExe);
+            packageB.VerifyInstalled(false);
+        }
+
+        [Fact]
+        public void CanUninstallDependencyPackagesWithBundlesUninstalledInReverseOrder()
+        {
+            var packageA = this.CreatePackageInstaller("PackageAv1");
+            var packageB = this.CreatePackageInstaller("PackageB");
+            var bundleA = this.CreateBundleInstaller("BundleAv1");
+            var bundleB = this.CreateBundleInstaller("BundleB");
+
+            packageA.VerifyInstalled(false);
+            packageB.VerifyInstalled(false);
+
+            bundleA.Install();
+            bundleA.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+
+            bundleB.Install();
+            bundleB.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageB.VerifyInstalled(true);
+
+            bundleB.Uninstall();
+            bundleB.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(true);
+
+            bundleA.Uninstall();
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(false);
+            packageB.VerifyInstalled(false);
+        }
+
+#if SUPPORT_ADDON_AND_PATCH_RELATED_BUNDLES
+        [Fact(Skip = "https://github.com/wixtoolset/issues/issues/6387")]
+#else
+        [Fact(Skip = "addon/patch related bundle")]
+#endif
+        public void CanUpgradePatchBundleWithAdditionalPatch()
+        {
+            var originalVersion = "1.0.0.0";
+            var patchedVersion = "1.0.1.0";
+            var patchedVersion2 = "1.0.2.0";
+            var testRegistryValue = "PackageA";
+
+            var packageA = this.CreatePackageInstaller("PackageAv1");
+            var packageB = this.CreatePackageInstaller("PackageBv1");
+            var bundleF = this.CreateBundleInstaller("BundleJ");
+            var bundleF_PatchAv101 = this.CreateBundleInstaller("BundleF_PatchAv1_0_1");
+            var bundleF_PatchAv102 = this.CreateBundleInstaller("BundleF_PatchAv1_0_2");
+
+            packageA.VerifyInstalled(false);
+            packageB.VerifyInstalled(false);
+
+            bundleF.Install();
+            bundleF.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageA.VerifyTestRegistryValue(testRegistryValue, originalVersion);
+            packageB.VerifyInstalled(true);
+
+            bundleF_PatchAv101.Install();
+            bundleF_PatchAv101.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageA.VerifyTestRegistryValue(testRegistryValue, patchedVersion);
+            packageB.VerifyInstalled(false);
+
+            bundleF_PatchAv102.Install();
+            bundleF_PatchAv102.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageA.VerifyTestRegistryValue(testRegistryValue, patchedVersion2);
+            packageB.VerifyInstalled(false);
+
+            bundleF.Uninstall();
+            bundleF.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleF_PatchAv101.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleF_PatchAv102.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(false);
+            packageB.VerifyInstalled(false);
+        }
+
+        [Fact]
+        public void DoesntRegisterDependencyOnPackageNotSelectedForInstall()
+        {
+            var testRegistryValueExe = "ExeA";
+
+            var packageA = this.CreatePackageInstaller("PackageAv1");
+            var packageB = this.CreatePackageInstaller("PackageB");
+            var bundleA = this.CreateBundleInstaller("BundleAv1");
+            var bundleB = this.CreateBundleInstaller("BundleB");
+            var testBAController = this.CreateTestBAController();
+
+            packageA.VerifyInstalled(false);
+            packageB.VerifyInstalled(false);
+
+            bundleA.Install();
+            bundleA.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            bundleA.VerifyExeTestRegistryValue(testRegistryValueExe, "1.0.0.0");
+
+            // Verify https://github.com/wixtoolset/issues/issues/3456 - Dependency registered on package though unselected to instal
+            testBAController.SetPackageRequestedState("PackageA", RequestState.None);
+            testBAController.SetPackageRequestedState("PackageB", RequestState.None);
+
+            bundleB.Install();
+            bundleB.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            bundleA.VerifyExeTestRegistryValue(testRegistryValueExe, "1.0.0.0");
+            packageB.VerifyInstalled(false);
+
+            testBAController.ResetPackageStates("PackageA");
+            testBAController.ResetPackageStates("PackageB");
+
+            bundleA.Uninstall();
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(false);
+            bundleA.VerifyExeTestRegistryValue(testRegistryValueExe, "1.0.0.0");
+            packageB.VerifyInstalled(false);
+
+            bundleB.Uninstall();
+            bundleB.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(false);
+            bundleA.VerifyExeTestRegistryRootDeleted(testRegistryValueExe);
+            packageB.VerifyInstalled(false);
+        }
+
+        [Fact(Skip = "https://github.com/wixtoolset/issues/issues/3516")]
+        public void DoesntRollbackPackageInstallIfPreexistingDependents()
+        {
+            var packageA = this.CreatePackageInstaller("PackageAv1");
+            var packageC = this.CreatePackageInstaller("PackageC");
+            var bundleE = this.CreateBundleInstaller("BundleE");
+            var bundleL = this.CreateBundleInstaller("BundleL");
+            var testBAController = this.CreateTestBAController();
+
+            packageA.VerifyInstalled(false);
+            packageC.VerifyInstalled(false);
+
+            // Make PackageC fail.
+            testBAController.SetPackageCancelExecuteAtProgress("PackageC", 10);
+
+            bundleE.Install();
+            bundleE.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageC.VerifyInstalled(false);
+
+            // Make PackageC install then rollback.
+            testBAController.SetPackageCancelExecuteAtProgress("PackageC", null);
+            testBAController.SetPackageCancelOnProgressAtProgress("PackageC", 10);
+
+            bundleL.Install((int)MSIExec.MSIExecReturnCode.ERROR_INSTALL_USEREXIT);
+            bundleL.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageC.VerifyInstalled(true);
+
+            testBAController.SetPackageCancelOnProgressAtProgress("PackageC", null);
+
+            bundleE.Uninstall();
+            bundleE.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(false);
+            packageC.VerifyInstalled(false);
+        }
+
+        [Fact]
+        public void RegistersDependencyOnFailedNonVitalPackages()
+        {
+            var packageA = this.CreatePackageInstaller("PackageAv1");
+            var packageC = this.CreatePackageInstaller("PackageC");
+            var bundleE = this.CreateBundleInstaller("BundleE");
+            var bundleL = this.CreateBundleInstaller("BundleL");
+            var testBAController = this.CreateTestBAController();
+
+            packageA.VerifyInstalled(false);
+            packageC.VerifyInstalled(false);
+
+            // Make PackageC fail.
+            testBAController.SetPackageCancelExecuteAtProgress("PackageC", 10);
+
+            // Verify https://github.com/wixtoolset/issues/issues/3406 - Non-vital failure result in bundle failure (install)
+            bundleE.Install();
+            bundleE.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageC.VerifyInstalled(false);
+
+            // Verify https://github.com/wixtoolset/issues/issues/3406 - Non-vital failure result in bundle failure (repair)
+            bundleE.Repair();
+            bundleE.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageC.VerifyInstalled(false);
+
+            testBAController.SetPackageCancelExecuteAtProgress("PackageC", null);
+
+            bundleL.Install();
+            bundleL.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageC.VerifyInstalled(true);
+
+            // Verify https://github.com/wixtoolset/issues/issues/3516 - Burn registers dependency on failed packages
+            bundleL.Uninstall();
+            bundleL.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageC.VerifyInstalled(true);
+
+            bundleE.Uninstall();
+            bundleE.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(false);
+            packageC.VerifyInstalled(false);
+        }
+
+        [Fact]
+        public void RemovesDependencyDuringUpgradeRollback()
+        {
+            var testRegistryValueExe = "ExeA";
+
+            var packageA = this.CreatePackageInstaller("PackageAv1");
+            var bundleA = this.CreateBundleInstaller("BundleAv1");
+            var bundleD = this.CreateBundleInstaller("BundleD");
+
+            packageA.VerifyInstalled(false);
+            bundleA.VerifyExeTestRegistryRootDeleted(testRegistryValueExe);
+
+            bundleA.Install();
+            bundleA.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            bundleA.VerifyExeTestRegistryValue(testRegistryValueExe, "1.0.0.0");
+
+            // Verify https://github.com/wixtoolset/issues/issues/3341 - pkg dependecy not removed in rollback if pkg already present
+            bundleD.Install((int)MSIExec.MSIExecReturnCode.ERROR_INSTALL_FAILURE);
+            bundleD.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(true);
+            bundleA.VerifyExeTestRegistryValue(testRegistryValueExe, "1.0.0.0");
+
+            bundleA.Uninstall();
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(false);
+            bundleA.VerifyExeTestRegistryRootDeleted(testRegistryValueExe);
+        }
+
+        [Fact]
+        public void SkipsCrossScopeDependencyRegistration()
+        {
+            var packageA = this.CreatePackageInstaller("PackageAv1");
+            var packageDv1 = this.CreatePackageInstaller("PackageDv1");
+            var packageDv2 = this.CreatePackageInstaller("PackageDv2");
+            var bundleHv1 = this.CreateBundleInstaller("BundleHv1");
+            var bundleHv2 = this.CreateBundleInstaller("BundleHv2");
+
+            packageA.VerifyInstalled(false);
+            packageDv1.VerifyInstalled(false);
+            packageDv2.VerifyInstalled(false);
+
+            var bundleHv1InstallLogFilePath = bundleHv1.Install();
+            bundleHv1.VerifyRegisteredAndInPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageDv1.VerifyInstalled(true);
+
+            Assert.True(LogVerifier.MessageInLogFileRegex(bundleHv1InstallLogFilePath, @"Skipping cross-scope dependency registration on package: PackageA, bundle scope: PerUser, package scope: PerMachine"));
+
+            var bundleHv2InstallLogFilePath = bundleHv2.Install();
+            bundleHv2.VerifyRegisteredAndInPackageCache();
+            bundleHv1.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(true);
+            packageDv1.VerifyInstalled(false);
+            packageDv2.VerifyInstalled(true);
+
+            Assert.True(LogVerifier.MessageInLogFileRegex(bundleHv2InstallLogFilePath, @"Skipping cross-scope dependency registration on package: PackageA, bundle scope: PerUser, package scope: PerMachine"));
+            Assert.True(LogVerifier.MessageInLogFileRegex(bundleHv2InstallLogFilePath, @"Detected related bundle: \{[0-9A-Za-z\-]{36}\}, type: Upgrade, scope: PerUser, version: 1\.0\.0\.0, operation: MajorUpgrade, cached: Yes"));
+
+            bundleHv2.Uninstall();
+            bundleHv2.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            // Verify that permanent packageA is still installed and then remove.
+            packageA.VerifyInstalled(true);
+            packageDv2.VerifyInstalled(false);
+            packageA.UninstallProduct();
+            packageA.VerifyInstalled(false);
+        }
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/ElevationTests.cs b/src/test/burn/WixToolsetTest.BurnE2E/ElevationTests.cs
new file mode 100644
index 00000000..54a89469
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/ElevationTests.cs
@@ -0,0 +1,30 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using Xunit;
+    using Xunit.Abstractions;
+
+    public class ElevationTests : BurnE2ETests
+    {
+        public ElevationTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
+
+        /// <summary>
+        /// This test calls Elevate after Detect, and then calls Plan in OnElevateBegin.
+        /// After calling Plan, it pumps some messages to simulate UI like the UAC callback.
+        /// </summary>
+        [Fact(Skip = "https://github.com/wixtoolset/issues/issues/6349")] // CAUTION: this test currently hangs because the Plan request gets dropped.
+        public void CanExplicitlyElevateAndPlanFromOnElevateBegin()
+        {
+            var packageA = this.CreatePackageInstaller("PackageA");
+            var bundleA = this.CreateBundleInstaller("BundleA");
+            var testBAController = this.CreateTestBAController();
+
+            testBAController.SetExplicitlyElevateAndPlanFromOnElevateBegin();
+
+            bundleA.Install();
+            bundleA.VerifyRegisteredAndInPackageCache();
+            packageA.VerifyInstalled(true);
+        }
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/FailureTests.cs b/src/test/burn/WixToolsetTest.BurnE2E/FailureTests.cs
new file mode 100644
index 00000000..a11a5eb6
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/FailureTests.cs
@@ -0,0 +1,112 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using WixTestTools;
+    using Xunit;
+    using Xunit.Abstractions;
+
+    public class FailureTests : BurnE2ETests
+    {
+        public FailureTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
+
+        [Fact]
+        public void CanCancelMsiPackageVeryEarly()
+        {
+            var packageA = this.CreatePackageInstaller("PackageA");
+            var packageB = this.CreatePackageInstaller("PackageB");
+            var bundleA = this.CreateBundleInstaller("BundleA");
+            var testBAController = this.CreateTestBAController();
+
+            // Cancel package B right away.
+            testBAController.SetPackageCancelExecuteAtProgress("PackageB", 1);
+
+            bundleA.Install((int)MSIExec.MSIExecReturnCode.ERROR_INSTALL_USEREXIT);
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(false);
+            packageB.VerifyInstalled(false);
+        }
+
+        [Fact]
+        public void CanCancelMsiPackageVeryLate()
+        {
+            var packageA = this.CreatePackageInstaller("PackageA");
+            var packageB = this.CreatePackageInstaller("PackageB");
+            var bundleA = this.CreateBundleInstaller("BundleA");
+            var testBAController = this.CreateTestBAController();
+
+            // Cancel package B at the last moment possible.
+            testBAController.SetPackageCancelExecuteAtProgress("PackageB", 100);
+
+            bundleA.Install((int)MSIExec.MSIExecReturnCode.ERROR_INSTALL_USEREXIT);
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(false);
+            packageB.VerifyInstalled(false);
+        }
+
+        [Fact]
+        public void CanCancelMsiPackageInOnProgress()
+        {
+            var packageA = this.CreatePackageInstaller("PackageA");
+            var packageB = this.CreatePackageInstaller("PackageB");
+            var bundleA = this.CreateBundleInstaller("BundleA");
+            var testBAController = this.CreateTestBAController();
+
+            // Cancel package B during its OnProgress message.
+            testBAController.SetPackageCancelOnProgressAtProgress("PackageB", 100);
+
+            bundleA.Install((int)MSIExec.MSIExecReturnCode.ERROR_INSTALL_USEREXIT);
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(false);
+            packageB.VerifyInstalled(false);
+        }
+
+        [Fact(Skip = "https://github.com/wixtoolset/issues/issues/5750")]
+        public void CanCancelExecuteWhileCaching()
+        {
+            var packageA = this.CreatePackageInstaller("PackageA");
+            var packageB = this.CreatePackageInstaller("PackageB");
+            var bundleB = this.CreateBundleInstaller("BundleB");
+            var testBAController = this.CreateTestBAController();
+
+            // Slow the caching of package B to ensure that package A starts installing and cancels.
+            testBAController.SetPackageCancelExecuteAtProgress("PackageA", 50);
+            testBAController.SetPackageSlowCache("PackageB", 2000);
+
+            bundleB.Install((int)MSIExec.MSIExecReturnCode.ERROR_INSTALL_USEREXIT);
+            bundleB.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(false);
+            packageB.VerifyInstalled(false);
+        }
+
+        /// <summary>
+        /// BundleC has non-vital PackageA and vital PackageB.
+        /// PackageA is not compressed in the bundle and has a Name different from the source file. The Name points to a file that does not exist.
+        /// BundleC should be able to install successfully by ignoring the missing PackageA and installing PackageB.
+        /// </summary>
+        [Fact]
+        public void CanInstallWhenMissingNonVitalPackage()
+        {
+            var packageA = this.CreatePackageInstaller("PackageA");
+            var packageB = this.CreatePackageInstaller("PackageB");
+            var bundleC = this.CreateBundleInstaller("BundleC");
+
+            var bundleCInstallLogFilePath = bundleC.Install();
+            bundleC.VerifyRegisteredAndInPackageCache();
+            Assert.True(LogVerifier.MessageInLogFileRegex(bundleCInstallLogFilePath, "Skipping apply of package: PackageA due to cache error: 0x80070002. Continuing..."));
+
+            packageA.VerifyInstalled(false);
+            packageB.VerifyInstalled(true);
+
+            bundleC.Uninstall();
+            bundleC.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageA.VerifyInstalled(false);
+            packageB.VerifyInstalled(false);
+        }
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/ForwardCompatibleBundleTests.cs b/src/test/burn/WixToolsetTest.BurnE2E/ForwardCompatibleBundleTests.cs
new file mode 100644
index 00000000..eb649c86
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/ForwardCompatibleBundleTests.cs
@@ -0,0 +1,469 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using System;
+    using System.IO;
+    using WixTestTools;
+    using Xunit;
+    using Xunit.Abstractions;
+
+    public class ForwardCompatibleBundleTests : BurnE2ETests
+    {
+        public ForwardCompatibleBundleTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
+
+        private const string BundleAProviderId = "~" + nameof(ForwardCompatibleBundleTests) + "_BundleA";
+        private const string BundleCProviderId = "~" + nameof(ForwardCompatibleBundleTests) + "_BundleC";
+        private const string V100 = "1.0.0.0";
+        private const string V200 = "2.0.0.0";
+
+        [Fact]
+        public void CanTrack1ForwardCompatibleDependentThroughMajorUpgrade()
+        {
+            string providerId = BundleAProviderId;
+            string parent = "~BundleAv1";
+            string parentSwitch = String.Concat("-parent ", parent);
+
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var packageAv2 = this.CreatePackageInstaller("PackageAv2");
+            var bundleAv1 = this.CreateBundleInstaller("BundleAv1");
+            var bundleAv2 = this.CreateBundleInstaller("BundleAv2");
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(false);
+
+            // Install the v1 bundle with a parent.
+            bundleAv1.Install(arguments: parentSwitch);
+            bundleAv1.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(true);
+            packageAv2.VerifyInstalled(false);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out var actualProviderVersion));
+            Assert.Equal(V100, actualProviderVersion);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent));
+
+            // Upgrade with the v2 bundle.
+            bundleAv2.Install();
+            bundleAv2.VerifyRegisteredAndInPackageCache();
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(true);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+            Assert.Equal(V200, actualProviderVersion);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent));
+
+            // Uninstall the v2 bundle and nothing should happen because there is still a parent.
+            bundleAv2.Uninstall();
+            bundleAv2.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(true);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+            Assert.Equal(V200, actualProviderVersion);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent));
+
+            // Uninstall the v1 bundle with passthrough and all should be removed.
+            bundleAv1.Uninstall(arguments: parentSwitch);
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleAv2.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(false);
+            Assert.False(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+        }
+
+        [Fact]
+        public void CanTrack1ForwardCompatibleDependentThroughMajorUpgradeWithParentNone()
+        {
+            string providerId = BundleAProviderId;
+            string parent = "~BundleAv1";
+            string parentSwitch = String.Concat("-parent ", parent);
+
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var packageAv2 = this.CreatePackageInstaller("PackageAv2");
+            var bundleAv1 = this.CreateBundleInstaller("BundleAv1");
+            var bundleAv2 = this.CreateBundleInstaller("BundleAv2");
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(false);
+
+            // Install the v1 bundle with a parent.
+            bundleAv1.Install(arguments: parentSwitch);
+            bundleAv1.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(true);
+            packageAv2.VerifyInstalled(false);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out var actualProviderVersion));
+            Assert.Equal(V100, actualProviderVersion);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent));
+
+            // Upgrade with the v2 bundle but prevent self parent being registered.
+            bundleAv2.Install(arguments: "-parent:none");
+            bundleAv2.VerifyRegisteredAndInPackageCache();
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(true);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+            Assert.Equal(V200, actualProviderVersion);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent));
+
+            // Uninstall the v1 bundle with passthrough and all should be removed.
+            bundleAv1.Uninstall(arguments: parentSwitch);
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleAv2.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(false);
+            Assert.False(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+        }
+
+        [Fact]
+        public void CanTrack2ForwardCompatibleDependentsThroughMajorUpgrade()
+        {
+            string providerId = BundleAProviderId;
+            string parent = "~BundleAv1";
+            string parent2 = "~BundleAv1_Parent2";
+            string parentSwitch = String.Concat("-parent ", parent);
+            string parent2Switch = String.Concat("-parent ", parent2);
+
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var packageAv2 = this.CreatePackageInstaller("PackageAv2");
+            var bundleAv1 = this.CreateBundleInstaller("BundleAv1");
+            var bundleAv2 = this.CreateBundleInstaller("BundleAv2");
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(false);
+
+            // Install the v1 bundle with a parent.
+            bundleAv1.Install(arguments: parentSwitch);
+            bundleAv1.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(true);
+            packageAv2.VerifyInstalled(false);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out var actualProviderVersion));
+            Assert.Equal(V100, actualProviderVersion);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent));
+
+            // Install the v1 bundle with a second parent.
+            bundleAv1.Install(arguments: parent2Switch);
+            bundleAv1.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(true);
+            packageAv2.VerifyInstalled(false);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+            Assert.Equal(V100, actualProviderVersion);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent2));
+
+            // Upgrade with the v2 bundle.
+            bundleAv2.Install();
+            bundleAv2.VerifyRegisteredAndInPackageCache();
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(true);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+            Assert.Equal(V200, actualProviderVersion);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent));
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent2));
+
+            // Uninstall the v2 bundle and nothing should happen because there is still a parent.
+            bundleAv2.Uninstall();
+            bundleAv2.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(true);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+            Assert.Equal(V200, actualProviderVersion);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent));
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent2));
+
+            // Uninstall one parent of the v1 bundle and nothing should happen because there is still a parent.
+            bundleAv1.Uninstall(arguments: parentSwitch);
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleAv2.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(true);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+            Assert.Equal(V200, actualProviderVersion);
+            Assert.False(BundleRegistration.DependencyDependentExists(providerId, parent));
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent2));
+
+            // Uninstall the v1 bundle with passthrough with second parent and all should be removed.
+            bundleAv1.Uninstall(arguments: parent2Switch);
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleAv2.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(false);
+            Assert.False(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+        }
+
+        [Fact]
+        public void CanTrack2ForwardCompatibleDependentsThroughMajorUpgradePerUser()
+        {
+            string providerId = BundleCProviderId;
+            string parent = "~BundleCv1";
+            string parent2 = "~BundleCv1_Parent2";
+            string parentSwitch = String.Concat("-parent ", parent);
+            string parent2Switch = String.Concat("-parent ", parent2);
+
+            var packageCv1 = this.CreatePackageInstaller("PackageCv1");
+            var packageCv2 = this.CreatePackageInstaller("PackageCv2");
+            var bundleCv1 = this.CreateBundleInstaller("BundleCv1");
+            var bundleCv2 = this.CreateBundleInstaller("BundleCv2");
+
+            packageCv1.VerifyInstalled(false);
+            packageCv2.VerifyInstalled(false);
+
+            // Install the v1 bundle with a parent.
+            bundleCv1.Install(arguments: parentSwitch);
+            bundleCv1.VerifyRegisteredAndInPackageCache();
+
+            packageCv1.VerifyInstalled(true);
+            packageCv2.VerifyInstalled(false);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out var actualProviderVersion));
+            Assert.Equal(V100, actualProviderVersion);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent));
+
+            // Install the v1 bundle with a second parent.
+            bundleCv1.Install(arguments: parent2Switch);
+            bundleCv1.VerifyRegisteredAndInPackageCache();
+
+            packageCv1.VerifyInstalled(true);
+            packageCv2.VerifyInstalled(false);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+            Assert.Equal(V100, actualProviderVersion);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent2));
+
+            // Upgrade with the v2 bundle.
+            bundleCv2.Install();
+            bundleCv2.VerifyRegisteredAndInPackageCache();
+            bundleCv1.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageCv1.VerifyInstalled(false);
+            packageCv2.VerifyInstalled(true);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+            Assert.Equal(V200, actualProviderVersion);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent));
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent2));
+
+            // Uninstall the v2 bundle and nothing should happen because there is still a parent.
+            bundleCv2.Uninstall();
+            bundleCv2.VerifyRegisteredAndInPackageCache();
+
+            packageCv1.VerifyInstalled(false);
+            packageCv2.VerifyInstalled(true);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+            Assert.Equal(V200, actualProviderVersion);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent));
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent2));
+
+            // Uninstall one parent of the v1 bundle and nothing should happen because there is still a parent.
+            bundleCv1.Uninstall(arguments: parentSwitch);
+            bundleCv1.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleCv2.VerifyRegisteredAndInPackageCache();
+
+            packageCv1.VerifyInstalled(false);
+            packageCv2.VerifyInstalled(true);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+            Assert.Equal(V200, actualProviderVersion);
+            Assert.False(BundleRegistration.DependencyDependentExists(providerId, parent));
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent2));
+
+            // Uninstall the v1 bundle with passthrough with second parent and all should be removed.
+            bundleCv1.Uninstall(arguments: parent2Switch);
+            bundleCv1.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleCv2.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageCv1.VerifyInstalled(false);
+            packageCv2.VerifyInstalled(false);
+            Assert.False(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+        }
+
+        [Fact]
+        public void CanTrack2ForwardCompatibleDependentsThroughMajorUpgradeWithParent()
+        {
+            string providerId = BundleAProviderId;
+            string parent = "~BundleAv1";
+            string parent2 = "~BundleAv1_Parent2";
+            string parent3 = "~BundleAv1_Parent3";
+            string parentSwitch = String.Concat("-parent ", parent);
+            string parent2Switch = String.Concat("-parent ", parent2);
+            string parent3Switch = String.Concat("-parent ", parent3);
+
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var packageAv2 = this.CreatePackageInstaller("PackageAv2");
+            var bundleAv1 = this.CreateBundleInstaller("BundleAv1");
+            var bundleAv2 = this.CreateBundleInstaller("BundleAv2");
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(false);
+
+            // Install the v1 bundle with a parent.
+            bundleAv1.Install(arguments: parentSwitch);
+            bundleAv1.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(true);
+            packageAv2.VerifyInstalled(false);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out var actualProviderVersion));
+            Assert.Equal(V100, actualProviderVersion);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent));
+
+            // Install the v1 bundle with a second parent.
+            bundleAv1.Install(arguments: parent2Switch);
+            bundleAv1.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(true);
+            packageAv2.VerifyInstalled(false);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+            Assert.Equal(V100, actualProviderVersion);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent2));
+
+            // Upgrade with the v2 bundle.
+            bundleAv2.Install(arguments: parent3Switch);
+            bundleAv2.VerifyRegisteredAndInPackageCache();
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(true);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+            Assert.Equal(V200, actualProviderVersion);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent));
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent2));
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent3));
+
+            // Uninstall the v2 bundle and nothing should happen because there is still a parent.
+            bundleAv2.Uninstall(arguments: parent3Switch);
+            bundleAv2.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(true);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+            Assert.Equal(V200, actualProviderVersion);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent));
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent2));
+            Assert.False(BundleRegistration.DependencyDependentExists(providerId, parent3));
+
+            // Uninstall one parent of the v1 bundle and nothing should happen because there is still a parent.
+            bundleAv1.Uninstall(arguments: parentSwitch);
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleAv2.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(true);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+            Assert.Equal(V200, actualProviderVersion);
+            Assert.False(BundleRegistration.DependencyDependentExists(providerId, parent));
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent2));
+
+            // Uninstall the v1 bundle with passthrough with second parent and all should be removed.
+            bundleAv1.Uninstall(arguments: parent2Switch);
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleAv2.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(false);
+            Assert.False(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+        }
+
+        [Fact]
+        public void CanUninstallForwardCompatibleWithBundlesUninstalledInFifoOrder()
+        {
+            string providerId = BundleAProviderId;
+            string parent = "~BundleAv1";
+            string parentSwitch = String.Concat("-parent ", parent);
+
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var packageAv2 = this.CreatePackageInstaller("PackageAv2");
+            var bundleAv1 = this.CreateBundleInstaller("BundleAv1");
+            var bundleAv2 = this.CreateBundleInstaller("BundleAv2");
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(false);
+
+            bundleAv2.Install();
+            bundleAv2.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(true);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out var actualProviderVersion));
+            Assert.Equal(V200, actualProviderVersion);
+
+            // Install the v1 bundle with a parent which should passthrough to v2.
+            bundleAv1.Install(arguments: parentSwitch);
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(true);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent));
+
+            bundleAv2.Uninstall();
+            bundleAv2.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(true);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent));
+
+            // Uninstall the v1 bundle with passthrough and all should be removed.
+            bundleAv1.Uninstall(arguments: parentSwitch);
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleAv2.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(false);
+            Assert.False(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+        }
+
+        [Fact]
+        public void CanUninstallForwardCompatibleWithBundlesUninstalledInReverseOrder()
+        {
+            string providerId = BundleAProviderId;
+            string parent = "~BundleAv1";
+            string parentSwitch = String.Concat("-parent ", parent);
+
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var packageAv2 = this.CreatePackageInstaller("PackageAv2");
+            var bundleAv1 = this.CreateBundleInstaller("BundleAv1");
+            var bundleAv2 = this.CreateBundleInstaller("BundleAv2");
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(false);
+
+            bundleAv2.Install();
+            bundleAv2.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(true);
+            Assert.True(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out var actualProviderVersion));
+            Assert.Equal(V200, actualProviderVersion);
+
+            // Install the v1 bundle with a parent which should passthrough to v2.
+            bundleAv1.Install(arguments: parentSwitch);
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(true);
+            Assert.True(BundleRegistration.DependencyDependentExists(providerId, parent));
+
+            // Uninstall the v1 bundle with the same parent which should passthrough to v2 and remove parent.
+            bundleAv1.Uninstall(arguments: parentSwitch);
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleAv2.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(true);
+            Assert.False(BundleRegistration.DependencyDependentExists(providerId, parent));
+
+            // Uninstall the v2 bundle and all should be removed.
+            bundleAv2.Uninstall();
+            bundleAv2.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(false);
+            Assert.False(BundleRegistration.TryGetDependencyProviderValue(providerId, "Version", out actualProviderVersion));
+        }
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/IWebServer.cs b/src/test/burn/WixToolsetTest.BurnE2E/IWebServer.cs
new file mode 100644
index 00000000..3bb8a23e
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/IWebServer.cs
@@ -0,0 +1,20 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using System;
+    using System.Collections.Generic;
+
+    public interface IWebServer : IDisposable
+    {
+        /// <summary>
+        /// Registers a collection of relative URLs (the key) with its absolute path to the file (the value).
+        /// </summary>
+        void AddFiles(Dictionary<string, string> physicalPathsByRelativeUrl);
+
+        /// <summary>
+        /// Starts the web server on a new thread.
+        /// </summary>
+        void Start();
+    }
+}
\ No newline at end of file
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/LayoutTests.cs b/src/test/burn/WixToolsetTest.BurnE2E/LayoutTests.cs
new file mode 100644
index 00000000..1e36e2a5
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/LayoutTests.cs
@@ -0,0 +1,68 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using System.Collections.Generic;
+    using System.IO;
+    using WixBuildTools.TestSupport;
+    using Xunit;
+    using Xunit.Abstractions;
+
+    public class LayoutTests : BurnE2ETests
+    {
+        public LayoutTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
+
+        [Fact]
+        public void CanLayoutBundleInPlaceWithMissingPayloads()
+        {
+            var bundleA = this.CreateBundleInstaller("BundleA");
+            var webServer = this.CreateWebServer();
+
+            webServer.AddFiles(new Dictionary<string, string>
+            {
+                { "/BundleA/LayoutOnlyPayload", Path.Combine(this.TestContext.TestDataFolder, "BundleA.wxs") },
+                { "/BundleA/packages.cab", Path.Combine(this.TestContext.TestDataFolder, "packages.cab") },
+            });
+            webServer.Start();
+
+            using var dfs = new DisposableFileSystem();
+            var layoutDirectory = dfs.GetFolder(true);
+
+            // Manually copy bundle to layout directory and then run from there so the non-compressed payloads have to be resolved.
+            var bundleAFileInfo = new FileInfo(bundleA.Bundle);
+            var bundleACopiedPath = Path.Combine(layoutDirectory, bundleAFileInfo.Name);
+            bundleAFileInfo.CopyTo(bundleACopiedPath);
+
+            bundleA.Layout(bundleACopiedPath, layoutDirectory);
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            Assert.True(File.Exists(bundleACopiedPath));
+            Assert.True(File.Exists(Path.Combine(layoutDirectory, "packages.cab")));
+            Assert.True(File.Exists(Path.Combine(layoutDirectory, "BundleA.wxs")));
+        }
+
+        [Fact]
+        public void CanLayoutBundleToNewDirectory()
+        {
+            var bundleA = this.CreateBundleInstaller("BundleA");
+            var webServer = this.CreateWebServer();
+
+            webServer.AddFiles(new Dictionary<string, string>
+            {
+                { "/BundleA/LayoutOnlyPayload", Path.Combine(this.TestContext.TestDataFolder, "BundleA.wxs") },
+                { "/BundleA/packages.cab", Path.Combine(this.TestContext.TestDataFolder, "packages.cab") },
+            });
+            webServer.Start();
+
+            using var dfs = new DisposableFileSystem();
+            var layoutDirectory = dfs.GetFolder();
+
+            bundleA.Layout(layoutDirectory);
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            Assert.True(File.Exists(Path.Combine(layoutDirectory, "BundleA.exe")));
+            Assert.True(File.Exists(Path.Combine(layoutDirectory, "packages.cab")));
+            Assert.True(File.Exists(Path.Combine(layoutDirectory, "BundleA.wxs")));
+        }
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/MsiTransactionTests.cs b/src/test/burn/WixToolsetTest.BurnE2E/MsiTransactionTests.cs
new file mode 100644
index 00000000..3d9748bb
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/MsiTransactionTests.cs
@@ -0,0 +1,128 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using System;
+    using System.IO;
+    using WixTestTools;
+    using Xunit;
+    using Xunit.Abstractions;
+
+    public class MsiTransactionTests : BurnE2ETests
+    {
+        public MsiTransactionTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
+
+        [Fact]
+        public void CanUpgradeBundleWithMsiTransaction()
+        {
+            var packageA = this.CreatePackageInstaller("PackageA");
+            var packageBv1 = this.CreatePackageInstaller("PackageBv1");
+            var packageBv2 = this.CreatePackageInstaller("PackageBv2");
+            var packageCv1 = this.CreatePackageInstaller("PackageCv1");
+            var packageCv2 = this.CreatePackageInstaller("PackageCv2");
+            var packageD = this.CreatePackageInstaller("PackageD");
+
+            var bundleAv1 = this.CreateBundleInstaller("BundleAv1");
+            var bundleAv2 = this.CreateBundleInstaller("BundleAv2");
+
+            var packageASourceCodeInstalled = packageA.GetInstalledFilePath("Package.wxs");
+            var packageBv1SourceCodeInstalled = packageBv1.GetInstalledFilePath("Package.wxs");
+            var packageBv2SourceCodeInstalled = packageBv2.GetInstalledFilePath("Package.wxs");
+            var packageCv1SourceCodeInstalled = packageCv1.GetInstalledFilePath("Package.wxs");
+            var packageCv2SourceCodeInstalled = packageCv2.GetInstalledFilePath("Package.wxs");
+            var packageDSourceCodeInstalled = packageD.GetInstalledFilePath("Package.wxs");
+
+            // Source file should *not* be installed
+            Assert.False(File.Exists(packageASourceCodeInstalled), $"Package A payload should not be there on test start: {packageASourceCodeInstalled}");
+            Assert.False(File.Exists(packageBv1SourceCodeInstalled), $"Package Bv1 payload should not be there on test start: {packageBv1SourceCodeInstalled}");
+            Assert.False(File.Exists(packageBv2SourceCodeInstalled), $"Package Bv2 payload should not be there on test start: {packageBv2SourceCodeInstalled}");
+            Assert.False(File.Exists(packageCv1SourceCodeInstalled), $"Package Cv1 payload should not be there on test start: {packageCv1SourceCodeInstalled}");
+            Assert.False(File.Exists(packageCv2SourceCodeInstalled), $"Package Cv2 payload should not be there on test start: {packageCv2SourceCodeInstalled}");
+            Assert.False(File.Exists(packageDSourceCodeInstalled), $"Package D payload should not be there on test start: {packageDSourceCodeInstalled}");
+
+            bundleAv1.Install();
+
+            var bundleAv1CachedPath = bundleAv1.VerifyRegisteredAndInPackageCache();
+
+            // Source file should be installed
+            Assert.True(File.Exists(packageASourceCodeInstalled), String.Concat("Should have found Package A payload installed at: ", packageASourceCodeInstalled));
+            Assert.True(File.Exists(packageBv1SourceCodeInstalled), String.Concat("Should have found Package Bv1 payload installed at: ", packageBv1SourceCodeInstalled));
+            Assert.True(File.Exists(packageCv1SourceCodeInstalled), String.Concat("Should have found Package Cv1 payload installed at: ", packageCv1SourceCodeInstalled));
+
+            bundleAv2.Install();
+
+            var bundleAv2CachedPath = bundleAv2.VerifyRegisteredAndInPackageCache();
+
+            // Source file should be upgraded
+            Assert.True(File.Exists(packageDSourceCodeInstalled), String.Concat("Should have found Package D payload installed at: ", packageDSourceCodeInstalled));
+            Assert.True(File.Exists(packageBv2SourceCodeInstalled), String.Concat("Should have found Package Bv2 payload installed at: ", packageBv2SourceCodeInstalled));
+            Assert.True(File.Exists(packageCv2SourceCodeInstalled), String.Concat("Should have found Package Cv2 payload installed at: ", packageCv2SourceCodeInstalled));
+            Assert.False(File.Exists(packageCv1SourceCodeInstalled), String.Concat("Package Cv1 payload should have been removed by upgrade uninstall from: ", packageCv1SourceCodeInstalled));
+            Assert.False(File.Exists(packageBv1SourceCodeInstalled), String.Concat("Package Bv1 payload should have been removed by upgrade uninstall from: ", packageBv1SourceCodeInstalled));
+            Assert.False(File.Exists(packageASourceCodeInstalled), String.Concat("Package A payload should have been removed by upgrade uninstall from: ", packageASourceCodeInstalled));
+
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache(bundleAv1CachedPath);
+
+            // Uninstall everything.
+            bundleAv2.Uninstall();
+
+            // Source file should *not* be installed
+            Assert.False(File.Exists(packageDSourceCodeInstalled), String.Concat("Package D payload should have been removed by uninstall from: ", packageDSourceCodeInstalled));
+            Assert.False(File.Exists(packageBv2SourceCodeInstalled), String.Concat("Package Bv2 payload should have been removed by uninstall from: ", packageBv2SourceCodeInstalled));
+            Assert.False(File.Exists(packageCv2SourceCodeInstalled), String.Concat("Package Cv2 payload should have been removed by uninstall from: ", packageCv2SourceCodeInstalled));
+
+            bundleAv2.VerifyUnregisteredAndRemovedFromPackageCache(bundleAv2CachedPath);
+        }
+
+        /// <summary>
+        /// Installs 2 bundles:
+        ///   BundleBv1- installs package Bv1
+        ///   BundleBv2- installs packages A, Bv2, F
+        ///     package Bv2 performs a major upgrade of package Bv1
+        ///     package F fails
+        ///     Thus, rolling back the transaction should reinstall package Bv1
+        /// </summary>
+        [Fact]
+        public void CanRelyOnMsiTransactionRollback()
+        {
+            var packageA = this.CreatePackageInstaller("PackageA");
+            var packageBv1 = this.CreatePackageInstaller("PackageBv1");
+            var packageBv2 = this.CreatePackageInstaller("PackageBv2");
+            this.CreatePackageInstaller("PackageF");
+
+            var bundleBv1 = this.CreateBundleInstaller("BundleBv1");
+            var bundleBv2 = this.CreateBundleInstaller("BundleBv2");
+
+            var packageASourceCodeInstalled = packageA.GetInstalledFilePath("Package.wxs");
+            var packageBv1SourceCodeInstalled = packageBv1.GetInstalledFilePath("Package.wxs");
+            var packageBv2SourceCodeInstalled = packageBv2.GetInstalledFilePath("Package.wxs");
+
+            // Source file should *not* be installed
+            Assert.False(File.Exists(packageASourceCodeInstalled), $"Package A payload should not be there on test start: {packageASourceCodeInstalled}");
+            Assert.False(File.Exists(packageBv1SourceCodeInstalled), $"Package Bv1 payload should not be there on test start: {packageBv1SourceCodeInstalled}");
+            Assert.False(File.Exists(packageBv2SourceCodeInstalled), $"Package Bv2 payload should not be there on test start: {packageBv2SourceCodeInstalled}");
+
+            bundleBv1.Install();
+
+            bundleBv1.VerifyRegisteredAndInPackageCache();
+
+            // Source file should be installed
+            Assert.True(File.Exists(packageBv1SourceCodeInstalled), String.Concat("Should have found Package Bv1 payload installed at: ", packageBv1SourceCodeInstalled));
+
+            bundleBv2.Install((int)MSIExec.MSIExecReturnCode.ERROR_INSTALL_FAILURE);
+
+            // Bundle v2 should be registered since it installed a non-permanent package.
+            bundleBv2.VerifyRegisteredAndInPackageCache();
+
+            // Bundle v1 should not have been removed since the install of v2 failed in the middle of the chain.
+            bundleBv1.VerifyRegisteredAndInPackageCache();
+
+            // Source file should be installed
+            Assert.True(File.Exists(packageASourceCodeInstalled), String.Concat("Should have found Package A payload installed at: ", packageASourceCodeInstalled));
+
+            // Previous source file should be installed
+            Assert.True(File.Exists(packageBv1SourceCodeInstalled), String.Concat("Should have found Package Bv1 payload installed at: ", packageBv1SourceCodeInstalled));
+            Assert.False(File.Exists(packageBv2SourceCodeInstalled), String.Concat("Should not have found Package Bv2 payload installed at: ", packageBv2SourceCodeInstalled));
+        }
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/PatchTests.cs b/src/test/burn/WixToolsetTest.BurnE2E/PatchTests.cs
new file mode 100644
index 00000000..0c7fdc98
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/PatchTests.cs
@@ -0,0 +1,137 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using System;
+    using System.IO;
+    using System.Xml;
+    using Xunit;
+    using Xunit.Abstractions;
+
+    public class PatchTests : BurnE2ETests
+    {
+        public PatchTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
+
+        [Fact]
+        public void CanRunDetectMultipleTimesWithPatches()
+        {
+            var testBAController = this.CreateTestBAController();
+            testBAController.SetRedetectCount(1);
+
+            this.CanInstallBundleWithPatchThenRemoveIt();
+        }
+
+        [Fact]
+        public void CanInstallBundleWithPatchThenRemoveIt()
+        {
+            var originalVersion = "1.0.0.0";
+            var patchedVersion = "1.0.1.0";
+            var testRegistryValue = "PackageA";
+
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var bundleA = this.CreateBundleInstaller("BundleA");
+            var bundlePatchA = this.CreateBundleInstaller("BundlePatchA");
+
+            bundleA.Install();
+            bundleA.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(true);
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, originalVersion);
+
+            bundlePatchA.Install();
+            bundlePatchA.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, patchedVersion);
+
+            bundlePatchA.Uninstall();
+            bundlePatchA.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, originalVersion);
+
+            bundleA.Uninstall();
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv1.VerifyTestRegistryRootDeleted();
+        }
+
+        [Fact(Skip = "https://github.com/wixtoolset/issues/issues/6380")]
+        public void CanPatchSwidTag()
+        {
+            var originalVersion = "1.0.0.0";
+            var patchedVersion = "1.0.1.0";
+            var packageTagName = "~PatchTests - PackageA";
+            var bundleTagName = "~PatchTests - BundleA";
+            var bundlePatchTagName = "~PatchTests - BundlePatchA";
+
+            this.CreatePackageInstaller("PackageAv1");
+            var bundleA = this.CreateBundleInstaller("BundleA");
+            var bundlePatchA = this.CreateBundleInstaller("BundlePatchA");
+
+            bundleA.Install();
+            VerifySwidTagVersion(bundleTagName, originalVersion);
+            VerifySwidTagVersion(packageTagName, originalVersion);
+
+            bundlePatchA.Install();
+            VerifySwidTagVersion(bundlePatchTagName, patchedVersion);
+            VerifySwidTagVersion(packageTagName, patchedVersion);
+
+            bundlePatchA.Uninstall();
+            VerifySwidTagVersion(packageTagName, originalVersion);
+
+            bundleA.Uninstall();
+            VerifySwidTagVersion(bundleTagName, null);
+            VerifySwidTagVersion(packageTagName, null);
+        }
+
+        [Fact]
+        public void CanInstallBundleWithPatchesTargetingSingleProductThenRemoveIt()
+        {
+            var originalVersion = "1.0.0.0";
+            var patchedVersion = "1.0.1.0";
+            var testRegistryValue = "PackageA";
+            var testRegistryValue2 = "PackageA2";
+
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var bundlePatchA2 = this.CreateBundleInstaller("BundlePatchA2");
+
+            packageAv1.InstallProduct();
+            packageAv1.VerifyInstalled(true);
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, originalVersion);
+            packageAv1.VerifyTestRegistryValue(testRegistryValue2, originalVersion);
+
+            bundlePatchA2.Install();
+            bundlePatchA2.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, patchedVersion);
+            packageAv1.VerifyTestRegistryValue(testRegistryValue2, patchedVersion);
+
+            bundlePatchA2.Uninstall();
+            bundlePatchA2.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, originalVersion);
+            packageAv1.VerifyTestRegistryValue(testRegistryValue2, originalVersion);
+        }
+
+        private static void VerifySwidTagVersion(string tagName, string expectedVersion)
+        {
+            var regidFolder = Environment.ExpandEnvironmentVariables(@"%ProgramData%\regid.1995-08.com.example");
+            var tagPath = Path.Combine(regidFolder, "regid.1995-08.com.example " + tagName + ".swidtag");
+            string version = null;
+
+            if (File.Exists(tagPath))
+            {
+                var doc = new XmlDocument();
+                doc.Load(tagPath);
+
+                var ns = new XmlNamespaceManager(doc.NameTable);
+                ns.AddNamespace("s", "http://standards.iso.org/iso/19770/-2/2009/schema.xsd");
+
+                var versionNode = doc.SelectSingleNode("/s:software_identification_tag/s:product_version/s:name", ns);
+                version = versionNode?.InnerText ?? String.Empty;
+            }
+
+            Assert.Equal(expectedVersion, version);
+        }
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/PrereqBaTests.cs b/src/test/burn/WixToolsetTest.BurnE2E/PrereqBaTests.cs
new file mode 100644
index 00000000..ced2e08e
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/PrereqBaTests.cs
@@ -0,0 +1,76 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using System;
+    using System.IO;
+    using Xunit;
+    using Xunit.Abstractions;
+
+    public class PrereqBaTests : BurnE2ETests
+    {
+        public PrereqBaTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
+
+        /// <summary>
+        /// This bundle purposely provides a .runtimeconfig.json file that requires a version of .NET Core that doesn't exist,
+        /// with an MSI package to represent the prerequisite package.
+        /// This verifies that:
+        ///   The preqba doesn't infinitely reload itself after failing to load the managed BA.
+        ///   The engine automatically uninstalls the bundle since only permanent packages were installed.
+        /// </summary>
+        [Fact]
+        public void DncPreqBaDetectsInfiniteLoop()
+        {
+            var packageA = this.CreatePackageInstaller("PackageA");
+            this.CreatePackageInstaller("PackageF");
+
+            var bundleA = this.CreateBundleInstaller("BundleA");
+
+            var packageASourceCodeInstalled = packageA.GetInstalledFilePath("Package.wxs");
+
+            // Source file should *not* be installed
+            Assert.False(File.Exists(packageASourceCodeInstalled), $"Package A payload should not be there on test start: {packageASourceCodeInstalled}");
+
+            bundleA.Install();
+
+            // Part of the test is Install actually completing.
+
+            // Source file should be installed
+            Assert.True(File.Exists(packageASourceCodeInstalled), String.Concat("Should have found Package A payload installed at: ", packageASourceCodeInstalled));
+
+            // No non-permanent packages should have ended up installed or cached so it should have unregistered.
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+        }
+
+        /// <summary>
+        /// This bundle purposely provides a WixToolset.Mba.Host.config file that requires a version of .NET Framework that doesn't exist,
+        /// with an MSI package to represent the prerequisite package.
+        /// This verifies that:
+        ///   The preqba doesn't infinitely reload itself after failing to load the managed BA.
+        ///   The engine automatically uninstalls the bundle since only permanent packages were installed.
+        /// </summary>
+        [Fact]
+        public void MbaPreqBaDetectsInfiniteLoop()
+        {
+            var packageB = this.CreatePackageInstaller("PackageB");
+            this.CreatePackageInstaller("PackageF");
+
+            var bundleB = this.CreateBundleInstaller("BundleB");
+
+            var packageBSourceCodeInstalled = packageB.GetInstalledFilePath("Package.wxs");
+
+            // Source file should *not* be installed
+            Assert.False(File.Exists(packageBSourceCodeInstalled), $"Package B payload should not be there on test start: {packageBSourceCodeInstalled}");
+
+            bundleB.Install();
+
+            // Part of the test is Install actually completing.
+
+            // Source file should be installed
+            Assert.True(File.Exists(packageBSourceCodeInstalled), String.Concat("Should have found Package B payload installed at: ", packageBSourceCodeInstalled));
+
+            // No non-permanent packages should have ended up installed or cached so it should have unregistered.
+            bundleB.VerifyUnregisteredAndRemovedFromPackageCache();
+        }
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/RegistrationTests.cs b/src/test/burn/WixToolsetTest.BurnE2E/RegistrationTests.cs
new file mode 100644
index 00000000..51122c28
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/RegistrationTests.cs
@@ -0,0 +1,78 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using System;
+    using Xunit;
+    using Xunit.Abstractions;
+
+    public class RegistrationTests : BurnE2ETests
+    {
+        public RegistrationTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
+
+        [Fact]
+        public void AutomaticallyUncachesBundleWhenNotInstalled()
+        {
+            var bundleA = this.CreateBundleInstaller("BundleA");
+            var testBAController = this.CreateTestBAController();
+
+            var cachedBundlePath = bundleA.ManuallyCache();
+
+            testBAController.SetQuitAfterDetect();
+
+            bundleA.Install(cachedBundlePath);
+
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+        }
+
+        [Fact]
+        public void AutomaticallyUninstallsBundleWithoutBADoingApply()
+        {
+            this.InstallBundleThenManuallyUninstallPackageAndRemovePackageFromCacheThenRunAndQuitWithoutApply(true);
+        }
+
+        [Fact]
+        public void AutomaticallyUninstallsBundleWithoutBADoingDetect()
+        {
+            this.InstallBundleThenManuallyUninstallPackageAndRemovePackageFromCacheThenRunAndQuitWithoutApply(false);
+        }
+
+        [Fact]
+        public void RegistersInARPIfPrecached()
+        {
+            var bundleA = this.CreateBundleInstaller("BundleA");
+
+            bundleA.ManuallyCache();
+
+            // Verifies https://github.com/wixtoolset/issues/issues/5702
+            bundleA.Install();
+            bundleA.VerifyRegisteredAndInPackageCache();
+        }
+
+        private void InstallBundleThenManuallyUninstallPackageAndRemovePackageFromCacheThenRunAndQuitWithoutApply(bool detect)
+        {
+            var packageA = this.CreatePackageInstaller("PackageA");
+            var bundleA = this.CreateBundleInstaller("BundleA");
+            var testBAController = this.CreateTestBAController();
+
+            bundleA.Install();
+            bundleA.VerifyRegisteredAndInPackageCache();
+            packageA.VerifyInstalled(true);
+
+            packageA.UninstallProduct();
+            bundleA.RemovePackageFromCache("PackageA");
+
+            if (detect)
+            {
+                testBAController.SetQuitAfterDetect();
+            }
+            else
+            {
+                testBAController.SetImmediatelyQuit();
+            }
+            bundleA.Install();
+            packageA.VerifyInstalled(false);
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+        }
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/RollbackBoundaryTests.cs b/src/test/burn/WixToolsetTest.BurnE2E/RollbackBoundaryTests.cs
new file mode 100644
index 00000000..6539db34
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/RollbackBoundaryTests.cs
@@ -0,0 +1,52 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using System;
+    using System.IO;
+    using Xunit;
+    using Xunit.Abstractions;
+
+    public class RollbackBoundaryTests : BurnE2ETests
+    {
+        public RollbackBoundaryTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
+
+        /// <summary>
+        /// Installs 1 bundle:
+        ///   chain - non-vital rollback boundary, package F, package A, vital rollback boundary, package B
+        ///     package F fails
+        ///     package A and B are permanent
+        ///   Execution is supposed to be:
+        ///     package F (fails)
+        ///     rollback to non-vital rollback boundary which ignores the error and skips over package A
+        ///     install package B
+        ///     unregister since no non-permanent packages should be installed or cached.
+        /// </summary>
+        [Fact(Skip = "https://github.com/wixtoolset/issues/issues/6309")]
+        public void NonVitalRollbackBoundarySkipsToNextRollbackBoundary()
+        {
+            var packageA = this.CreatePackageInstaller("PackageA");
+            var packageB = this.CreatePackageInstaller("PackageB");
+            this.CreatePackageInstaller("PackageC");
+            this.CreatePackageInstaller("PackageF");
+
+            var bundleA = this.CreateBundleInstaller("BundleA");
+
+            var packageASourceCodeInstalled = packageA.GetInstalledFilePath("Package.wxs");
+            var packageBSourceCodeInstalled = packageB.GetInstalledFilePath("Package.wxs");
+
+            // Source file should *not* be installed
+            Assert.False(File.Exists(packageASourceCodeInstalled), $"Package A payload should not be there on test start: {packageASourceCodeInstalled}");
+            Assert.False(File.Exists(packageBSourceCodeInstalled), $"Package B payload should not be there on test start: {packageBSourceCodeInstalled}");
+
+            bundleA.Install();
+
+            // No non-permanent packages should have ended up installed or cached so it should have unregistered.
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+
+            // Only PackageB source file should be installed
+            Assert.True(File.Exists(packageBSourceCodeInstalled), String.Concat("Should have found Package B payload installed at: ", packageBSourceCodeInstalled));
+            Assert.False(File.Exists(packageASourceCodeInstalled), String.Concat("Should not have found Package A payload installed at: ", packageASourceCodeInstalled));
+        }
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/SlipstreamTests.cs b/src/test/burn/WixToolsetTest.BurnE2E/SlipstreamTests.cs
new file mode 100644
index 00000000..29632e2e
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/SlipstreamTests.cs
@@ -0,0 +1,353 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using System;
+    using System.IO;
+    using WixTestTools;
+    using WixToolset.Mba.Core;
+    using Xunit;
+    using Xunit.Abstractions;
+
+    public class SlipstreamTests : BurnE2ETests
+    {
+        public SlipstreamTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
+
+        private const string V090 = "0.9.0.0";
+        private const string V100 = "1.0.0.0";
+        private const string V101 = "1.0.1.0";
+
+        [Fact]
+        public void CanInstallBundleWithSlipstreamedPatchThenRemoveIt()
+        {
+            var testRegistryValue = "PackageA";
+
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var bundleA = this.CreateBundleInstaller("BundleA");
+
+            var packageAv1SourceCodeInstalled = packageAv1.GetInstalledFilePath("Package.wxs");
+            Assert.False(File.Exists(packageAv1SourceCodeInstalled), $"PackageAv1 payload should not be there on test start: {packageAv1SourceCodeInstalled}");
+
+            bundleA.Install();
+            bundleA.VerifyRegisteredAndInPackageCache();
+            Assert.True(File.Exists(packageAv1SourceCodeInstalled), String.Concat("Should have found PackageAv1 payload installed at: ", packageAv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, V101);
+
+            bundleA.Uninstall();
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+            Assert.False(File.Exists(packageAv1SourceCodeInstalled), String.Concat("PackageAv1 payload should have been removed by uninstall from: ", packageAv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryRootDeleted();
+        }
+
+        /// <summary>
+        /// BundleA installs PackageA with slipstreamed PatchA.
+        /// BundleOnlyPatchA is installed which contains PatchA (which should be a no-op).
+        /// BundleOnlyPatchA in uninstalled which should do nothing since BundleA has a dependency on it.
+        /// Bundle is installed which should remove everything.
+        /// </summary>
+        [Fact]
+        public void ReferenceCountsSlipstreamedPatch()
+        {
+            var testRegistryValue = "PackageA";
+
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var bundleOnlyPatchA = this.CreateBundleInstaller("BundleOnlyPatchA");
+            var bundleA = this.CreateBundleInstaller("BundleA");
+
+            var packageAv1SourceCodeInstalled = packageAv1.GetInstalledFilePath("Package.wxs");
+            Assert.False(File.Exists(packageAv1SourceCodeInstalled), $"PackageAv1 payload should not be there on test start: {packageAv1SourceCodeInstalled}");
+
+            bundleA.Install();
+            bundleA.VerifyRegisteredAndInPackageCache();
+            Assert.True(File.Exists(packageAv1SourceCodeInstalled), String.Concat("Should have found PackageAv1 payload installed at: ", packageAv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, V101);
+
+            bundleOnlyPatchA.Install();
+            bundleOnlyPatchA.VerifyRegisteredAndInPackageCache();
+            Assert.True(File.Exists(packageAv1SourceCodeInstalled), String.Concat("Should have found PackageAv1 payload installed at: ", packageAv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, V101);
+
+            bundleOnlyPatchA.Uninstall();
+            bundleOnlyPatchA.VerifyUnregisteredAndRemovedFromPackageCache();
+            Assert.True(File.Exists(packageAv1SourceCodeInstalled), String.Concat("Should have found PackageAv1 payload installed at: ", packageAv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, V101);
+
+            bundleA.Uninstall();
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+            Assert.False(File.Exists(packageAv1SourceCodeInstalled), String.Concat("PackageAv1 payload should have been removed by uninstall from: ", packageAv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryRootDeleted();
+        }
+
+        [Fact(Skip = "https://github.com/wixtoolset/issues/issues/6350")]
+        public void CanInstallBundleWithSlipstreamedPatchThenRepairIt()
+        {
+            this.InstallBundleWithSlipstreamedPatchThenRepairIt(false);
+        }
+
+        [Fact(Skip = "https://github.com/wixtoolset/issues/issues/6350")]
+        public void CanInstallReversedBundleWithSlipstreamedPatchThenRepairIt()
+        {
+            this.InstallBundleWithSlipstreamedPatchThenRepairIt(true);
+        }
+
+        private void InstallBundleWithSlipstreamedPatchThenRepairIt(bool isReversed)
+        {
+            var bundleName = isReversed ? "BundleAReverse" : "BundleA";
+            var testRegistryValue = "PackageA";
+
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var bundleA = this.CreateBundleInstaller(bundleName);
+
+            var packageAv1SourceCodeInstalled = packageAv1.GetInstalledFilePath("Package.wxs");
+            Assert.False(File.Exists(packageAv1SourceCodeInstalled), $"PackageAv1 payload should not be there on test start: {packageAv1SourceCodeInstalled}");
+
+            bundleA.Install();
+            bundleA.VerifyRegisteredAndInPackageCache();
+            Assert.True(File.Exists(packageAv1SourceCodeInstalled), String.Concat("Should have found PackageAv1 payload installed at: ", packageAv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, V101);
+
+            // Delete the installed file and registry key so we have something to repair.
+            File.Delete(packageAv1SourceCodeInstalled);
+            packageAv1.DeleteTestRegistryValue(testRegistryValue);
+
+            bundleA.Repair();
+            bundleA.VerifyRegisteredAndInPackageCache();
+            Assert.True(File.Exists(packageAv1SourceCodeInstalled), String.Concat("Should have found PackageAv1 payload installed at: ", packageAv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, V101);
+
+            bundleA.Uninstall();
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+            Assert.False(File.Exists(packageAv1SourceCodeInstalled), String.Concat("PackageAv1 payload should have been removed by uninstall from: ", packageAv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryRootDeleted();
+        }
+
+        [Fact]
+        public void CanInstallSlipstreamedPatchThroughForcedRepair()
+        {
+            this.InstallSlipstreamedPatchThroughForcedRepair(false);
+        }
+
+        [Fact]
+        public void CanInstallSlipstreamedPatchThroughReversedForcedRepair()
+        {
+            this.InstallSlipstreamedPatchThroughForcedRepair(true);
+        }
+
+        private void InstallSlipstreamedPatchThroughForcedRepair(bool isReversed)
+        {
+            var bundleName = isReversed ? "BundleAReverse" : "BundleA";
+            var testRegistryValue = "PackageA";
+
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var bundleA = this.CreateBundleInstaller(bundleName);
+            var bundleOnlyA = this.CreateBundleInstaller("BundleOnlyA");
+            var testBAController = this.CreateTestBAController();
+
+            var packageAv1SourceCodeInstalled = packageAv1.GetInstalledFilePath("Package.wxs");
+            Assert.False(File.Exists(packageAv1SourceCodeInstalled), $"PackageAv1 payload should not be there on test start: {packageAv1SourceCodeInstalled}");
+
+            bundleOnlyA.Install();
+            bundleOnlyA.VerifyRegisteredAndInPackageCache();
+            Assert.True(File.Exists(packageAv1SourceCodeInstalled), String.Concat("Should have found PackageAv1 payload installed at: ", packageAv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, V100);
+
+            // Delete the installed file and registry key so we have something to repair.
+            File.Delete(packageAv1SourceCodeInstalled);
+            packageAv1.DeleteTestRegistryValue(testRegistryValue);
+
+            testBAController.SetPackageRequestedState("PackageA", RequestState.Repair);
+            testBAController.SetPackageRequestedState("PatchA", RequestState.Repair);
+
+            bundleA.Install();
+            bundleA.VerifyRegisteredAndInPackageCache();
+            Assert.True(File.Exists(packageAv1SourceCodeInstalled), String.Concat("Should have found PackageAv1 payload installed at: ", packageAv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, V101);
+
+            testBAController.ResetPackageStates("PackageA");
+            testBAController.ResetPackageStates("PatchA");
+
+            bundleA.Uninstall();
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+            Assert.True(File.Exists(packageAv1SourceCodeInstalled), String.Concat("Should have found PackageAv1 payload installed at: ", packageAv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, V100);
+
+            bundleOnlyA.Uninstall();
+            bundleOnlyA.VerifyUnregisteredAndRemovedFromPackageCache();
+            Assert.False(File.Exists(packageAv1SourceCodeInstalled), String.Concat("PackageAv1 payload should have been removed by uninstall from: ", packageAv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryRootDeleted();
+        }
+
+        [Fact]
+        public void CanUninstallSlipstreamedPatchAlone()
+        {
+            var testRegistryValue = "PackageA";
+
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var bundleA = this.CreateBundleInstaller("BundleA");
+            var testBAController = this.CreateTestBAController();
+
+            var packageAv1SourceCodeInstalled = packageAv1.GetInstalledFilePath("Package.wxs");
+            Assert.False(File.Exists(packageAv1SourceCodeInstalled), $"PackageAv1 payload should not be there on test start: {packageAv1SourceCodeInstalled}");
+
+            bundleA.Install();
+            bundleA.VerifyRegisteredAndInPackageCache();
+            Assert.True(File.Exists(packageAv1SourceCodeInstalled), String.Concat("Should have found PackageAv1 payload installed at: ", packageAv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, V101);
+
+            testBAController.SetPackageRequestedState("PatchA", RequestState.Absent);
+
+            bundleA.Modify();
+            bundleA.VerifyRegisteredAndInPackageCache();
+            Assert.True(File.Exists(packageAv1SourceCodeInstalled), String.Concat("Should have found PackageAv1 payload installed at: ", packageAv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, V100);
+
+            bundleA.Uninstall();
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+            Assert.False(File.Exists(packageAv1SourceCodeInstalled), String.Concat("PackageAv1 payload should have been removed by uninstall from: ", packageAv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryRootDeleted();
+        }
+
+        [Fact]
+        public void CanModifyToUninstallPackageWithSlipstreamedPatch()
+        {
+            var testRegistryValue = "PackageA";
+
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var packageBv1 = this.CreatePackageInstaller("PackageBv1");
+            var bundleB = this.CreateBundleInstaller("BundleB");
+            var testBAController = this.CreateTestBAController();
+
+            var packageAv1SourceCodeInstalled = packageAv1.GetInstalledFilePath("Package.wxs");
+            var packageBv1SourceCodeInstalled = packageBv1.GetInstalledFilePath("Package.wxs");
+            Assert.False(File.Exists(packageAv1SourceCodeInstalled), $"PackageAv1 payload should not be there on test start: {packageAv1SourceCodeInstalled}");
+            Assert.False(File.Exists(packageBv1SourceCodeInstalled), $"PackageBv1 payload should not be there on test start: {packageBv1SourceCodeInstalled}");
+
+            bundleB.Install();
+            bundleB.VerifyRegisteredAndInPackageCache();
+            Assert.True(File.Exists(packageAv1SourceCodeInstalled), String.Concat("Should have found PackageAv1 payload installed at: ", packageAv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, V101);
+            Assert.True(File.Exists(packageBv1SourceCodeInstalled), String.Concat("Should have found PackageBv1 payload installed at: ", packageBv1SourceCodeInstalled));
+
+            testBAController.SetPackageRequestedState("PackageA", RequestState.Absent);
+            testBAController.SetPackageRequestedState("PatchA", RequestState.Absent);
+
+            bundleB.Modify();
+            bundleB.VerifyRegisteredAndInPackageCache();
+            Assert.False(File.Exists(packageAv1SourceCodeInstalled), $"PackageAv1 payload should have been removed by modify from: {packageAv1SourceCodeInstalled}");
+
+            testBAController.ResetPackageStates("PackageA");
+            testBAController.ResetPackageStates("PatchA");
+
+            bundleB.Uninstall();
+            bundleB.VerifyUnregisteredAndRemovedFromPackageCache();
+            Assert.False(File.Exists(packageBv1SourceCodeInstalled), String.Concat("PackageBv1 payload should have been removed by uninstall from: ", packageBv1SourceCodeInstalled));
+            packageBv1.VerifyTestRegistryRootDeleted();
+        }
+
+        [Fact]
+        public void UninstallsPackageWithSlipstreamedPatchDuringRollback()
+        {
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var packageBv1 = this.CreatePackageInstaller("PackageBv1");
+            var bundleB = this.CreateBundleInstaller("BundleB");
+            var testBAController = this.CreateTestBAController();
+
+            var packageAv1SourceCodeInstalled = packageAv1.GetInstalledFilePath("Package.wxs");
+            var packageBv1SourceCodeInstalled = packageBv1.GetInstalledFilePath("Package.wxs");
+            Assert.False(File.Exists(packageAv1SourceCodeInstalled), $"PackageAv1 payload should not be there on test start: {packageAv1SourceCodeInstalled}");
+            Assert.False(File.Exists(packageBv1SourceCodeInstalled), $"PackageBv1 payload should not be there on test start: {packageBv1SourceCodeInstalled}");
+
+            testBAController.SetPackageCancelExecuteAtProgress("PackageB", 50);
+
+            bundleB.Install((int)MSIExec.MSIExecReturnCode.ERROR_INSTALL_USEREXIT);
+            bundleB.VerifyUnregisteredAndRemovedFromPackageCache();
+            Assert.False(File.Exists(packageAv1SourceCodeInstalled), $"PackageAv1 payload should have been removed by rollback from: {packageAv1SourceCodeInstalled}");
+            Assert.False(File.Exists(packageBv1SourceCodeInstalled), String.Concat("PackageBv1 payload should not have been installed from: ", packageBv1SourceCodeInstalled));
+            packageBv1.VerifyTestRegistryRootDeleted();
+        }
+
+        [Fact(Skip = "https://github.com/wixtoolset/issues/issues/6359")]
+        public void CanAutomaticallyPredetermineSlipstreamPatchesAtBuildTime()
+        {
+            var testRegistryValueA = "PackageA";
+            var testRegistryValueA2 = "PackageA2";
+            var testRegistryValueB = "PackageB";
+            var testRegistryValueB2 = "PackageB2";
+
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var packageBv1 = this.CreatePackageInstaller("PackageBv1");
+            var bundleC = this.CreateBundleInstaller("BundleC");
+
+            var packageAv1SourceCodeInstalled = packageAv1.GetInstalledFilePath("Package.wxs");
+            var packageBv1SourceCodeInstalled = packageBv1.GetInstalledFilePath("Package.wxs");
+            Assert.False(File.Exists(packageAv1SourceCodeInstalled), $"PackageAv1 payload should not be there on test start: {packageAv1SourceCodeInstalled}");
+            Assert.False(File.Exists(packageBv1SourceCodeInstalled), $"PackageBv1 payload should not be there on test start: {packageBv1SourceCodeInstalled}");
+
+            bundleC.Install();
+            bundleC.VerifyRegisteredAndInPackageCache();
+            Assert.True(File.Exists(packageAv1SourceCodeInstalled), String.Concat("Should have found PackageAv1 payload installed at: ", packageAv1SourceCodeInstalled));
+            // Product A should've slipstreamed both patches.
+            packageAv1.VerifyTestRegistryValue(testRegistryValueA, V101);
+            packageAv1.VerifyTestRegistryValue(testRegistryValueA2, V101);
+            // Product B should've only slipstreamed patch AB2.
+            packageBv1.VerifyTestRegistryValue(testRegistryValueB, V100);
+            packageBv1.VerifyTestRegistryValue(testRegistryValueB2, V101);
+
+            bundleC.Uninstall();
+            bundleC.VerifyUnregisteredAndRemovedFromPackageCache();
+            Assert.False(File.Exists(packageAv1SourceCodeInstalled), String.Concat("PackageAv1 payload should have been removed by uninstall from: ", packageAv1SourceCodeInstalled));
+            Assert.False(File.Exists(packageBv1SourceCodeInstalled), String.Concat("PackageBv1 payload should have been removed by uninstall from: ", packageBv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryRootDeleted();
+        }
+
+        [Fact]
+        public void CanInstallSlipstreamedPatchWithPackageDuringMajorUpgrade()
+        {
+            var testRegistryValue = "PackageA";
+
+            var packageAv0 = this.CreatePackageInstaller("PackageAv0_9_0");
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var bundleA = this.CreateBundleInstaller("BundleA");
+
+            packageAv1.VerifyInstalled(false);
+
+            packageAv0.InstallProduct();
+            packageAv0.VerifyInstalled(true);
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, V090);
+
+            bundleA.Install();
+            bundleA.VerifyRegisteredAndInPackageCache();
+            packageAv0.VerifyInstalled(false);
+            packageAv1.VerifyInstalled(true);
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, V101);
+
+            bundleA.Uninstall();
+            bundleA.VerifyUnregisteredAndRemovedFromPackageCache();
+            packageAv1.VerifyInstalled(false);
+            packageAv1.VerifyTestRegistryRootDeleted();
+        }
+
+        [Fact]
+        public void RespectsSlipstreamedPatchInstallCondition()
+        {
+            var testRegistryValue = "PackageA";
+
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var bundleD = this.CreateBundleInstaller("BundleD");
+
+            var packageAv1SourceCodeInstalled = packageAv1.GetInstalledFilePath("Package.wxs");
+            Assert.False(File.Exists(packageAv1SourceCodeInstalled), $"PackageAv1 payload should not be there on test start: {packageAv1SourceCodeInstalled}");
+
+            bundleD.Install();
+            bundleD.VerifyRegisteredAndInPackageCache();
+            Assert.True(File.Exists(packageAv1SourceCodeInstalled), String.Concat("Should have found PackageAv1 payload installed at: ", packageAv1SourceCodeInstalled));
+            // The patch was not supposed to be installed.
+            packageAv1.VerifyTestRegistryValue(testRegistryValue, V100);
+
+            bundleD.Uninstall();
+            bundleD.VerifyUnregisteredAndRemovedFromPackageCache();
+            Assert.False(File.Exists(packageAv1SourceCodeInstalled), String.Concat("PackageAv1 payload should have been removed by uninstall from: ", packageAv1SourceCodeInstalled));
+            packageAv1.VerifyTestRegistryRootDeleted();
+        }
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/TestBAController.cs b/src/test/burn/WixToolsetTest.BurnE2E/TestBAController.cs
new file mode 100644
index 00000000..6e4fe6c6
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/TestBAController.cs
@@ -0,0 +1,187 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using System;
+    using Microsoft.Win32;
+    using WixTestTools;
+    using WixToolset.Mba.Core;
+
+    public class TestBAController : IDisposable
+    {
+        public TestBAController(WixTestContext testContext, bool x64 = false)
+        {
+            this.TestGroupName = testContext.TestGroupName;
+            this.BaseRegKeyPath = x64 ? @"Software\WiX\Tests" : @"Software\WOW6432Node\WiX\Tests";
+            this.TestBaseRegKeyPath = String.Format(@"{0}\TestBAControl\{1}", this.BaseRegKeyPath, this.TestGroupName);
+        }
+
+        private string BaseRegKeyPath { get; }
+
+        private string TestBaseRegKeyPath { get; }
+
+        public string TestGroupName { get; }
+
+        /// <summary>
+        /// Sets a test value in the registry to communicate with the TestBA.
+        /// </summary>
+        /// <param name="name">Name of the value to set.</param>
+        /// <param name="value">Value to set. If this is null, the value is removed.</param>
+        public void SetBurnTestValue(string name, string value)
+        {
+            using (var testKey = Registry.LocalMachine.CreateSubKey(this.TestBaseRegKeyPath))
+            {
+                if (String.IsNullOrEmpty(value))
+                {
+                    testKey.DeleteValue(name, false);
+                }
+                else
+                {
+                    testKey.SetValue(name, value);
+                }
+            }
+        }
+
+        public void SetExplicitlyElevateAndPlanFromOnElevateBegin(string value = "true")
+        {
+            this.SetBurnTestValue("ExplicitlyElevateAndPlanFromOnElevateBegin", value);
+        }
+
+        public void SetImmediatelyQuit(string value = "true")
+        {
+            this.SetBurnTestValue("ImmediatelyQuit", value);
+        }
+
+        public void SetQuitAfterDetect(string value = "true")
+        {
+            this.SetBurnTestValue("QuitAfterDetect", value);
+        }
+
+        /// <summary>
+        /// Slows the cache progress of a package.
+        /// </summary>
+        /// <param name="packageId">Package identity.</param>
+        /// <param name="delay">Sets or removes the delay on a package being cached.</param>
+        public void SetPackageSlowCache(string packageId, int? delay)
+        {
+            this.SetPackageState(packageId, "SlowCache", delay.HasValue ? delay.ToString() : null);
+        }
+
+        /// <summary>
+        /// Cancels the cache of a package at a particular progress point.
+        /// </summary>
+        /// <param name="packageId">Package identity.</param>
+        /// <param name="cancelPoint">Sets or removes the cancel progress on a package being cached.</param>
+        public void SetPackageCancelCacheAtProgress(string packageId, int? cancelPoint)
+        {
+            this.SetPackageState(packageId, "CancelCacheAtProgress", cancelPoint.HasValue ? cancelPoint.ToString() : null);
+        }
+
+        /// <summary>
+        /// Slows the execute progress of a package.
+        /// </summary>
+        /// <param name="packageId">Package identity.</param>
+        /// <param name="delay">Sets or removes the delay on a package being executed.</param>
+        public void SetPackageSlowExecute(string packageId, int? delay)
+        {
+            this.SetPackageState(packageId, "SlowExecute", delay.HasValue ? delay.ToString() : null);
+        }
+
+        /// <summary>
+        /// Cancels the execute of a package at a particular progress point.
+        /// </summary>
+        /// <param name="packageId">Package identity.</param>
+        /// <param name="cancelPoint">Sets or removes the cancel progress on a package being executed.</param>
+        public void SetPackageCancelExecuteAtProgress(string packageId, int? cancelPoint)
+        {
+            this.SetPackageState(packageId, "CancelExecuteAtProgress", cancelPoint.HasValue ? cancelPoint.ToString() : null);
+        }
+
+        /// <summary>
+        /// Cancels the execute of a package at the next progess after the specified MSI action start.
+        /// </summary>
+        /// <param name="packageId">Package identity.</param>
+        /// <param name="actionName">Sets or removes the cancel progress on a package being executed.</param>
+        public void SetPackageCancelExecuteAtActionStart(string packageId, string actionName)
+        {
+            this.SetPackageState(packageId, "CancelExecuteAtActionStart", actionName);
+        }
+
+        /// <summary>
+        /// Cancels the execute of a package at a particular OnProgress point.
+        /// </summary>
+        /// <param name="packageId">Package identity.</param>
+        /// <param name="cancelPoint">Sets or removes the cancel OnProgress point on a package being executed.</param>
+        public void SetPackageCancelOnProgressAtProgress(string packageId, int? cancelPoint)
+        {
+            this.SetPackageState(packageId, "CancelOnProgressAtProgress", cancelPoint.HasValue ? cancelPoint.ToString() : null);
+        }
+
+        /// <summary>
+        /// Sets the requested state for a package that the TestBA will return to the engine during plan.
+        /// </summary>
+        /// <param name="packageId">Package identity.</param>
+        /// <param name="state">State to request.</param>
+        public void SetPackageRequestedState(string packageId, RequestState state)
+        {
+            this.SetPackageState(packageId, "Requested", state.ToString());
+        }
+
+        /// <summary>
+        /// Sets the requested state for a package that the TestBA will return to the engine during plan.
+        /// </summary>
+        /// <param name="packageId">Package identity.</param>
+        /// <param name="state">State to request.</param>
+        public void SetPackageFeatureState(string packageId, string featureId, FeatureState state)
+        {
+            this.SetPackageState(packageId, String.Concat(featureId, "Requested"), state.ToString());
+        }
+
+        /// <summary>
+        /// Sets the number of times to re-run the Detect phase.
+        /// </summary>
+        /// <param name="state">Number of times to run Detect (after the first, normal, Detect).</param>
+        public void SetRedetectCount(int redetectCount)
+        {
+            this.SetPackageState(null, "RedetectCount", redetectCount.ToString());
+        }
+
+        /// <summary>
+        /// Resets the state for a package that the TestBA will return to the engine during plan.
+        /// </summary>
+        /// <param name="packageId">Package identity.</param>
+        public void ResetPackageStates(string packageId)
+        {
+            var key = String.Format(@"{0}\{1}", this.TestBaseRegKeyPath, packageId ?? String.Empty);
+            Registry.LocalMachine.DeleteSubKey(key);
+        }
+
+        public void SetVerifyArguments(string verifyArguments)
+        {
+            this.SetBurnTestValue("VerifyArguments", verifyArguments);
+
+        }
+
+        private void SetPackageState(string packageId, string name, string value)
+        {
+            var key = String.Format(@"{0}\{1}", this.TestBaseRegKeyPath, packageId ?? String.Empty);
+            using (var packageKey = Registry.LocalMachine.CreateSubKey(key))
+            {
+                if (String.IsNullOrEmpty(value))
+                {
+                    packageKey.DeleteValue(name, false);
+                }
+                else
+                {
+                    packageKey.SetValue(name, value);
+                }
+            }
+        }
+
+        public void Dispose()
+        {
+            Registry.LocalMachine.DeleteSubKeyTree($@"{this.BaseRegKeyPath}\{this.TestGroupName}", false);
+            Registry.LocalMachine.DeleteSubKeyTree($@"{this.BaseRegKeyPath}\TestBAControl", false);
+        }
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/UpdateBundleTests.cs b/src/test/burn/WixToolsetTest.BurnE2E/UpdateBundleTests.cs
new file mode 100644
index 00000000..9fcd428b
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/UpdateBundleTests.cs
@@ -0,0 +1,245 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.IO;
+    using Xunit;
+    using Xunit.Abstractions;
+
+    public class UpdateBundleTests : BurnE2ETests
+    {
+        public UpdateBundleTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
+
+        [Fact]
+        public void CanLaunchUpdateBundleFromLocalSourceInsteadOfInstall()
+        {
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var packageAv2 = this.CreatePackageInstaller("PackageAv2");
+            var bundleAv1 = this.CreateBundleInstaller("BundleAv1");
+            var bundleAv2 = this.CreateBundleInstaller("BundleAv2");
+
+            var updateBundleSwitch = String.Concat("\"", "-updatebundle:", bundleAv2.Bundle, "\"");
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(false);
+
+            // Install the v2 bundle by getting v1 to launch it as an update bundle.
+            bundleAv1.Install(arguments: updateBundleSwitch);
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleAv2.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(true);
+
+            bundleAv2.Uninstall();
+            bundleAv2.VerifyUnregisteredAndRemovedFromPackageCache();
+            packageAv2.VerifyInstalled(false);
+        }
+
+        [Fact]
+        public void CanLaunchUpdateBundleFromLocalSourceInsteadOfModify()
+        {
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var packageAv2 = this.CreatePackageInstaller("PackageAv2");
+            var bundleAv1 = this.CreateBundleInstaller("BundleAv1");
+            var bundleAv2 = this.CreateBundleInstaller("BundleAv2");
+
+            var updateBundleSwitch = String.Concat("\"", "-updatebundle:", bundleAv2.Bundle, "\"");
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(false);
+
+            bundleAv1.Install();
+            bundleAv1.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(true);
+            packageAv2.VerifyInstalled(false);
+
+            // Install the v2 bundle by getting v1 to launch it as an update bundle.
+            bundleAv1.Modify(arguments: updateBundleSwitch);
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleAv2.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(true);
+
+            bundleAv2.Uninstall();
+            bundleAv2.VerifyUnregisteredAndRemovedFromPackageCache();
+            packageAv2.VerifyInstalled(false);
+        }
+
+        [Fact]
+        public void ForwardsArgumentsToUpdateBundle()
+        {
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var packageAv2 = this.CreatePackageInstaller("PackageAv2");
+            var bundleAv1 = this.CreateBundleInstaller("BundleAv1");
+            var bundleAv2 = this.CreateBundleInstaller("BundleAv2");
+            var testBAController = this.CreateTestBAController();
+
+            const string verifyArguments = "these arguments should exist";
+            var updateBundleSwitch = String.Concat("\"", "-updatebundle:", bundleAv2.Bundle, "\" ", verifyArguments);
+
+            testBAController.SetVerifyArguments(verifyArguments);
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(false);
+
+            // Install the v2 bundle by getting v1 to launch it as an update bundle.
+            bundleAv1.Install(arguments: updateBundleSwitch);
+            bundleAv1.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleAv2.VerifyRegisteredAndInPackageCache();
+
+            packageAv1.VerifyInstalled(false);
+            packageAv2.VerifyInstalled(true);
+
+            // Attempt to uninstall bundleA2 without the verify arguments passed and expect failure code.
+            bundleAv2.Uninstall(expectedExitCode: -1);
+
+            // Remove the required arguments and uninstall again.
+            testBAController.SetVerifyArguments(null);
+            bundleAv2.Uninstall();
+            bundleAv2.VerifyUnregisteredAndRemovedFromPackageCache();
+            packageAv2.VerifyInstalled(false);
+        }
+
+        // Installs bundle Bv1.0 then tries to update to latest version during modify (but no server exists).
+        [Fact]
+        public void CanCheckUpdateServerDuringModifyAndDoNothingWhenServerIsntResponsive()
+        {
+            var packageB = this.CreatePackageInstaller("PackageBv1");
+            var bundleB = this.CreateBundleInstaller("BundleBv1");
+
+            packageB.VerifyInstalled(false);
+
+            bundleB.Install();
+            bundleB.VerifyRegisteredAndInPackageCache();
+
+            packageB.VerifyInstalled(true);
+
+            // Run the v1 bundle requesting an update bundle.
+            bundleB.Modify(arguments: "-checkupdate");
+            bundleB.VerifyRegisteredAndInPackageCache();
+
+            // Verify nothing changed.
+            packageB.VerifyInstalled(true);
+
+            bundleB.Uninstall();
+            bundleB.VerifyUnregisteredAndRemovedFromPackageCache();
+            packageB.VerifyInstalled(false);
+        }
+
+        // Installs bundle Bv1.0 then tries to update to latest version during modify (server exists, no feed).
+        [Fact]
+        public void CanCheckUpdateServerDuringModifyAndDoNothingWhenFeedIsMissing()
+        {
+            var packageB = this.CreatePackageInstaller("PackageBv1");
+            var bundleB = this.CreateBundleInstaller("BundleBv1");
+            var webServer = this.CreateWebServer();
+
+            webServer.Start();
+
+            packageB.VerifyInstalled(false);
+
+            bundleB.Install();
+            bundleB.VerifyRegisteredAndInPackageCache();
+
+            packageB.VerifyInstalled(true);
+
+            // Run the v1 bundle requesting an update bundle.
+            bundleB.Modify(arguments: "-checkupdate");
+            bundleB.VerifyRegisteredAndInPackageCache();
+
+            // Verify nothing changed.
+            packageB.VerifyInstalled(true);
+
+            bundleB.Uninstall();
+            bundleB.VerifyUnregisteredAndRemovedFromPackageCache();
+            packageB.VerifyInstalled(false);
+        }
+
+        // Installs bundle Bv1.0 then tries to update to latest version during modify (server exists, v1.0 feed).
+        [Fact]
+        public void CanCheckUpdateServerDuringModifyAndDoNothingWhenAlreadyLatestVersion()
+        {
+            var packageB = this.CreatePackageInstaller("PackageBv1");
+            var bundleB = this.CreateBundleInstaller("BundleBv1");
+            var webServer = this.CreateWebServer();
+
+            webServer.AddFiles(new Dictionary<string, string>
+            {
+                { "/BundleB/feed", Path.Combine(this.TestContext.TestDataFolder, "FeedBv1.0.xml") },
+            });
+            webServer.Start();
+
+            packageB.VerifyInstalled(false);
+
+            bundleB.Install();
+            bundleB.VerifyRegisteredAndInPackageCache();
+
+            packageB.VerifyInstalled(true);
+
+            // Run the v1 bundle requesting an update bundle.
+            bundleB.Modify(arguments: "-checkupdate");
+            bundleB.VerifyRegisteredAndInPackageCache();
+
+            // Verify nothing changed.
+            packageB.VerifyInstalled(true);
+
+            bundleB.Uninstall();
+            bundleB.VerifyUnregisteredAndRemovedFromPackageCache();
+            packageB.VerifyInstalled(false);
+        }
+
+        // Installs bundle Bv1.0 then does an update to bundle Bv2.0 during modify (server exists, v2.0 feed).
+        [Fact]
+        public void CanLaunchUpdateBundleFromDownloadInsteadOfModify()
+        {
+            var packageBv1 = this.CreatePackageInstaller("PackageBv1");
+            var packageBv2 = this.CreatePackageInstaller("PackageBv2");
+            var bundleBv1 = this.CreateBundleInstaller("BundleBv1");
+            var bundleBv2 = this.CreateBundleInstaller("BundleBv2");
+            var webServer = this.CreateWebServer();
+
+            webServer.AddFiles(new Dictionary<string, string>
+            {
+                { "/BundleB/feed", Path.Combine(this.TestContext.TestDataFolder, "FeedBv2.0.xml") },
+                { "/BundleB/2.0/BundleB.exe", bundleBv2.Bundle },
+            });
+            webServer.Start();
+
+            packageBv1.VerifyInstalled(false);
+            packageBv2.VerifyInstalled(false);
+
+            bundleBv1.Install();
+            bundleBv1.VerifyRegisteredAndInPackageCache();
+
+            packageBv1.VerifyInstalled(true);
+            packageBv2.VerifyInstalled(false);
+
+            // Run the v1 bundle requesting an update bundle.
+            bundleBv1.Modify(arguments: "-checkupdate");
+
+            // The modify -> update is asynchronous, so we need to wait until the real BundleB is done
+            var childBundles = Process.GetProcessesByName(Path.GetFileNameWithoutExtension(bundleBv2.Bundle));
+            foreach (var childBundle in childBundles)
+            {
+                childBundle.WaitForExit();
+            }
+
+            bundleBv1.VerifyUnregisteredAndRemovedFromPackageCache();
+            bundleBv2.VerifyRegisteredAndInPackageCache();
+
+            packageBv1.VerifyInstalled(false);
+            packageBv2.VerifyInstalled(true);
+
+            bundleBv2.Uninstall();
+            bundleBv2.VerifyUnregisteredAndRemovedFromPackageCache();
+            packageBv1.VerifyInstalled(false);
+            packageBv2.VerifyInstalled(false);
+        }
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/UpgradeRelatedBundleTests.cs b/src/test/burn/WixToolsetTest.BurnE2E/UpgradeRelatedBundleTests.cs
new file mode 100644
index 00000000..70c0c474
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/UpgradeRelatedBundleTests.cs
@@ -0,0 +1,36 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using System;
+    using System.IO;
+    using WixTestTools;
+    using Xunit;
+    using Xunit.Abstractions;
+
+    public class UpgradeRelatedBundleTests : BurnE2ETests
+    {
+        public UpgradeRelatedBundleTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper) { }
+
+        [Fact]
+        public void ReportsRelatedBundleMissingFromCache()
+        {
+            var packageAv1 = this.CreatePackageInstaller("PackageAv1");
+            var packageAv2 = this.CreatePackageInstaller("PackageAv2");
+            var bundleAv1 = this.CreateBundleInstaller("BundleAv1");
+            var bundleAv2 = this.CreateBundleInstaller("BundleAv2");
+
+            bundleAv1.Install();
+            bundleAv1.VerifyRegisteredAndInPackageCache();
+
+            bundleAv1.ManuallyUncache();
+
+            // Verify https://github.com/wixtoolset/issues/issues/4991
+            var bundleAv2InstallLogFilePath = bundleAv2.Install();
+            bundleAv2.VerifyRegisteredAndInPackageCache();
+
+            Assert.True(LogVerifier.MessageInLogFileRegex(bundleAv2InstallLogFilePath, @"OnDetectRelatedBundle\(\) - id: \{[0-9A-Za-z\-]{36}\}, missing from cache: True"));
+            Assert.True(LogVerifier.MessageInLogFileRegex(bundleAv2InstallLogFilePath, @"Detected related bundle: \{[0-9A-Za-z\-]{36}\}, type: Upgrade, scope: PerMachine, version: 1\.0\.0\.0, operation: MajorUpgrade, cached: No"));
+        }
+    }
+}
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/WebServer/CoreOwinWebServer.cs b/src/test/burn/WixToolsetTest.BurnE2E/WebServer/CoreOwinWebServer.cs
new file mode 100644
index 00000000..89825813
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/WebServer/CoreOwinWebServer.cs
@@ -0,0 +1,70 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolsetTest.BurnE2E
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using Microsoft.AspNetCore.Builder;
+    using Microsoft.AspNetCore.Hosting;
+    using Microsoft.Extensions.FileProviders;
+    using Microsoft.Extensions.FileProviders.Physical;
+    using Microsoft.Extensions.Hosting;
+    using Microsoft.Extensions.Primitives;
+
+    public class CoreOwinWebServer : IWebServer, IFileProvider
+    {
+        private Dictionary<string, string> PhysicalPathsByRelativeUrl { get; } = new Dictionary<string, string>();
+
+        private IHost WebHost { get; set; }
+
+        public void AddFiles(Dictionary<string, string> physicalPathsByRelativeUrl)
+        {
+            foreach (var kvp in physicalPathsByRelativeUrl)
+            {
+                this.PhysicalPathsByRelativeUrl.Add(kvp.Key, kvp.Value);
+            }
+        }
+
+        public void Start()
+        {
+            this.WebHost = Host.CreateDefaultBuilder()
+                               .ConfigureWebHostDefaults(webBuilder =>
+                               {
+                                   // Use localhost instead of * to avoid firewall issues.
+                                   webBuilder.UseUrls("http://localhost:9999");
+                                   webBuilder.Configure(appBuilder =>
+                                   {
+                                       appBuilder.UseStaticFiles(new StaticFileOptions
+                                       {
+                                           FileProvider = this,
+                                           RequestPath = "/e2e",
+                                           ServeUnknownFileTypes = true,
+                                       });
+                                   });
+                               })
+                               .Build();
+            this.WebHost.Start();
+        }
+
+        public void Dispose()
+        {
+            var waitTime = TimeSpan.FromSeconds(5);
+            this.WebHost?.StopAsync(waitTime).Wait(waitTime);
+        }
+
+        public IDirectoryContents GetDirectoryContents(string subpath) => throw new NotImplementedException();
+
+        public IFileInfo GetFileInfo(string subpath)
+        {
+            if (this.PhysicalPathsByRelativeUrl.TryGetValue(subpath, out var filepath))
+            {
+                return new PhysicalFileInfo(new FileInfo(filepath));
+            }
+
+            return new NotFoundFileInfo(subpath);
+        }
+
+        public IChangeToken Watch(string filter) => throw new NotImplementedException();
+    }
+}
\ No newline at end of file
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/WixToolsetTest.BurnE2E.csproj b/src/test/burn/WixToolsetTest.BurnE2E/WixToolsetTest.BurnE2E.csproj
new file mode 100644
index 00000000..2aee1157
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/WixToolsetTest.BurnE2E.csproj
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. -->
+
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <PlatformTarget>x64</PlatformTarget>
+    <RollForward>Major</RollForward>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Content Include="runtests.cmd" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\WixTestTools\WixTestTools.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.Owin" Version="3.1.13" />
+    <PackageReference Include="Microsoft.Win32.Registry" Version="5.0.0" />
+    <PackageReference Include="System.Security.Principal.Windows" Version="5.0.0" />
+    <PackageReference Include="WixBuildTools.TestSupport" Version="4.0.50" />
+    <PackageReference Include="WixToolset.Data" Version="4.0.218" />
+    <PackageReference Include="WixToolset.Mba.Core" Version="4.0.58" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.3.0" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" PrivateAssets="All" />
+  </ItemGroup>
+</Project>
diff --git a/src/test/burn/WixToolsetTest.BurnE2E/runtests.cmd b/src/test/burn/WixToolsetTest.BurnE2E/runtests.cmd
new file mode 100644
index 00000000..4c6dc8ee
--- /dev/null
+++ b/src/test/burn/WixToolsetTest.BurnE2E/runtests.cmd
@@ -0,0 +1,2 @@
+SET RuntimeTestsEnabled=true
+dotnet test WixToolsetTest.BurnE2E.dll -v normal
\ No newline at end of file