Merge Integration

12 files changed, 2132 insertions, 0 deletions

diff --git a/src/test/burn/WixTestTools/BundleInstaller.cs b/src/test/burn/WixTestTools/BundleInstaller.cs
new file mode 100644
index 00000000..a49c4024
--- /dev/null
+++ b/src/test/burn/WixTestTools/BundleInstaller.cs
@@ -0,0 +1,197 @@
+// 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 WixTestTools
+{
+    using System;
+    using System.IO;
+    using System.Text;
+
+    public partial class BundleInstaller : IDisposable
+    {
+        public BundleInstaller(WixTestContext testContext, string name)
+        {
+            this.Bundle = Path.Combine(testContext.TestDataFolder, $"{name}.exe");
+            this.BundlePdb = Path.Combine(testContext.TestDataFolder, $"{name}.wixpdb");
+            this.TestContext = testContext;
+            this.TestGroupName = testContext.TestGroupName;
+            this.TestName = testContext.TestName;
+        }
+
+        public string Bundle { get; }
+
+        private WixTestContext TestContext { get; }
+
+        public string TestGroupName { get; }
+
+        public string TestName { get; }
+
+        /// <summary>
+        /// Installs the bundle with optional arguments.
+        /// </summary>
+        /// <param name="expectedExitCode">Expected exit code, defaults to success.</param>
+        /// <param name="arguments">Optional arguments to pass to the tool.</param>
+        /// <returns>Path to the generated log file.</returns>
+        public string Install(int expectedExitCode = (int)MSIExec.MSIExecReturnCode.SUCCESS, params string[] arguments)
+        {
+            return this.RunBundleWithArguments(expectedExitCode, MSIExec.MSIExecMode.Install, arguments);
+        }
+
+        /// <summary>
+        /// Installs the bundle with optional arguments.
+        /// </summary>
+        /// <param name="bundlePath">This should be the bundle in the package cache.</param>
+        /// <param name="expectedExitCode">Expected exit code, defaults to success.</param>
+        /// <param name="arguments">Optional arguments to pass to the tool.</param>
+        /// <returns>Path to the generated log file.</returns>
+        public string Install(string bundlePath, int expectedExitCode = (int)MSIExec.MSIExecReturnCode.SUCCESS, params string[] arguments)
+        {
+            return this.RunBundleWithArguments(expectedExitCode, MSIExec.MSIExecMode.Install, arguments, bundlePath: bundlePath);
+        }
+
+        /// <summary>
+        /// Calls Layout for the bundle with optional arguments.
+        /// </summary>
+        /// <param name="layoutDirectory">The destination directory.</param>
+        /// <param name="expectedExitCode">Expected exit code, defaults to success.</param>
+        /// <param name="arguments">Optional arguments to pass to the tool.</param>
+        /// <returns>Path to the generated log file.</returns>
+        public string Layout(string layoutDirectory, int expectedExitCode = (int)MSIExec.MSIExecReturnCode.SUCCESS, params string[] arguments)
+        {
+            return this.RunBundleWithArguments(expectedExitCode, MSIExec.MSIExecMode.AdministrativeInstall, arguments, layoutDirectory: layoutDirectory);
+        }
+
+        /// <summary>
+        /// Calls Layout for the bundle with optional arguments.
+        /// </summary>
+        /// <param name="bundlePath">Path to the bundle to run.</param>
+        /// <param name="layoutDirectory">The destination directory.</param>
+        /// <param name="expectedExitCode">Expected exit code, defaults to success.</param>
+        /// <param name="arguments">Optional arguments to pass to the tool.</param>
+        /// <returns>Path to the generated log file.</returns>
+        public string Layout(string bundlePath, string layoutDirectory, int expectedExitCode = (int)MSIExec.MSIExecReturnCode.SUCCESS, params string[] arguments)
+        {
+            return this.RunBundleWithArguments(expectedExitCode, MSIExec.MSIExecMode.AdministrativeInstall, arguments, bundlePath: bundlePath, layoutDirectory: layoutDirectory);
+        }
+
+        /// <summary>
+        /// Modify the bundle with optional arguments.
+        /// </summary>
+        /// <param name="expectedExitCode">Expected exit code, defaults to success.</param>
+        /// <param name="arguments">Optional arguments to pass to the tool.</param>
+        /// <returns>Path to the generated log file.</returns>
+        public string Modify(int expectedExitCode = (int)MSIExec.MSIExecReturnCode.SUCCESS, params string[] arguments)
+        {
+            return this.RunBundleWithArguments(expectedExitCode, MSIExec.MSIExecMode.Modify, arguments);
+        }
+
+        /// <summary>
+        /// Modify the bundle with optional arguments.
+        /// </summary>
+        /// <param name="bundlePath">This should be the bundle in the package cache.</param>
+        /// <param name="expectedExitCode">Expected exit code, defaults to success.</param>
+        /// <param name="arguments">Optional arguments to pass to the tool.</param>
+        /// <returns>Path to the generated log file.</returns>
+        public string Modify(string bundlePath, int expectedExitCode = (int)MSIExec.MSIExecReturnCode.SUCCESS, params string[] arguments)
+        {
+            return this.RunBundleWithArguments(expectedExitCode, MSIExec.MSIExecMode.Modify, arguments, bundlePath: bundlePath);
+        }
+
+        /// <summary>
+        /// Repairs the bundle with optional arguments.
+        /// </summary>
+        /// <param name="expectedExitCode">Expected exit code, defaults to success.</param>
+        /// <param name="arguments">Optional arguments to pass to the tool.</param>
+        /// <returns>Path to the generated log file.</returns>
+        public string Repair(int expectedExitCode = (int)MSIExec.MSIExecReturnCode.SUCCESS, params string[] arguments)
+        {
+            return this.RunBundleWithArguments(expectedExitCode, MSIExec.MSIExecMode.Repair, arguments);
+        }
+
+        /// <summary>
+        /// Uninstalls the bundle with optional arguments.
+        /// </summary>
+        /// <param name="expectedExitCode">Expected exit code, defaults to success.</param>
+        /// <param name="arguments">Optional arguments to pass to the tool.</param>
+        /// <returns>Path to the generated log file.</returns>
+        public string Uninstall(int expectedExitCode = (int)MSIExec.MSIExecReturnCode.SUCCESS, params string[] arguments)
+        {
+            return this.RunBundleWithArguments(expectedExitCode, MSIExec.MSIExecMode.Uninstall, arguments);
+        }
+
+        /// <summary>
+        /// Uninstalls the bundle at the given path with optional arguments.
+        /// </summary>
+        /// <param name="bundlePath">This should be the bundle in the package cache.</param>
+        /// <param name="expectedExitCode">Expected exit code, defaults to success.</param>
+        /// <param name="arguments">Optional arguments to pass to the tool.</param>
+        /// <returns>Path to the generated log file.</returns>
+        public string Uninstall(string bundlePath, int expectedExitCode = (int)MSIExec.MSIExecReturnCode.SUCCESS, params string[] arguments)
+        {
+            return this.RunBundleWithArguments(expectedExitCode, MSIExec.MSIExecMode.Uninstall, arguments, bundlePath: bundlePath);
+        }
+
+        /// <summary>
+        /// Executes the bundle with optional arguments.
+        /// </summary>
+        /// <param name="expectedExitCode">Expected exit code.</param>
+        /// <param name="mode">Install mode.</param>
+        /// <param name="arguments">Optional arguments to pass to the tool.</param>
+        /// <returns>Path to the generated log file.</returns>
+        private string RunBundleWithArguments(int expectedExitCode, MSIExec.MSIExecMode mode, string[] arguments, bool assertOnError = true, string bundlePath = null, string layoutDirectory = null)
+        {
+            TestTool bundle = new TestTool(bundlePath ?? this.Bundle);
+            var sb = new StringBuilder();
+
+            // Be sure to run silent.
+            sb.Append(" -quiet");
+            
+            // Generate the log file name.
+            string logFile = Path.Combine(Path.GetTempPath(), String.Format("{0}_{1}_{2:yyyyMMddhhmmss}_{4}_{3}.log", this.TestGroupName, this.TestName, DateTime.UtcNow, Path.GetFileNameWithoutExtension(this.Bundle), mode));
+            sb.AppendFormat(" -log \"{0}\"", logFile);
+
+            // Set operation.
+            switch (mode)
+            {
+                case MSIExec.MSIExecMode.AdministrativeInstall:
+                    sb.Append($" -layout \"{layoutDirectory}\"");
+                    break;
+
+                case MSIExec.MSIExecMode.Modify:
+                    sb.Append(" -modify");
+                    break;
+
+                case MSIExec.MSIExecMode.Repair:
+                    sb.Append(" -repair");
+                    break;
+
+                case MSIExec.MSIExecMode.Cleanup:
+                case MSIExec.MSIExecMode.Uninstall:
+                    sb.Append(" -uninstall");
+                    break;
+            }
+
+            // Add additional arguments.
+            if (null != arguments)
+            {
+                sb.Append(" ");
+                sb.Append(String.Join(" ", arguments));
+            }
+
+            // Set the arguments.
+            bundle.Arguments = sb.ToString();
+
+            // Run the tool and assert the expected code.
+            bundle.ExpectedExitCode = expectedExitCode;
+            bundle.Run(assertOnError);
+
+            // Return the log file name.
+            return logFile;
+        }
+
+        public void Dispose()
+        {
+            string[] args = { "-burn.ignoredependencies=ALL" };
+            this.RunBundleWithArguments((int)MSIExec.MSIExecReturnCode.SUCCESS, MSIExec.MSIExecMode.Cleanup, args, assertOnError: false);
+        }
+    }
+}
diff --git a/src/test/burn/WixTestTools/BundleRegistration.cs b/src/test/burn/WixTestTools/BundleRegistration.cs
new file mode 100644
index 00000000..75660838
--- /dev/null
+++ b/src/test/burn/WixTestTools/BundleRegistration.cs
@@ -0,0 +1,182 @@
+// 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 WixTestTools
+{
+    using System;
+    using Microsoft.Win32;
+
+    public class BundleRegistration
+    {
+        public const string BURN_REGISTRATION_REGISTRY_UNINSTALL_KEY = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall";
+        public const string BURN_REGISTRATION_REGISTRY_UNINSTALL_KEY_WOW6432NODE = "SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall";
+        public const string BURN_REGISTRATION_REGISTRY_BUNDLE_CACHE_PATH = "BundleCachePath";
+        public const string BURN_REGISTRATION_REGISTRY_BUNDLE_ADDON_CODE = "BundleAddonCode";
+        public const string BURN_REGISTRATION_REGISTRY_BUNDLE_DETECT_CODE = "BundleDetectCode";
+        public const string BURN_REGISTRATION_REGISTRY_BUNDLE_PATCH_CODE = "BundlePatchCode";
+        public const string BURN_REGISTRATION_REGISTRY_BUNDLE_UPGRADE_CODE = "BundleUpgradeCode";
+        public const string BURN_REGISTRATION_REGISTRY_BUNDLE_DISPLAY_NAME = "DisplayName";
+        public const string BURN_REGISTRATION_REGISTRY_BUNDLE_VERSION = "BundleVersion";
+        public const string BURN_REGISTRATION_REGISTRY_ENGINE_VERSION = "EngineVersion";
+        public const string BURN_REGISTRATION_REGISTRY_BUNDLE_PROVIDER_KEY = "BundleProviderKey";
+        public const string BURN_REGISTRATION_REGISTRY_BUNDLE_TAG = "BundleTag";
+        public const string REGISTRY_REBOOT_PENDING_FORMAT = "{0}.RebootRequired";
+        public const string REGISTRY_BUNDLE_INSTALLED = "Installed";
+        public const string REGISTRY_BUNDLE_DISPLAY_ICON = "DisplayIcon";
+        public const string REGISTRY_BUNDLE_DISPLAY_VERSION = "DisplayVersion";
+        public const string REGISTRY_BUNDLE_ESTIMATED_SIZE = "EstimatedSize";
+        public const string REGISTRY_BUNDLE_PUBLISHER = "Publisher";
+        public const string REGISTRY_BUNDLE_HELP_LINK = "HelpLink";
+        public const string REGISTRY_BUNDLE_HELP_TELEPHONE = "HelpTelephone";
+        public const string REGISTRY_BUNDLE_URL_INFO_ABOUT = "URLInfoAbout";
+        public const string REGISTRY_BUNDLE_URL_UPDATE_INFO = "URLUpdateInfo";
+        public const string REGISTRY_BUNDLE_PARENT_DISPLAY_NAME = "ParentDisplayName";
+        public const string REGISTRY_BUNDLE_PARENT_KEY_NAME = "ParentKeyName";
+        public const string REGISTRY_BUNDLE_COMMENTS = "Comments";
+        public const string REGISTRY_BUNDLE_CONTACT = "Contact";
+        public const string REGISTRY_BUNDLE_NO_MODIFY = "NoModify";
+        public const string REGISTRY_BUNDLE_MODIFY_PATH = "ModifyPath";
+        public const string REGISTRY_BUNDLE_NO_ELEVATE_ON_MODIFY = "NoElevateOnModify";
+        public const string REGISTRY_BUNDLE_NO_REMOVE = "NoRemove";
+        public const string REGISTRY_BUNDLE_SYSTEM_COMPONENT = "SystemComponent";
+        public const string REGISTRY_BUNDLE_QUIET_UNINSTALL_STRING = "QuietUninstallString";
+        public const string REGISTRY_BUNDLE_UNINSTALL_STRING = "UninstallString";
+        public const string REGISTRY_BUNDLE_RESUME_COMMAND_LINE = "BundleResumeCommandLine";
+        public const string REGISTRY_BUNDLE_VERSION_MAJOR = "VersionMajor";
+        public const string REGISTRY_BUNDLE_VERSION_MINOR = "VersionMinor";
+
+        public string[] AddonCodes { get; set; }
+
+        public string CachePath { get; set; }
+
+        public string DisplayName { get; set; }
+
+        public string[] DetectCodes { get; set; }
+
+        public string EngineVersion { get; set; }
+
+        public int? EstimatedSize { get; set; }
+
+        public int? Installed { get; set; }
+
+        public string ModifyPath { get; set; }
+
+        public string[] PatchCodes { get; set; }
+
+        public string ProviderKey { get; set; }
+
+        public string Publisher { get; set; }
+
+        public string QuietUninstallString { get; set; }
+
+        public string QuietUninstallCommand { get; set; }
+
+        public string QuietUninstallCommandArguments { get; set; }
+
+        public string Tag { get; set; }
+
+        public string UninstallCommand { get; set; }
+
+        public string UninstallCommandArguments { get; set; }
+
+        public string UninstallString { get; set; }
+
+        public string[] UpgradeCodes { get; set; }
+
+        public string UrlInfoAbout { get; set; }
+
+        public string UrlUpdateInfo { get; set; }
+
+        public string Version { get; set; }
+
+        public static bool TryGetPerMachineBundleRegistrationById(string bundleId, bool x64, out BundleRegistration registration)
+        {
+            var baseKeyPath = x64 ? BURN_REGISTRATION_REGISTRY_UNINSTALL_KEY : BURN_REGISTRATION_REGISTRY_UNINSTALL_KEY_WOW6432NODE;
+            var registrationKeyPath = $"{baseKeyPath}\\{bundleId}";
+            using var registrationKey = Registry.LocalMachine.OpenSubKey(registrationKeyPath);
+            var success = registrationKey != null;
+            registration = success ? GetBundleRegistration(registrationKey) : null;
+            return success;
+        }
+
+        public static bool TryGetPerUserBundleRegistrationById(string bundleId, out BundleRegistration registration)
+        {
+            var registrationKeyPath = $"{BURN_REGISTRATION_REGISTRY_UNINSTALL_KEY}\\{bundleId}";
+            using var registrationKey = Registry.CurrentUser.OpenSubKey(registrationKeyPath);
+            var success = registrationKey != null;
+            registration = success ? GetBundleRegistration(registrationKey) : null;
+            return success;
+        }
+
+        private static BundleRegistration GetBundleRegistration(RegistryKey idKey)
+        {
+            var registration = new BundleRegistration();
+
+            registration.AddonCodes = idKey.GetValue(BURN_REGISTRATION_REGISTRY_BUNDLE_ADDON_CODE) as string[];
+            registration.CachePath = idKey.GetValue(BURN_REGISTRATION_REGISTRY_BUNDLE_CACHE_PATH) as string;
+            registration.DetectCodes = idKey.GetValue(BURN_REGISTRATION_REGISTRY_BUNDLE_DETECT_CODE) as string[];
+            registration.PatchCodes = idKey.GetValue(BURN_REGISTRATION_REGISTRY_BUNDLE_PATCH_CODE) as string[];
+            registration.ProviderKey = idKey.GetValue(BURN_REGISTRATION_REGISTRY_BUNDLE_PROVIDER_KEY) as string;
+            registration.Tag = idKey.GetValue(BURN_REGISTRATION_REGISTRY_BUNDLE_TAG) as string;
+            registration.UpgradeCodes = idKey.GetValue(BURN_REGISTRATION_REGISTRY_BUNDLE_UPGRADE_CODE) as string[];
+            registration.Version = idKey.GetValue(BURN_REGISTRATION_REGISTRY_BUNDLE_VERSION) as string;
+            registration.DisplayName = idKey.GetValue(BURN_REGISTRATION_REGISTRY_BUNDLE_DISPLAY_NAME) as string;
+            registration.EngineVersion = idKey.GetValue(BURN_REGISTRATION_REGISTRY_ENGINE_VERSION) as string;
+            registration.EstimatedSize = idKey.GetValue(REGISTRY_BUNDLE_ESTIMATED_SIZE) as int?;
+            registration.Installed = idKey.GetValue(REGISTRY_BUNDLE_INSTALLED) as int?;
+            registration.ModifyPath = idKey.GetValue(REGISTRY_BUNDLE_MODIFY_PATH) as string;
+            registration.Publisher = idKey.GetValue(REGISTRY_BUNDLE_PUBLISHER) as string;
+            registration.UrlInfoAbout = idKey.GetValue(REGISTRY_BUNDLE_URL_INFO_ABOUT) as string;
+            registration.UrlUpdateInfo = idKey.GetValue(REGISTRY_BUNDLE_URL_UPDATE_INFO) as string;
+
+            registration.QuietUninstallString = idKey.GetValue(REGISTRY_BUNDLE_QUIET_UNINSTALL_STRING) as string;
+            if (!String.IsNullOrEmpty(registration.QuietUninstallString))
+            {
+                var closeQuote = registration.QuietUninstallString.IndexOf("\"", 1);
+                if (closeQuote > 0)
+                {
+                    registration.QuietUninstallCommand = registration.QuietUninstallString.Substring(1, closeQuote - 1).Trim();
+                    registration.QuietUninstallCommandArguments = registration.QuietUninstallString.Substring(closeQuote + 1).Trim();
+                }
+            }
+
+            registration.UninstallString = idKey.GetValue(REGISTRY_BUNDLE_UNINSTALL_STRING) as string;
+            if (!String.IsNullOrEmpty(registration.UninstallString))
+            {
+                var closeQuote = registration.UninstallString.IndexOf("\"", 1);
+                if (closeQuote > 0)
+                {
+                    registration.UninstallCommand = registration.UninstallString.Substring(1, closeQuote - 1).Trim();
+                    registration.UninstallCommandArguments = registration.UninstallString.Substring(closeQuote + 1).Trim();
+                }
+            }
+
+            return registration;
+        }
+
+        public static bool TryGetDependencyProviderValue(string providerId, string name, out string value)
+        {
+            value = null;
+
+            string key = String.Format(@"Installer\Dependencies\{0}", providerId);
+            using (RegistryKey providerKey = Registry.ClassesRoot.OpenSubKey(key))
+            {
+                if (null == providerKey)
+                {
+                    return false;
+                }
+
+                value = providerKey.GetValue(name) as string;
+                return value != null;
+            }
+        }
+
+        public static bool DependencyDependentExists(string providerId, string dependentId)
+        {
+            string key = String.Format(@"Installer\Dependencies\{0}\Dependents\{1}", providerId, dependentId);
+            using (RegistryKey dependentKey = Registry.ClassesRoot.OpenSubKey(key))
+            {
+                return null != dependentKey;
+            }
+        }
+    }
+}
diff --git a/src/test/burn/WixTestTools/BundleVerifier.cs b/src/test/burn/WixTestTools/BundleVerifier.cs
new file mode 100644
index 00000000..984df169
--- /dev/null
+++ b/src/test/burn/WixTestTools/BundleVerifier.cs
@@ -0,0 +1,156 @@
+// 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 WixTestTools
+{
+    using System;
+    using System.IO;
+    using System.Linq;
+    using System.Text;
+    using Microsoft.Win32;
+    using WixToolset.Data;
+    using WixToolset.Data.Symbols;
+    using Xunit;
+
+    public partial class BundleInstaller
+    {
+        public const string FULL_BURN_POLICY_REGISTRY_PATH = "SOFTWARE\\WOW6432Node\\Policies\\WiX\\Burn";
+        public const string PACKAGE_CACHE_FOLDER_NAME = "Package Cache";
+
+        public string BundlePdb { get; }
+
+        private WixBundleSymbol BundleSymbol { get; set; }
+
+        private WixBundleSymbol GetBundleSymbol()
+        {
+            if (this.BundleSymbol == null)
+            {
+                using var wixOutput = WixOutput.Read(this.BundlePdb);
+                var intermediate = Intermediate.Load(wixOutput);
+                var section = intermediate.Sections.Single();
+                this.BundleSymbol = section.Symbols.OfType<WixBundleSymbol>().Single();
+            }
+
+            return this.BundleSymbol;
+        }
+
+        public string GetPackageCachePathForCacheId(string cacheId, bool perMachine)
+        {
+            string cachePath;
+            if (perMachine)
+            {
+                using var policyKey = Registry.LocalMachine.OpenSubKey(FULL_BURN_POLICY_REGISTRY_PATH);
+                var redirectedCachePath = policyKey?.GetValue("PackageCache") as string;
+                cachePath = redirectedCachePath ?? Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), PACKAGE_CACHE_FOLDER_NAME);
+            }
+            else
+            {
+                cachePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), PACKAGE_CACHE_FOLDER_NAME);
+            }
+            return Path.Combine(cachePath, cacheId);
+        }
+
+        public string GetExpectedCachedBundlePath()
+        {
+            var bundleSymbol = this.GetBundleSymbol();
+            var cachePath = this.GetPackageCachePathForCacheId(bundleSymbol.BundleId, bundleSymbol.PerMachine);
+            return Path.Combine(cachePath, Path.GetFileName(this.Bundle));
+        }
+
+        public string ManuallyCache()
+        {
+            var expectedCachePath = this.GetExpectedCachedBundlePath();
+            Directory.CreateDirectory(Path.GetDirectoryName(expectedCachePath));
+            File.Copy(this.Bundle, expectedCachePath);
+            return expectedCachePath;
+        }
+
+        public void ManuallyUncache()
+        {
+            var expectedCachePath = this.GetExpectedCachedBundlePath();
+            File.Delete(expectedCachePath);
+        }
+
+        public bool TryGetRegistration(out BundleRegistration registration)
+        {
+            var bundleSymbol = this.GetBundleSymbol();
+            var x64 = bundleSymbol.Platform != Platform.X86;
+            var bundleId = bundleSymbol.BundleId;
+            if (bundleSymbol.PerMachine)
+            {
+                return BundleRegistration.TryGetPerMachineBundleRegistrationById(bundleId, x64, out registration);
+            }
+            else
+            {
+                return BundleRegistration.TryGetPerUserBundleRegistrationById(bundleId, out registration);
+            }
+        }
+
+        public string VerifyRegisteredAndInPackageCache()
+        {
+            Assert.True(this.TryGetRegistration(out var registration));
+
+            Assert.NotNull(registration.CachePath);
+            Assert.True(File.Exists(registration.CachePath));
+
+            var expectedCachePath = this.GetExpectedCachedBundlePath();
+            Assert.Equal(expectedCachePath, registration.CachePath, StringComparer.OrdinalIgnoreCase);
+
+            return registration.CachePath;
+        }
+
+        public void VerifyUnregisteredAndRemovedFromPackageCache()
+        {
+            var cachedBundlePath = this.GetExpectedCachedBundlePath();
+            this.VerifyUnregisteredAndRemovedFromPackageCache(cachedBundlePath);
+        }
+
+        public void VerifyUnregisteredAndRemovedFromPackageCache(string cachedBundlePath)
+        {
+            Assert.False(this.TryGetRegistration(out _));
+            Assert.False(File.Exists(cachedBundlePath));
+        }
+
+        public void RemovePackageFromCache(string packageId)
+        {
+            using var wixOutput = WixOutput.Read(this.BundlePdb);
+            var intermediate = Intermediate.Load(wixOutput);
+            var section = intermediate.Sections.Single();
+            var packageSymbol = section.Symbols.OfType<WixBundlePackageSymbol>().Single(p => p.Id.Id == packageId);
+            var cachePath = this.GetPackageCachePathForCacheId(packageSymbol.CacheId, packageSymbol.PerMachine == YesNoDefaultType.Yes);
+            if (Directory.Exists(cachePath))
+            {
+                Directory.Delete(cachePath, true);
+            }
+        }
+
+        public void VerifyPackageIsCached(string packageId)
+        {
+            using var wixOutput = WixOutput.Read(this.BundlePdb);
+            var intermediate = Intermediate.Load(wixOutput);
+            var section = intermediate.Sections.Single();
+            var packageSymbol = section.Symbols.OfType<WixBundlePackageSymbol>().Single(p => p.Id.Id == packageId);
+            var cachePath = this.GetPackageCachePathForCacheId(packageSymbol.CacheId, packageSymbol.PerMachine == YesNoDefaultType.Yes);
+            Assert.True(Directory.Exists(cachePath));
+        }
+
+        public void VerifyExeTestRegistryRootDeleted(string name, bool x64 = false)
+        {
+            using var testRegistryRoot = this.TestContext.GetTestRegistryRoot(x64, name);
+            if (testRegistryRoot != null)
+            {
+                var actualValue = testRegistryRoot.GetValue("Version") as string;
+                Assert.Null(actualValue);
+            }
+        }
+
+        public void VerifyExeTestRegistryValue(string name, string expectedValue, bool x64 = false)
+        {
+            using (var root = this.TestContext.GetTestRegistryRoot(x64, name))
+            {
+                Assert.NotNull(root);
+                var actualValue = root.GetValue("Version") as string;
+                Assert.Equal(expectedValue, actualValue);
+            }
+        }
+    }
+}
diff --git a/src/test/burn/WixTestTools/LogVerifier.cs b/src/test/burn/WixTestTools/LogVerifier.cs
new file mode 100644
index 00000000..0252a9f9
--- /dev/null
+++ b/src/test/burn/WixTestTools/LogVerifier.cs
@@ -0,0 +1,252 @@
+// 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 WixTestTools
+{
+    using System;
+    using System.IO;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using Xunit;
+
+    /// <summary>
+    /// The LogVerifier can verify a log file for given regular expressions.
+    /// </summary>
+    public class LogVerifier
+    {
+        // Member Variables
+        private string logFile;
+
+        /// <summary>
+        /// Prevent creation of LogVerifier without log file
+        /// </summary>
+        private LogVerifier()
+        { }
+
+        /// <summary>
+        /// Constructor for log files where the exact file name is known.
+        /// </summary>
+        /// <param name="fileName">The full path to the log file</param>
+        public LogVerifier(string fileName)
+        {
+            if (null == fileName)
+                throw new ArgumentNullException("fileName");
+
+            if (!File.Exists(fileName))
+                throw new ArgumentException(String.Format(@"File doesn't exist:{0}", fileName), "fileName");
+
+            logFile = fileName;
+        }
+
+        /// <summary>
+        /// Constructor for log files where the exact file name is known.
+        /// </summary>
+        /// <param name="directory">The directory in which the log file is located.</param>
+        /// <param name="fileName">The name of the log file.</param>
+        public LogVerifier(string directory, string fileName)
+            : this(Path.Combine(directory, fileName))
+        { }
+
+        /// <summary>
+        /// Scans a log file line by line until the regex pattern is matched or eof is reached.
+        /// This method would be used in the case where the log file is very large, the regex doesn't
+        /// span multiple lines, and only one match is required.
+        /// </summary>
+        /// <param name="regex">A regular expression</param>
+        /// <returns>True if a match is found, False otherwise.</returns>
+        public bool LineByLine(Regex regex)
+        {
+            string line = string.Empty;
+            StreamReader sr = new StreamReader(logFile);
+
+            // Read from a file stream line by line.
+            while ((line = sr.ReadLine()) != null)
+            {
+                if (regex.Match(line).Success)
+                {
+                    sr.Close();
+                    sr.Dispose();
+                    return true;
+                }
+            }
+            return false;
+        }
+
+
+        /// <summary>
+        /// Scans a log file line by line until the regex pattern is matched or eof is reached.
+        /// This method would be used in the case where the log file is very large, the regex doesn't
+        /// span multiple lines, and only one match is required.
+        /// No RegexOptions are used and matches are case sensitive.
+        /// </summary>
+        /// <param name="regex">A regular expression string.</param>
+        /// <returns>True if a match is found, False otherwise.</returns>
+        public bool LineByLine(string regex)
+        {
+            return LineByLine(new Regex(regex));
+        }
+
+
+        /// <summary>
+        /// Scans a log file for matches to the regex.
+        /// </summary>
+        /// <param name="regex">A regular expression</param>
+        /// <returns>The number of matches</returns>
+        public int EntireFileAtOnce(Regex regex)
+        {
+            string logFileText = this.ReadLogFile();
+            return regex.Matches(logFileText).Count;
+        }
+
+        /// <summary>
+        /// Scans a log file for matches to the regex.
+        /// </summary>
+        /// <param name="regex">A regular expression</param>
+        /// <returns>The number of matches</returns>
+        public bool EntireFileAtOncestr(string regex)
+        {
+            string logFileText = this.ReadLogFile();
+            return logFileText.Contains(regex);
+        }
+        /// <summary>
+        /// Scans a log file for matches to the regex string.
+        /// Only the Multiline RegexOption is used and matches are case sensitive.
+        /// </summary>
+        /// <param name="regex">A regular expression</param>
+        /// <returns>The number of matches</returns>
+        public int EntireFileAtOnce(string regex)
+        {
+            return EntireFileAtOnce(new Regex(regex, RegexOptions.Multiline));
+        }
+
+        /// <summary>
+        /// Scans a log file for matches to the regex string.
+        /// </summary>
+        /// <param name="regex">A regular expression</param>
+        /// <param name="ignoreCase">Specify whether to perform case sensitive matches</param>
+        /// <returns>The number of matches</returns>
+        public int EntireFileAtOnce(string regex, bool ignoreCase)
+        {
+            if (!ignoreCase)
+                return EntireFileAtOnce(new Regex(regex, RegexOptions.Multiline));
+            else
+                return EntireFileAtOnce(new Regex(regex, RegexOptions.Multiline | RegexOptions.IgnoreCase));
+        }
+
+        /// <summary>
+        /// Search through the log and Assert.Fail() if a specified string is not found.
+        /// </summary>
+        /// <param name="regex">Search expression</param>
+        /// <param name="ignoreCase">Perform case insensitive match</param>
+        public void AssertTextInLog(string regex, bool ignoreCase)
+        {
+            Assert.True(EntireFileAtOncestr(regex),
+                String.Format("The log does not contain a match to the regular expression \"{0}\" ", regex));
+        }
+
+        /// <summary>
+        /// Search through the log and Assert.Fail() if a specified string is not found.
+        /// </summary>
+        /// <param name="regex">Search expression</param>
+        /// <param name="ignoreCase">Perform case insensitive match</param>
+        public void AssertTextInLog(Regex regex, bool ignoreCase)
+        {
+            Assert.True(EntireFileAtOnce(regex) >= 1,
+                String.Format("The log does not contain a match to the regular expression \"{0}\" ", regex.ToString()));
+        }
+
+        /// <summary>
+        /// Search through the log and Assert.Fail() if a specified string is not found.
+        /// </summary>
+        /// <param name="regex">Search expression</param>
+        /// <param name="ignoreCase">Perform case insensitive match</param>
+        public void AssertTextInLog(string regex)
+        {
+            AssertTextInLog(regex, true);
+        }
+
+        /// <summary>
+        /// Search through the log and Assert.Fail() if a specified string is not found.
+        /// </summary>
+        /// <param name="regex">Search expression</param>
+        /// <param name="ignoreCase">Perform case insensitive match</param>
+        public void AssertTextInLog(Regex regex)
+        {
+            AssertTextInLog(regex, true);
+        }
+
+
+        /// <summary>
+        /// Search through the log and Assert.Fail() if a specified string is  found.
+        /// </summary>
+        /// <param name="regex">Search expression</param>
+        /// <param name="ignoreCase">Perform case insensitive match</param>
+        public void AssertTextNotInLog(Regex regex, bool ignoreCase)
+        {
+            Assert.True(EntireFileAtOnce(regex) < 1,
+                String.Format("The log contain a match to the regular expression \"{0}\" ", regex.ToString()));
+        }
+
+        /// <summary>
+        /// Search through the log and Assert.Fail() if a specified string is not found.
+        /// </summary>
+        /// <param name="regex">Search expression</param>
+        /// <param name="ignoreCase">Perform case insensitive match</param>
+        public void AssertTextNotInLog(string regex, bool ignoreCase)
+        {
+            Assert.False(EntireFileAtOncestr(regex),
+                String.Format("The log does not contain a match to the regular expression \"{0}\" ", regex));
+        }
+
+        /// <summary>
+        /// Checks if a meesage is in a file
+        /// </summary>
+        /// <param name="logFileName">The full path to the log file</param>
+        /// <param name="message">Search expression</param>
+        /// <returns>True if the message was found, false otherwise</returns>
+        public static bool MessageInLogFile(string logFileName, string message)
+        {
+            LogVerifier logVerifier = new LogVerifier(logFileName);
+            return logVerifier.EntireFileAtOncestr(message);
+        }
+
+        /// <summary>
+        /// Checks if a meesage is in a file
+        /// </summary>
+        /// <param name="logFileName">The full path to the log file</param>
+        /// <param name="message">Search expression (regex)</param>
+        /// <returns>True if the message was found, false otherwise</returns>
+        public static bool MessageInLogFileRegex(string logFileName, string regexMessage)
+        {
+            LogVerifier logVerifier = new LogVerifier(logFileName);
+            return logVerifier.EntireFileAtOnce(regexMessage) > 0;
+        }
+
+        /// <summary>
+        /// Read in the entire log file at once.
+        /// </summary>
+        /// <returns>Contents of log file.</returns>
+        private string ReadLogFile()
+        {
+            // Retry a few times.
+            for (int retry = 0; ; ++retry)
+            {
+                try
+                {
+                    using (StreamReader sr = new StreamReader(this.logFile))
+                    {
+                        return sr.ReadToEnd();
+                    }
+                }
+                catch // we'll catch everything a few times until we give up.
+                {
+                    if (retry > 4)
+                    {
+                        throw;
+                    }
+
+                    System.Threading.Thread.Sleep(1000);
+                }
+            }
+        }
+    }
+}
diff --git a/src/test/burn/WixTestTools/MSIExec.cs b/src/test/burn/WixTestTools/MSIExec.cs
new file mode 100644
index 00000000..8dce96cf
--- /dev/null
+++ b/src/test/burn/WixTestTools/MSIExec.cs
@@ -0,0 +1,753 @@
+// 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 WixTestTools
+{
+    using System;
+    using System.IO;
+    using System.Text;
+    using WixBuildTools.TestSupport;
+
+    public class MSIExec : TestTool
+    {
+        /// <summary>
+        /// The expected exit code of the tool
+        /// </summary>
+        public new MSIExecReturnCode ExpectedExitCode
+        {
+            get { return (MSIExecReturnCode)base.ExpectedExitCode; }
+            set { base.ExpectedExitCode = (int?)value; }
+        }
+
+        /// <summary>
+        /// Mode of execution (install, uninstall, or repair)
+        /// </summary>
+        public MSIExecMode ExecutionMode { get; set; }
+
+        /// <summary>
+        /// Path to msi or ProductCode
+        /// </summary>
+        public string Product { get; set; }
+
+        /// <summary>
+        /// Logging Options
+        /// </summary>
+        public MSIExecLoggingOptions LoggingOptions { get; set; }
+
+        /// <summary>
+        /// Path to the log file
+        /// </summary>
+        public string LogFile { get; set; }
+
+        /// <summary>
+        /// Unattended mode - progress bar only
+        /// </summary>
+        public bool Passive { get; set; }
+
+        /// <summary>
+        /// Quiet mode, no user interaction
+        /// </summary>
+        public bool Quiet { get; set; }
+
+        /// <summary>
+        /// Sets user interface level
+        /// </summary>
+        public MSIExecUserInterfaceLevel UserInterfaceLevel { get; set; }
+
+        /// <summary>
+        /// Do not restart after the installation is complete
+        /// </summary>
+        public bool NoRestart { get; set; }
+
+        /// <summary>
+        /// Prompts the user for restart if necessary
+        /// </summary>
+        public bool PromptRestart { get; set; }
+
+        /// <summary>
+        /// Always restart the computer after installation
+        /// </summary>
+        public bool ForceRestart { get; set; }
+
+        /// <summary>
+        /// Other arguments.
+        /// </summary>
+        public string OtherArguments { get; set; }
+
+        /// <summary>
+        /// Constructor that uses the default location for MSIExec.
+        /// </summary>
+        public MSIExec()
+            : this(Environment.SystemDirectory)
+        {
+        }
+
+        /// <summary>
+        /// Constructor that accepts a path to the MSIExec location.
+        /// </summary>
+        /// <param name="toolDirectory">The directory of MSIExec.exe.</param>
+        public MSIExec(string toolDirectory)
+            : base(Path.Combine(toolDirectory, "MSIExec.exe"))
+        {
+            this.SetDefaultArguments();
+        }
+
+        public override ExternalExecutableResult Run(bool assertOnError)
+        {
+            this.Arguments = this.GetArguments();
+            return base.Run(assertOnError);
+        }
+
+        /// <summary>
+        /// Clears all of the assigned arguments and resets them to the default values.
+        /// </summary>
+        public void SetDefaultArguments()
+        {
+            this.ExecutionMode = MSIExecMode.Install;
+            this.Product = String.Empty;
+            this.Quiet = true;
+            this.Passive = false;
+            this.UserInterfaceLevel = MSIExecUserInterfaceLevel.None;
+            this.NoRestart = true;
+            this.ForceRestart = false;
+            this.PromptRestart = false;
+            this.LogFile = string.Empty;
+            this.LoggingOptions = MSIExecLoggingOptions.VOICEWARMUP;
+            this.OtherArguments = String.Empty;
+        }
+
+        public string GetArguments()
+        {
+            var arguments = new StringBuilder();
+
+            // quiet
+            if (this.Quiet)
+            {
+                arguments.Append(" /quiet ");
+            }
+
+            // passive
+            if (this.Passive)
+            {
+                arguments.Append(" /passive ");
+            }
+
+            // UserInterfaceLevel
+            switch (this.UserInterfaceLevel)
+            {
+                case MSIExecUserInterfaceLevel.None:
+                    arguments.Append(" /qn ");
+                    break;
+                case MSIExecUserInterfaceLevel.Basic:
+                    arguments.Append(" /qb ");
+                    break;
+                case MSIExecUserInterfaceLevel.Reduced:
+                    arguments.Append(" /qr ");
+                    break;
+                case MSIExecUserInterfaceLevel.Full:
+                    arguments.Append(" /qf ");
+                    break;
+            }
+
+            // NoRestart
+            if (this.NoRestart)
+            {
+                arguments.Append(" /norestart ");
+            }
+
+            // PromptRestart
+            if (this.PromptRestart)
+            {
+                arguments.Append(" /promptrestart ");
+            }
+
+            // ForceRestart
+            if (this.ForceRestart)
+            {
+                arguments.Append(" /forcerestart ");
+            }
+
+            // Logging options
+            var loggingOptionsString = new StringBuilder();
+            if ((this.LoggingOptions & MSIExecLoggingOptions.Status_Messages) == MSIExecLoggingOptions.Status_Messages)
+            {
+                loggingOptionsString.Append("i");
+            }
+            if ((this.LoggingOptions & MSIExecLoggingOptions.Nonfatal_Warnings) == MSIExecLoggingOptions.Nonfatal_Warnings)
+            {
+                loggingOptionsString.Append("w");
+            }
+            if ((this.LoggingOptions & MSIExecLoggingOptions.All_Error_Messages) == MSIExecLoggingOptions.All_Error_Messages)
+            {
+                loggingOptionsString.Append("e");
+            }
+            if ((this.LoggingOptions & MSIExecLoggingOptions.Start_Up_Of_Actions) == MSIExecLoggingOptions.Start_Up_Of_Actions)
+            {
+                loggingOptionsString.Append("a");
+            }
+            if ((this.LoggingOptions & MSIExecLoggingOptions.Action_Specific_Records) == MSIExecLoggingOptions.Action_Specific_Records)
+            {
+                loggingOptionsString.Append("r");
+            }
+            if ((this.LoggingOptions & MSIExecLoggingOptions.User_Requests) == MSIExecLoggingOptions.User_Requests)
+            {
+                loggingOptionsString.Append("u");
+            }
+            if ((this.LoggingOptions & MSIExecLoggingOptions.Initial_UI_Parameters) == MSIExecLoggingOptions.Initial_UI_Parameters)
+            {
+                loggingOptionsString.Append("c");
+            }
+            if ((this.LoggingOptions & MSIExecLoggingOptions.OutOfMemory_Or_Fatal_Exit_Information) == MSIExecLoggingOptions.OutOfMemory_Or_Fatal_Exit_Information)
+            {
+                loggingOptionsString.Append("m");
+            }
+            if ((this.LoggingOptions & MSIExecLoggingOptions.OutOfDiskSpace_Messages) == MSIExecLoggingOptions.OutOfDiskSpace_Messages)
+            {
+                loggingOptionsString.Append("o");
+            }
+            if ((this.LoggingOptions & MSIExecLoggingOptions.Terminal_Properties) == MSIExecLoggingOptions.Terminal_Properties)
+            {
+                loggingOptionsString.Append("p");
+            }
+            if ((this.LoggingOptions & MSIExecLoggingOptions.Verbose_Output) == MSIExecLoggingOptions.Verbose_Output)
+            {
+                loggingOptionsString.Append("v");
+            }
+            if ((this.LoggingOptions & MSIExecLoggingOptions.Extra_Debugging_Information) == MSIExecLoggingOptions.Extra_Debugging_Information)
+            {
+                loggingOptionsString.Append("x");
+            }
+            if ((this.LoggingOptions & MSIExecLoggingOptions.Append_To_Existing_Log_File) == MSIExecLoggingOptions.Append_To_Existing_Log_File)
+            {
+                loggingOptionsString.Append("+");
+            }
+            if ((this.LoggingOptions & MSIExecLoggingOptions.Flush_Each_line) == MSIExecLoggingOptions.Flush_Each_line)
+            {
+                loggingOptionsString.Append("!");
+            }
+            if ((this.LoggingOptions & MSIExecLoggingOptions.Log_All_Information) == MSIExecLoggingOptions.Log_All_Information)
+            {
+                loggingOptionsString.Append("*");
+            }
+
+            // logfile and logging options
+            if (0 != loggingOptionsString.Length || !string.IsNullOrEmpty(this.LogFile))
+            {
+                arguments.Append(" /l");
+                if (0 != loggingOptionsString.Length)
+                {
+                    arguments.AppendFormat("{0} ", loggingOptionsString);
+                }
+                if (!string.IsNullOrEmpty(this.LogFile))
+                {
+                    arguments.AppendFormat(" \"{0}\" ", this.LogFile);
+                }
+            }
+
+            // OtherArguments
+            if (!String.IsNullOrEmpty(this.OtherArguments))
+            {
+                arguments.AppendFormat(" {0} ", this.OtherArguments);
+            }
+
+            // execution mode
+            switch (this.ExecutionMode)
+            {
+                case MSIExecMode.Install:
+                    arguments.Append(" /package ");
+                    break;
+                case MSIExecMode.AdministrativeInstall:
+                    arguments.Append(" /a ");
+                    break;
+                case MSIExecMode.Repair:
+                    arguments.Append(" /f ");
+                    break;
+                case MSIExecMode.Cleanup:
+                case MSIExecMode.Uninstall:
+                    arguments.Append(" /uninstall ");
+                    break;
+            };
+
+            // product
+            if (!string.IsNullOrEmpty(this.Product))
+            {
+                arguments.AppendFormat(" \"{0}\" ", this.Product);
+            }
+
+            return arguments.ToString();
+        }
+
+        /// <summary>
+        /// Return codes from an MSI install or uninstall
+        /// </summary>
+        /// <remarks>
+        /// Error codes indicative of success are:
+        /// ERROR_SUCCESS, ERROR_SUCCESS_REBOOT_INITIATED, and ERROR_SUCCESS_REBOOT_REQUIRED 
+        /// </remarks>
+        public enum MSIExecReturnCode
+        {
+            /// <summary>
+            /// ERROR_SUCCESS                           0   
+            /// Action completed successfully.
+            /// </summary>
+            SUCCESS = 0,
+
+            /// <summary>
+            /// ERROR_INVALID_DATA                      13 
+            /// The data is invalid. 
+            /// </summary>
+            ERROR_INVALID_DATA = 13,
+
+            /// <summary>
+            /// ERROR_INVALID_PARAMETER                 87 
+            /// One of the parameters was invalid. 
+            /// </summary>
+            ERROR_INVALID_PARAMETER = 87,
+
+            /// <summary>
+            /// ERROR_CALL_NOT_IMPLEMENTED              120 
+            /// This value is returned when a custom action attempts to call a function that cannot be called from custom actions. 
+            /// The function returns the value ERROR_CALL_NOT_IMPLEMENTED. Available beginning with Windows Installer version 3.0. 
+            /// </summary>
+            ERROR_CALL_NOT_IMPLEMENTED = 120,
+
+            /// <summary>
+            /// ERROR_APPHELP_BLOCK                     1259 
+            /// If Windows Installer determines a product may be incompatible with the current operating system, 
+            /// it displays a dialog box informing the user and asking whether to try to install anyway. 
+            /// This error code is returned if the user chooses not to try the installation. 
+            /// </summary>
+            ERROR_APPHELP_BLOCK = 1259,
+
+            /// <summary>
+            /// ERROR_INSTALL_SERVICE_FAILURE           1601
+            /// The Windows Installer service could not be accessed. 
+            /// Contact your support personnel to verify that the Windows Installer service is properly registered. 
+            /// </summary>
+            ERROR_INSTALL_SERVICE_FAILURE = 1601,
+
+
+            /// <summary>
+            /// ERROR_INSTALL_USEREXIT                  1602 
+            /// The user cancels installation. 
+            /// </summary>
+            ERROR_INSTALL_USEREXIT = 1602,
+
+            /// <summary>
+            /// ERROR_INSTALL_FAILURE                   1603 
+            /// A fatal error occurred during installation.
+            /// </summary> 
+            ERROR_INSTALL_FAILURE = 1603,
+
+            /// <summary>
+            /// ERROR_INSTALL_SUSPEND                   1604 
+            /// Installation suspended, incomplete. 
+            /// </summary> 
+            ERROR_INSTALL_SUSPEND = 1604,
+
+            /// <summary>
+            /// ERROR_UNKNOWN_PRODUCT                   1605 
+            /// This action is only valid for products that are currently installed. 
+            /// </summary> 
+            ERROR_UNKNOWN_PRODUCT = 1605,
+
+            /// <summary>
+            /// ERROR_UNKNOWN_FEATURE                   1606 
+            /// The feature identifier is not registered.
+            /// </summary> 
+            ERROR_UNKNOWN_FEATURE = 1606,
+
+            /// <summary>
+            /// ERROR_UNKNOWN_COMPONENT                 1607 
+            /// The component identifier is not registered.
+            /// </summary> 
+            ERROR_UNKNOWN_COMPONENT = 1607,
+
+            /// <summary>
+            /// ERROR_UNKNOWN_PROPERTY                  1608 
+            /// This is an unknown property. 
+            /// </summary> 
+            ERROR_UNKNOWN_PROPERTY = 1608,
+
+            /// <summary>
+            /// ERROR_INVALID_HANDLE_STATE              1609 
+            /// The handle is in an invalid state. 
+            /// </summary> 
+            ERROR_INVALID_HANDLE_STATE = 1609,
+
+            /// <summary>
+            /// ERROR_BAD_CONFIGURATION                 1610 
+            /// The configuration data for this product is corrupt. Contact your support personnel. 
+            /// </summary> 
+            ERROR_BAD_CONFIGURATION = 1610,
+
+            /// <summary>
+            /// ERROR_INDEX_ABSENT                      1611 
+            /// The component qualifier not present. 
+            /// </summary> 
+            ERROR_INDEX_ABSENT = 1611,
+
+            /// <summary>ERROR_INSTALL_SOURCE_ABSENT    1612 
+            /// The installation source for this product is not available. 
+            /// Verify that the source exists and that you can access it. 
+            /// </summary> 
+            ERROR_INSTALL_SOURCE_ABSENT = 1612,
+
+            /// <summary>
+            /// ERROR_INSTALL_PACKAGE_VERSION           1613 
+            /// This installation package cannot be installed by the Windows Installer service. 
+            /// You must install a Windows service pack that contains a newer version of the Windows Installer service. 
+            /// </summary> 
+            ERROR_INSTALL_PACKAGE_VERSION = 1613,
+
+            /// <summary>
+            /// ERROR_PRODUCT_UNINSTALLED               1614 
+            /// The product is uninstalled. 
+            /// </summary> 
+            ERROR_PRODUCT_UNINSTALLED = 1614,
+
+            /// <summary>
+            /// ERROR_BAD_QUERY_SYNTAX                  1615 
+            /// The SQL query syntax is invalid or unsupported. 
+            /// </summary> 
+            ERROR_BAD_QUERY_SYNTAX = 1615,
+
+            /// <summary>
+            /// ERROR_INVALID_FIELD                     1616 
+            /// The record field does not exist. 
+            /// </summary> 
+            ERROR_INVALID_FIELD = 1616,
+
+            /// <summary>
+            /// ERROR_INSTALL_ALREADY_RUNNING           1618 
+            /// Another installation is already in progress. Complete that installation before proceeding with this install. 
+            /// For information about the mutex, see _MSIExecute Mutex. 
+            /// </summary>
+            ERROR_INSTALL_ALREADY_RUNNING = 1618,
+
+            /// <summary>
+            /// ERROR_INSTALL_PACKAGE_OPEN_FAILED       1619 
+            /// This installation package could not be opened. Verify that the package exists and is accessible, or contact the 
+            /// application vendor to verify that this is a valid Windows Installer package. 
+            /// </summary>  
+            ERROR_INSTALL_PACKAGE_OPEN_FAILED = 1619,
+
+
+            /// <summary>
+            /// ERROR_INSTALL_PACKAGE_INVALID           1620 
+            /// This installation package could not be opened. 
+            /// Contact the application vendor to verify that this is a valid Windows Installer package. 
+            /// </summary> 
+            ERROR_INSTALL_PACKAGE_INVALID = 1620,
+
+            /// <summary>
+            /// ERROR_INSTALL_UI_FAILURE                1621 
+            /// There was an error starting the Windows Installer service user interface. 
+            /// Contact your support personnel. 
+            /// </summary> 
+            ERROR_INSTALL_UI_FAILURE = 1621,
+
+            /// <summary>
+            /// ERROR_INSTALL_LOG_FAILURE               1622 
+            /// There was an error opening installation log file. 
+            /// Verify that the specified log file location exists and is writable. 
+            /// </summary> 
+            ERROR_INSTALL_LOG_FAILURE = 1622,
+
+            /// <summary>
+            /// ERROR_INSTALL_LANGUAGE_UNSUPPORTED      1623 
+            /// This language of this installation package is not supported by your system. 
+            /// </summary> 
+            ERROR_INSTALL_LANGUAGE_UNSUPPORTED = 1623,
+
+            /// <summary>
+            /// ERROR_INSTALL_TRANSFORM_FAILURE         1624 
+            /// There was an error applying transforms.
+            /// Verify that the specified transform paths are valid. 
+            /// </summary> 
+            ERROR_INSTALL_TRANSFORM_FAILURE = 1624,
+
+
+            /// <summary>
+            /// ERROR_INSTALL_PACKAGE_REJECTED          1625 
+            /// This installation is forbidden by system policy. 
+            /// Contact your system administrator. 
+            /// </summary> 
+            ERROR_INSTALL_PACKAGE_REJECTED = 1625,
+
+            /// <summary>
+            /// ERROR_FUNCTION_NOT_CALLED               1626 
+            /// The function could not be executed. 
+            /// </summary> 
+            ERROR_FUNCTION_NOT_CALLED = 1626,
+
+            /// <summary>
+            /// ERROR_FUNCTION_FAILED                   1627 
+            /// The function failed during execution. 
+            /// </summary> 
+            ERROR_FUNCTION_FAILED = 1627,
+
+            /// <summary>
+            /// ERROR_INVALID_TABLE                     1628 
+            /// An invalid or unknown table was specified. 
+            /// </summary> 
+            ERROR_INVALID_TABLE = 1628,
+
+            /// <summary>
+            /// ERROR_DATATYPE_MISMATCH                 1629 
+            /// The data supplied is the wrong type. 
+            /// </summary> 
+            ERROR_DATATYPE_MISMATCH = 1629,
+
+            /// <summary>
+            /// ERROR_UNSUPPORTED_TYPE                  1630 
+            /// Data of this type is not supported. 
+            /// </summary> 
+            ERROR_UNSUPPORTED_TYPE = 1630,
+
+            /// <summary>
+            /// ERROR_CREATE_FAILED                     1631 
+            /// The Windows Installer service failed to start. 
+            /// Contact your support personnel. 
+            /// </summary> 
+            ERROR_CREATE_FAILED = 1631,
+
+            /// <summary>
+            /// ERROR_INSTALL_TEMP_UNWRITABLE           1632 
+            /// The Temp folder is either full or inaccessible. 
+            /// Verify that the Temp folder exists and that you can write to it. 
+            /// </summary> 
+            ERROR_INSTALL_TEMP_UNWRITABLE = 1632,
+
+            /// <summary>
+            /// ERROR_INSTALL_PLATFORM_UNSUPPORTED      1633 
+            /// This installation package is not supported on this platform. Contact your application vendor. </summary> 
+            ERROR_INSTALL_PLATFORM_UNSUPPORTED = 1633,
+
+            /// <summary>
+            /// ERROR_INSTALL_NOTUSED                   1634 
+            /// Component is not used on this machine. 
+            /// </summary> 
+            ERROR_INSTALL_NOTUSED = 1634,
+
+            /// <summary>
+            /// ERROR_PATCH_PACKAGE_OPEN_FAILED         1635 
+            /// This patch package could not be opened. Verify that the patch package exists and is accessible, 
+            /// or contact the application vendor to verify that this is a valid Windows Installer patch package. 
+            /// </summary> 
+            ERROR_PATCH_PACKAGE_OPEN_FAILED = 1635,
+
+            /// <summary>
+            /// ERROR_PATCH_PACKAGE_INVALID             1636 
+            /// This patch package could not be opened. 
+            /// Contact the application vendor to verify that this is a valid Windows Installer patch package. 
+            /// </summary> 
+            ERROR_PATCH_PACKAGE_INVALID = 1636,
+
+            /// <summary>
+            /// ERROR_PATCH_PACKAGE_UNSUPPORTED         1637 
+            /// This patch package cannot be processed by the Windows Installer service.
+            /// You must install a Windows service pack that contains a newer version of the Windows Installer service. 
+            /// </summary> 
+            ERROR_PATCH_PACKAGE_UNSUPPORTED = 1637,
+
+            /// <summary>
+            /// ERROR_PRODUCT_VERSION                   1638 
+            /// Another version of this product is already installed. 
+            /// Installation of this version cannot continue. To configure or remove the existing version of this product, 
+            /// use Add/Remove Programs in Control Panel. 
+            /// </summary> 
+            ERROR_PRODUCT_VERSION = 1638,
+
+            /// <summary>
+            /// ERROR_INVALID_COMMAND_LINE              1639 
+            /// Invalid command line argument. 
+            /// Consult the Windows Installer SDK for detailed command-line help. 
+            /// </summary> 
+            ERROR_INVALID_COMMAND_LINE = 1639,
+
+            /// <summary>
+            /// ERROR_INSTALL_REMOTE_DISALLOWED         1640
+            /// The current user is not permitted to perform installations from a client session of a server running the 
+            /// Terminal Server role service. 
+            /// </summary> 
+            ERROR_INSTALL_REMOTE_DISALLOWED = 1640,
+
+            /// <summary>
+            /// ERROR_SUCCESS_REBOOT_INITIATED          1641 
+            /// The installer has initiated a restart. 
+            /// This message is indicative of a success. 
+            /// </summary>  
+            ERROR_SUCCESS_REBOOT_INITIATED = 1641,
+
+            /// <summary>
+            /// ERROR_PATCH_TARGET_NOT_FOUND            1642
+            /// The installer cannot install the upgrade patch because the program being upgraded may be missing or the 
+            /// upgrade patch updates a different version of the program. 
+            /// Verify that the program to be upgraded exists on your computer and that you have the correct upgrade patch. 
+            /// </summary>  
+            ERROR_PATCH_TARGET_NOT_FOUND = 1642,
+
+            /// <summary>
+            /// ERROR_PATCH_PACKAGE_REJECTED            1643 
+            /// The patch package is not permitted by system policy. 
+            /// </summary> 
+            ERROR_PATCH_PACKAGE_REJECTED = 1643,
+
+            /// <summary>
+            /// ERROR_INSTALL_TRANSFORM_REJECTED        1644 
+            /// One or more customizations are not permitted by system policy. 
+            /// </summary> 
+            ERROR_INSTALL_TRANSFORM_REJECTED = 1644,
+
+            /// <summary>
+            /// ERROR_INSTALL_REMOTE_PROHIBITED         1645 
+            /// Windows Installer does not permit installation from a Remote Desktop Connection. 
+            /// </summary> 
+            ERROR_INSTALL_REMOTE_PROHIBITED = 1645,
+
+            /// <summary>
+            /// ERROR_PATCH_REMOVAL_UNSUPPORTED         1646 
+            /// The patch package is not a removable patch package. Available beginning with Windows Installer version 3.0. 
+            /// </summary> 
+            ERROR_PATCH_REMOVAL_UNSUPPORTED = 1646,
+
+            /// <summary>
+            /// ERROR_UNKNOWN_PATCH                     1647 
+            /// The patch is not applied to this product. Available beginning with Windows Installer version 3.0. 
+            /// </summary> 
+            ERROR_UNKNOWN_PATCH = 1647,
+
+            /// <summary>
+            /// ERROR_PATCH_NO_SEQUENCE                 1648 
+            /// No valid sequence could be found for the set of patches. Available beginning with Windows Installer version 3.0. 
+            /// </summary> 
+            ERROR_PATCH_NO_SEQUENCE = 1648,
+
+            /// <summary>
+            /// ERROR_PATCH_REMOVAL_DISALLOWED          1649
+            /// Patch removal was disallowed by policy. Available beginning with Windows Installer version 3.0. </summary> 
+            ERROR_PATCH_REMOVAL_DISALLOWED = 1649,
+
+            /// <summary>
+            /// ERROR_INVALID_PATCH_XML = 1650 
+            /// The XML patch data is invalid. Available beginning with Windows Installer version 3.0. 
+            /// </summary> 
+            ERROR_INVALID_PATCH_XML = 1650,
+
+            /// <summary>
+            /// ERROR_PATCH_MANAGED_ADVERTISED_PRODUCT  1651 
+            /// Administrative user failed to apply patch for a per-user managed or a per-machine application that is in advertise state. 
+            /// Available beginning with Windows Installer version 3.0. </summary> 
+            ERROR_PATCH_MANAGED_ADVERTISED_PRODUCT = 1651,
+
+            /// <summary>
+            /// ERROR_INSTALL_SERVICE_SAFEBOOT          1652 
+            /// Windows Installer is not accessible when the computer is in Safe Mode. 
+            /// Exit Safe Mode and try again or try using System Restore to return your computer to a previous state. 
+            /// Available beginning with Windows Installer version 4.0. 
+            /// </summary> 
+            ERROR_INSTALL_SERVICE_SAFEBOOT = 1652,
+
+            /// <summary>
+            /// ERROR_ROLLBACK_DISABLED                 1653 
+            /// Could not perform a multiple-package transaction because rollback has been disabled. 
+            /// Multiple-Package Installations cannot run if rollback is disabled. Available beginning with Windows Installer version 4.5. 
+            /// </summary> 
+            ERROR_ROLLBACK_DISABLED = 1653,
+
+            /// <summary>
+            /// ERROR_SUCCESS_REBOOT_REQUIRED           3010 
+            /// A restart is required to complete the install. This message is indicative of a success. 
+            /// This does not include installs where the ForceReboot action is run. 
+            /// </summary> 
+            ERROR_SUCCESS_REBOOT_REQUIRED = 3010
+        }
+
+        /// <summary>
+        /// Modes of operations for MSIExec; install, administrator install, uninstall .. etc
+        /// </summary>
+        public enum MSIExecMode
+        {
+            /// <summary>
+            /// Installs or configures a product
+            /// </summary>
+            Install = 0,
+
+            /// <summary>
+            /// Administrative install - Installs a product on the network
+            /// </summary>
+            AdministrativeInstall,
+
+            /// <summary>
+            /// Uninstalls the product
+            /// </summary>
+            Uninstall,
+
+            /// <summary>
+            /// Repairs a product
+            /// </summary>
+            Repair,
+
+            /// <summary>
+            /// Modifies a product
+            /// </summary>
+            Modify,
+
+            /// <summary>
+            /// Uninstalls the product as part of cleanup
+            /// </summary>
+            Cleanup,
+        }
+
+        /// <summary>
+        /// User interfave levels
+        /// </summary>
+        public enum MSIExecUserInterfaceLevel
+        {
+            /// <summary>
+            /// No UI
+            /// </summary>
+            None = 0,
+
+            /// <summary>
+            /// Basic UI
+            /// </summary>
+            Basic,
+
+            /// <summary>
+            /// Reduced UI
+            /// </summary>
+            Reduced,
+
+            /// <summary>
+            /// Full UI (default)
+            /// </summary>
+            Full
+        }
+
+        /// <summary>
+        /// Logging options
+        /// </summary>
+        [Flags]
+        public enum MSIExecLoggingOptions
+        {
+            Status_Messages = 0x0001,
+            Nonfatal_Warnings = 0x0002,
+            All_Error_Messages = 0x0004,
+            Start_Up_Of_Actions = 0x0008,
+            Action_Specific_Records = 0x0010,
+            User_Requests = 0x0020,
+            Initial_UI_Parameters = 0x0040,
+            OutOfMemory_Or_Fatal_Exit_Information = 0x0080,
+            OutOfDiskSpace_Messages = 0x0100,
+            Terminal_Properties = 0x0200,
+            Verbose_Output = 0x0400,
+            Append_To_Existing_Log_File = 0x0800,
+
+            Flush_Each_line = 0x1000,
+            Extra_Debugging_Information = 0x2000,
+            Log_All_Information = 0x4000,
+            VOICEWARMUP = 0x0FFF
+        }
+    }
+}
diff --git a/src/test/burn/WixTestTools/MsiUtilities.cs b/src/test/burn/WixTestTools/MsiUtilities.cs
new file mode 100644
index 00000000..4c7d1601
--- /dev/null
+++ b/src/test/burn/WixTestTools/MsiUtilities.cs
@@ -0,0 +1,47 @@
+// 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 WixTestTools
+{
+    using System;
+    using WixToolset.Dtf.WindowsInstaller;
+
+    public class MsiUtilities
+    {
+        /// <summary>
+        /// Return true if it finds the given productcode in system otherwise it returns false
+        /// </summary>
+        /// <param name="prodCode"></param>
+        /// <returns></returns>
+        public static bool IsProductInstalled(string prodCode)
+        {
+            //look in all user's products (both per-machine and per-user)
+            foreach (ProductInstallation product in ProductInstallation.GetProducts(null, "s-1-1-0", UserContexts.All))
+            {
+                if (product.ProductCode == prodCode)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Return true if it finds the given productcode in system with the specified version otherwise it returns false
+        /// </summary>
+        /// <param name="prodCode"></param>
+        /// <param name="prodVersion"></param>
+        /// <returns></returns>
+        public static bool IsProductInstalledWithVersion(string prodCode, Version prodVersion)
+        {
+            //look in all user's products (both per-machine and per-user)
+            foreach (ProductInstallation product in ProductInstallation.GetProducts(null, "s-1-1-0", UserContexts.All))
+            {
+                if (product.ProductCode == prodCode && product.ProductVersion == prodVersion)
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+}
diff --git a/src/test/burn/WixTestTools/PackageInstaller.cs b/src/test/burn/WixTestTools/PackageInstaller.cs
new file mode 100644
index 00000000..d32f499b
--- /dev/null
+++ b/src/test/burn/WixTestTools/PackageInstaller.cs
@@ -0,0 +1,104 @@
+// 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 WixTestTools
+{
+    using System;
+    using System.IO;
+    using System.Linq;
+    using WixToolset.Data;
+    using WixToolset.Data.Symbols;
+    using WixToolset.Data.WindowsInstaller;
+    using static WixTestTools.MSIExec;
+
+    public partial class PackageInstaller : IDisposable
+    {
+        public PackageInstaller(WixTestContext testContext, string filename)
+        {
+            this.Package = Path.Combine(testContext.TestDataFolder, $"{filename}.msi");
+            this.PackagePdb = Path.Combine(testContext.TestDataFolder, $"{filename}.wixpdb");
+            this.TestContext = testContext;
+
+            using var wixOutput = WixOutput.Read(this.PackagePdb);
+
+            var intermediate = Intermediate.Load(wixOutput);
+            var section = intermediate.Sections.Single();
+            var platformSummary = section.Symbols.OfType<SummaryInformationSymbol>().Single(s => s.PropertyId == SummaryInformationType.PlatformAndLanguage);
+            var platformString = platformSummary.Value.Split(new char[] { ';' }, 2)[0];
+            this.IsX64 = platformString != "Intel";
+
+            this.WiData = WindowsInstallerData.Load(wixOutput);
+        }
+
+        public string Package { get; }
+
+        private WixTestContext TestContext { get; }
+
+        public string TestGroupName => this.TestContext.TestGroupName;
+
+        public string TestName => this.TestContext.TestName;
+
+        /// <summary>
+        /// Installs a .msi file
+        /// </summary>
+        /// <param name="expectedExitCode">Expected exit code</param>
+        /// <param name="otherArguments">Other arguments to pass to MSIExec.</param>
+        /// <returns>MSIExec log File</returns>
+        public string InstallProduct(MSIExecReturnCode expectedExitCode = MSIExecReturnCode.SUCCESS, params string[] otherArguments)
+        {
+            return this.RunMSIExec(MSIExecMode.Install, otherArguments, expectedExitCode);
+        }
+
+        /// <summary>
+        /// Uninstalls a .msi file
+        /// </summary>
+        /// <param name="expectedExitCode">Expected exit code</param>
+        /// <param name="otherArguments">Other arguments to pass to MSIExec.</param>
+        /// <returns>MSIExec log File</returns>
+        public string UninstallProduct(MSIExecReturnCode expectedExitCode = MSIExecReturnCode.SUCCESS, params string[] otherArguments)
+        {
+            return this.RunMSIExec(MSIExecMode.Uninstall, otherArguments, expectedExitCode);
+        }
+
+        /// <summary>
+        /// Repairs a .msi file
+        /// </summary>
+        /// <param name="expectedExitCode">Expected exit code</param>
+        /// <param name="otherArguments">Other arguments to pass to msiexe.exe.</param>
+        /// <returns>MSIExec log File</returns>
+        public string RepairProduct(MSIExecReturnCode expectedExitCode = MSIExecReturnCode.SUCCESS, params string[] otherArguments)
+        {
+            return this.RunMSIExec(MSIExecMode.Repair, otherArguments, expectedExitCode);
+        }
+
+        /// <summary>
+        /// Executes MSIExec on a .msi file
+        /// </summary>
+        /// <param name="mode">Mode of execution for MSIExec</param>
+        /// <param name="otherArguments">Other arguments to pass to MSIExec.</param>
+        /// <param name="expectedExitCode">Expected exit code</param>
+        /// <returns>MSIExec exit code</returns>
+        private string RunMSIExec(MSIExecMode mode, string[] otherArguments, MSIExecReturnCode expectedExitCode, bool assertOnError = true)
+        {
+            // Generate the log file name.
+            var logFile = Path.Combine(Path.GetTempPath(), String.Format("{0}_{1}_{2:yyyyMMddhhmmss}_{4}_{3}.log", this.TestGroupName, this.TestName, DateTime.UtcNow, Path.GetFileNameWithoutExtension(this.Package), mode));
+
+            var msiexec = new MSIExec
+            {
+                Product = this.Package,
+                ExecutionMode = mode,
+                OtherArguments = null != otherArguments ? String.Join(" ", otherArguments) : null,
+                ExpectedExitCode = expectedExitCode,
+                LogFile = logFile,
+            };
+
+            msiexec.Run(assertOnError);
+            return msiexec.LogFile;
+        }
+
+        public void Dispose()
+        {
+            string[] args = { "IGNOREDEPENDENCIES=ALL", "WIXFAILWHENDEFERRED=0" };
+            this.RunMSIExec(MSIExecMode.Cleanup, args, MSIExecReturnCode.SUCCESS, assertOnError: false);
+        }
+    }
+}
diff --git a/src/test/burn/WixTestTools/PackageVerifier.cs b/src/test/burn/WixTestTools/PackageVerifier.cs
new file mode 100644
index 00000000..2f42dd21
--- /dev/null
+++ b/src/test/burn/WixTestTools/PackageVerifier.cs
@@ -0,0 +1,81 @@
+// 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 WixTestTools
+{
+    using System;
+    using System.IO;
+    using System.Linq;
+    using WixToolset.Data.WindowsInstaller;
+    using WixToolset.Data.WindowsInstaller.Rows;
+    using Xunit;
+
+    public partial class PackageInstaller
+    {
+        public string PackagePdb { get; }
+
+        private bool IsX64 { get; }
+
+        private WindowsInstallerData WiData { get; }
+
+        public string GetInstalledFilePath(string filename)
+        {
+            return this.TestContext.GetTestInstallFolder(this.IsX64, Path.Combine(this.GetInstallFolderName(), filename));
+        }
+
+        public string GetInstallFolderName()
+        {
+            var row = this.WiData.Tables["Directory"].Rows.Single(r => r.FieldAsString(0) == "INSTALLFOLDER");
+            var value = row.FieldAsString(2);
+            var longNameIndex = value.IndexOf('|') + 1;
+            if (longNameIndex > 0)
+            {
+                return value.Substring(longNameIndex);
+            }
+            return value;
+        }
+
+        public string GetProperty(string name)
+        {
+            var row = this.WiData.Tables["Property"].Rows.Cast<PropertyRow>().Single(r => r.Property == name);
+            return row.Value;
+        }
+
+        public void VerifyInstalled(bool installed)
+        {
+            var productCode = this.GetProperty("ProductCode");
+            Assert.Equal(installed, MsiUtilities.IsProductInstalled(productCode));
+        }
+
+        public void VerifyInstalledWithVersion(bool installed)
+        {
+            var productCode = this.GetProperty("ProductCode");
+            Version prodVersion = new Version(this.GetProperty("ProductVersion"));
+            Assert.Equal(installed, MsiUtilities.IsProductInstalledWithVersion(productCode, prodVersion));
+        }
+
+        public void DeleteTestRegistryValue(string name)
+        {
+            using (var root = this.TestContext.GetTestRegistryRoot(this.IsX64))
+            {
+                Assert.NotNull(root);
+                root.DeleteValue(name);
+            }
+        }
+
+        public void VerifyTestRegistryRootDeleted()
+        {
+            using var testRegistryRoot = this.TestContext.GetTestRegistryRoot(this.IsX64);
+            Assert.Null(testRegistryRoot);
+        }
+
+        public void VerifyTestRegistryValue(string name, string expectedValue)
+        {
+            using (var root = this.TestContext.GetTestRegistryRoot(this.IsX64))
+            {
+                Assert.NotNull(root);
+                var actualValue = root.GetValue(name) as string;
+                Assert.Equal(expectedValue, actualValue);
+            }
+        }
+    }
+}
diff --git a/src/test/burn/WixTestTools/TestTool.cs b/src/test/burn/WixTestTools/TestTool.cs
new file mode 100644
index 00000000..be5fde42
--- /dev/null
+++ b/src/test/burn/WixTestTools/TestTool.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 WixTestTools
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using WixBuildTools.TestSupport;
+    using Xunit;
+
+    public class TestTool : ExternalExecutable
+    {
+        /// <summary>
+        /// Constructor for a TestTool
+        /// </summary>
+        public TestTool()
+            : this(null)
+        {
+        }
+
+        /// <summary>
+        /// Constructor for a TestTool
+        /// </summary>
+        /// <param name="toolFile">The full path to the tool. Eg. c:\bin\candle.exe</param>
+        public TestTool(string toolFile)
+            : base(toolFile)
+        {
+            this.PrintOutputToConsole = true;
+        }
+
+        /// <summary>
+        /// The arguments to pass to the tool
+        /// </summary>
+        public virtual string Arguments { get; set; }
+
+        /// <summary>
+        /// Stores the errors that occurred when a run was checked against its expected results
+        /// </summary>
+        public List<string> Errors { get; set; }
+
+        /// <summary>
+        /// A list of Regex's that are expected to match stderr
+        /// </summary>
+        public List<Regex> ExpectedErrorRegexs { get; set; } = new List<Regex>();
+
+        /// <summary>
+        /// The expected error strings to stderr
+        /// </summary>
+        public List<string> ExpectedErrorStrings { get; set; } = new List<string>();
+
+        /// <summary>
+        /// The expected exit code of the tool
+        /// </summary>
+        public int? ExpectedExitCode { get; set; }
+
+        /// <summary>
+        /// A list of Regex's that are expected to match stdout
+        /// </summary>
+        public List<Regex> ExpectedOutputRegexs { get; set; } = new List<Regex>();
+
+        /// <summary>
+        /// The expected output strings to stdout
+        /// </summary>
+        public List<string> ExpectedOutputStrings { get; set; } = new List<string>();
+
+        /// <summary>
+        /// Print output from the tool execution to the console
+        /// </summary>
+        public bool PrintOutputToConsole { get; set; }
+
+        /// <summary>
+        /// The working directory of the tool
+        /// </summary>
+        public string WorkingDirectory { get; set; }
+
+        /// <summary>
+        /// Print the errors from the last run
+        /// </summary>
+        public void PrintErrors()
+        {
+            if (null != this.Errors)
+            {
+                Console.WriteLine("Errors:");
+
+                foreach (string error in this.Errors)
+                {
+                    Console.WriteLine(error);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Run the tool
+        /// </summary>
+        /// <returns>The results of the run</returns>
+        public ExternalExecutableResult Run()
+        {
+            return this.Run(true);
+        }
+
+        /// <summary>
+        /// Run the tool
+        /// </summary>
+        /// <param name="exceptionOnError">Throw an exception if the expected results don't match the actual results</param>
+        /// <exception cref="System.Exception">Thrown when the expected results don't match the actual results</exception>
+        /// <returns>The results of the run</returns>
+        public virtual ExternalExecutableResult Run(bool assertOnError)
+        {
+            var result = this.Run(this.Arguments, workingDirectory: this.WorkingDirectory ?? String.Empty);
+
+            if (this.PrintOutputToConsole)
+            {
+                Console.WriteLine(FormatResult(result));
+            }
+
+            this.Errors = this.CheckResult(result);
+
+            if (assertOnError && 0 < this.Errors.Count)
+            {
+                if (this.PrintOutputToConsole)
+                {
+                    this.PrintErrors();
+                }
+
+                Assert.Empty(this.Errors);
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Checks that the result from a run matches the expected results
+        /// </summary>
+        /// <param name="result">A result from a run</param>
+        /// <returns>A list of errors</returns>
+        public virtual List<string> CheckResult(ExternalExecutableResult result)
+        {
+            List<string> errors = new List<string>();
+
+            // Verify that the expected return code matched the actual return code
+            if (null != this.ExpectedExitCode && this.ExpectedExitCode != result.ExitCode)
+            {
+                errors.Add(String.Format("Expected exit code {0} did not match actual exit code {1}", this.ExpectedExitCode, result.ExitCode));
+            }
+
+            var standardErrorString = string.Join(Environment.NewLine, result.StandardError);
+
+            // Verify that the expected error string are in stderr
+            if (null != this.ExpectedErrorStrings)
+            {
+                foreach (string expectedString in this.ExpectedErrorStrings)
+                {
+                    if (!standardErrorString.Contains(expectedString))
+                    {
+                        errors.Add(String.Format("The text '{0}' was not found in stderr", expectedString));
+                    }
+                }
+            }
+
+            var standardOutputString = string.Join(Environment.NewLine, result.StandardOutput);
+
+            // Verify that the expected output string are in stdout
+            if (null != this.ExpectedOutputStrings)
+            {
+                foreach (string expectedString in this.ExpectedOutputStrings)
+                {
+                    if (!standardOutputString.Contains(expectedString))
+                    {
+                        errors.Add(String.Format("The text '{0}' was not found in stdout", expectedString));
+                    }
+                }
+            }
+
+            // Verify that the expected regular expressions match stderr
+            if (null != this.ExpectedOutputRegexs)
+            {
+                foreach (Regex expectedRegex in this.ExpectedOutputRegexs)
+                {
+                    if (!expectedRegex.IsMatch(standardOutputString))
+                    {
+                        errors.Add(String.Format("Regex {0} did not match stdout", expectedRegex.ToString()));
+                    }
+                }
+            }
+
+            // Verify that the expected regular expressions match stdout
+            if (null != this.ExpectedErrorRegexs)
+            {
+                foreach (Regex expectedRegex in this.ExpectedErrorRegexs)
+                {
+                    if (!expectedRegex.IsMatch(standardErrorString))
+                    {
+                        errors.Add(String.Format("Regex {0} did not match stderr", expectedRegex.ToString()));
+                    }
+                }
+            }
+
+            return errors;
+        }
+
+        /// <summary>
+        /// Clears all of the expected results and resets them to the default values
+        /// </summary>
+        public virtual void SetDefaultExpectedResults()
+        {
+            this.ExpectedErrorRegexs = new List<Regex>();
+            this.ExpectedErrorStrings = new List<string>();
+            this.ExpectedExitCode = null;
+            this.ExpectedOutputRegexs = new List<Regex>();
+            this.ExpectedOutputStrings = new List<string>();
+        }
+
+        /// <summary>
+        /// Returns a string with data contained in the result.
+        /// </summary>
+        /// <returns>A string</returns>
+        private static string FormatResult(ExternalExecutableResult result)
+        {
+            var returnValue = new StringBuilder();
+            returnValue.AppendLine();
+            returnValue.AppendLine("----------------");
+            returnValue.AppendLine("Tool run result:");
+            returnValue.AppendLine("----------------");
+            returnValue.AppendLine("Command:");
+            returnValue.AppendLine($"\"{result.StartInfo.FileName}\" {result.StartInfo.Arguments}");
+            returnValue.AppendLine();
+            returnValue.AppendLine("Standard Output:");
+            foreach (var line in result.StandardOutput ?? new string[0])
+            {
+                returnValue.AppendLine(line);
+            }
+            returnValue.AppendLine("Standard Error:");
+            foreach (var line in result.StandardError ?? new string[0])
+            {
+                returnValue.AppendLine(line);
+            }
+            returnValue.AppendLine("Exit Code:");
+            returnValue.AppendLine(Convert.ToString(result.ExitCode));
+            returnValue.AppendLine("----------------");
+
+            return returnValue.ToString();
+        }
+    }
+}
diff --git a/src/test/burn/WixTestTools/WixTestBase.cs b/src/test/burn/WixTestTools/WixTestBase.cs
new file mode 100644
index 00000000..bc050135
--- /dev/null
+++ b/src/test/burn/WixTestTools/WixTestBase.cs
@@ -0,0 +1,19 @@
+// 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 WixTestTools
+{
+    using Xunit.Abstractions;
+
+    public abstract class WixTestBase
+    {
+        protected WixTestBase(ITestOutputHelper testOutputHelper)
+        {
+            this.TestContext = new WixTestContext(testOutputHelper);
+        }
+
+        /// <summary>
+        /// The test context for the current test.
+        /// </summary>
+        public WixTestContext TestContext { get; }
+    }
+}
diff --git a/src/test/burn/WixTestTools/WixTestContext.cs b/src/test/burn/WixTestTools/WixTestContext.cs
new file mode 100644
index 00000000..a4e666f1
--- /dev/null
+++ b/src/test/burn/WixTestTools/WixTestContext.cs
@@ -0,0 +1,75 @@
+// 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 WixTestTools
+{
+    using System;
+    using System.IO;
+    using System.Linq;
+    using System.Reflection;
+    using Microsoft.Win32;
+    using WixBuildTools.TestSupport;
+    using Xunit.Abstractions;
+
+    public class WixTestContext
+    {
+        static readonly string RootDataPath = Path.GetFullPath(TestData.Get("TestData"));
+
+        public WixTestContext(ITestOutputHelper testOutputHelper)
+        {
+            var test = GetTest(testOutputHelper);
+            var splitClassName = test.TestCase.TestMethod.TestClass.Class.Name.Split('.');
+
+            this.TestGroupName = splitClassName.Last();
+            this.TestName = test.TestCase.TestMethod.Method.Name;
+
+            this.TestDataFolder = Path.Combine(RootDataPath, this.TestGroupName);
+        }
+
+        public string TestDataFolder { get; }
+
+        /// <summary>
+        /// Gets the name of the current test group.
+        /// </summary>
+        public string TestGroupName { get; }
+
+        public string TestName { get; }
+
+        /// <summary>
+        /// Gets the test install directory for the current test.
+        /// </summary>
+        /// <param name="additionalPath">Additional subdirectories under the test install directory.</param>
+        /// <returns>Full path to the test install directory.</returns>
+        /// <remarks>
+        /// The package or bundle must install into [ProgramFilesFolder]\~Test WiX\[TestGroupName]\([Additional]).
+        /// </remarks>
+        public string GetTestInstallFolder(bool x64, string additionalPath = null)
+        {
+            var baseDirectory = x64 ? Environment.SpecialFolder.ProgramFiles : Environment.SpecialFolder.ProgramFilesX86;
+            return Path.Combine(Environment.GetFolderPath(baseDirectory), "~Test WiX", this.TestGroupName, additionalPath ?? String.Empty);
+        }
+
+        /// <summary>
+        /// Gets the test registry key for the current test.
+        /// </summary>
+        /// <param name="additionalPath">Additional subkeys under the test registry key.</param>
+        /// <returns>Full path to the test registry key.</returns>
+        /// <remarks>
+        /// The package must write into HKLM\Software\WiX\Tests\[TestGroupName]\([Additional]).
+        /// </remarks>
+        public RegistryKey GetTestRegistryRoot(bool x64, string additionalPath = null)
+        {
+            var baseKey = x64 ? "Software" : @"Software\WOW6432Node";
+            var key = String.Format(@"{0}\WiX\Tests\{1}\{2}", baseKey, this.TestGroupName, additionalPath ?? String.Empty);
+            return Registry.LocalMachine.OpenSubKey(key, true);
+        }
+
+        private static ITest GetTest(ITestOutputHelper output)
+        {
+            // https://github.com/xunit/xunit/issues/416#issuecomment-378512739
+            var type = output.GetType();
+            var testMember = type.GetField("test", BindingFlags.Instance | BindingFlags.NonPublic);
+            var test = (ITest)testMember.GetValue(output);
+            return test;
+        }
+    }
+}
diff --git a/src/test/burn/WixTestTools/WixTestTools.csproj b/src/test/burn/WixTestTools/WixTestTools.csproj
new file mode 100644
index 00000000..58f02be7
--- /dev/null
+++ b/src/test/burn/WixTestTools/WixTestTools.csproj
@@ -0,0 +1,21 @@
+<?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>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <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="xunit" Version="2.4.1" />
+  </ItemGroup>
+</Project>