Normalize ToolsetTask implementation to call wix.exe and heat.exe

Share the ToolsetTask implementation that can find .NET Core and
.NET Framework with multiple architectures.

Fixes 6951

8 files changed, 472 insertions, 2 deletions

diff --git a/src/internal/SetBuildNumber/Directory.Packages.props.pp b/src/internal/SetBuildNumber/Directory.Packages.props.pp
index d06990fe..e1df6f8e 100644
--- a/src/internal/SetBuildNumber/Directory.Packages.props.pp
+++ b/src/internal/SetBuildNumber/Directory.Packages.props.pp
@@ -8,6 +8,7 @@
 
     <PackageVersion Include="WixBuildTools.TestSupport" Version="{packageversion}" />
     <PackageVersion Include="WixBuildTools.TestSupport.Native" Version="{packageversion}" />
+    <PackageVersion Include="WixToolset.BaseBuildTasks.Sources" Version="{packageversion}" />
 
     <PackageVersion Include="WixToolset.DUtil" Version="{packageversion}" />
     <PackageVersion Include="WixToolset.WcaUtil" Version="{packageversion}" />
diff --git a/src/internal/WixToolset.BaseBuildTasks.Sources/BaseToolsetTask.cs b/src/internal/WixToolset.BaseBuildTasks.Sources/BaseToolsetTask.cs
new file mode 100644
index 00000000..d9e3b5e8
--- /dev/null
+++ b/src/internal/WixToolset.BaseBuildTasks.Sources/BaseToolsetTask.cs
@@ -0,0 +1,178 @@
+// 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 WixToolset.BaseBuildTasks
+{
+    using System;
+    using System.IO;
+    using System.Runtime.InteropServices;
+    using Microsoft.Build.Utilities;
+
+    public abstract class BaseToolsetTask : ToolTask
+    {
+        /// <summary>
+        /// Gets or sets additional options that are appended the the tool command-line.
+        /// </summary>
+        /// <remarks>
+        /// This allows the task to support extended options in the tool which are not
+        /// explicitly implemented as properties on the task.
+        /// </remarks>
+        public string AdditionalOptions { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether to display the logo.
+        /// </summary>
+        public bool NoLogo { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether all warnings should be suppressed.
+        /// </summary>
+        public bool SuppressAllWarnings { get; set; }
+
+        /// <summary>
+        /// Gets or sets a list of specific warnings to be suppressed.
+        /// </summary>
+        public string[] SuppressSpecificWarnings { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether all warnings should be treated as errors.
+        /// </summary>
+        public bool TreatWarningsAsErrors { get; set; }
+
+        /// <summary>
+        /// Gets or sets a list of specific warnings to treat as errors.
+        /// </summary>
+        public string[] TreatSpecificWarningsAsErrors { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether to display verbose output.
+        /// </summary>
+        public bool VerboseOutput { get; set; }
+
+        /// <summary>
+        /// Get the path to the executable.
+        /// </summary>
+        /// <remarks>
+        /// ToolTask only calls GenerateFullPathToTool when the ToolPath property is not set.
+        /// WiX never sets the ToolPath property, but the user can through $(WixToolDir).
+        /// If we return only a file name, ToolTask will search the system paths for it.
+        /// </remarks>
+        protected sealed override string GenerateFullPathToTool()
+        {
+            var defaultToolFullPath = this.GetDefaultToolFullPath();
+
+#if NETCOREAPP
+            // If we're pointing at an executable use that.
+            if (IsSelfExecutable(defaultToolFullPath, out var finalToolFullPath))
+            {
+                return finalToolFullPath;
+            }
+
+            // Otherwise, use "dotnet.exe" to run an assembly dll.
+            return Environment.GetEnvironmentVariable("DOTNET_HOST_PATH") ?? "dotnet";
+#else
+            return defaultToolFullPath;
+#endif
+        }
+
+        /// <summary>
+        /// Builds a command line from options in this and derivative tasks.
+        /// </summary>
+        /// <remarks>
+        /// Derivative classes should call BuildCommandLine() on the base class to ensure that common command line options are added to the command.
+        /// </remarks>
+        protected virtual void BuildCommandLine(WixCommandLineBuilder commandLineBuilder)
+        {
+            commandLineBuilder.AppendIfTrue("-nologo", this.NoLogo);
+            commandLineBuilder.AppendArrayIfNotNull("-sw", this.SuppressSpecificWarnings);
+            commandLineBuilder.AppendIfTrue("-sw", this.SuppressAllWarnings);
+            commandLineBuilder.AppendIfTrue("-v", this.VerboseOutput);
+            commandLineBuilder.AppendArrayIfNotNull("-wx", this.TreatSpecificWarningsAsErrors);
+            commandLineBuilder.AppendIfTrue("-wx", this.TreatWarningsAsErrors);
+            commandLineBuilder.AppendTextIfNotNull(this.AdditionalOptions);
+        }
+
+        protected sealed override string GenerateResponseFileCommands()
+        {
+            var commandLineBuilder = new WixCommandLineBuilder();
+            this.BuildCommandLine(commandLineBuilder);
+            return commandLineBuilder.ToString();
+        }
+
+#if NETCOREAPP
+        protected override string GenerateCommandLineCommands()
+        {
+            // If the target tool path is an executable, we don't need to add anything to the command-line.
+            var toolFullPath = this.GetToolFullPath();
+
+            if (IsSelfExecutable(toolFullPath, out var finalToolFullPath))
+            {
+                return null;
+            }
+            else // we're using "dotnet.exe" to run the assembly so add "exec" plus path to the command-line.
+            {
+                return $"exec \"{finalToolFullPath}\"";
+            }
+        }
+
+        private static bool IsSelfExecutable(string proposedToolFullPath, out string finalToolFullPath)
+        {
+            var toolFullPathWithoutExtension = Path.Combine(Path.GetDirectoryName(proposedToolFullPath), Path.GetFileNameWithoutExtension(proposedToolFullPath));
+            var exeExtension = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? ".exe" : String.Empty;
+            var exeToolFullPath = $"{toolFullPathWithoutExtension}{exeExtension}";
+            if (File.Exists(exeToolFullPath))
+            {
+                finalToolFullPath = exeToolFullPath;
+                return true;
+            }
+
+            finalToolFullPath = $"{toolFullPathWithoutExtension}.dll";
+            return false;
+        }
+#else
+        private static string GetArchitectureFolder(string baseFolder)
+        {
+            // First try to find a folder that matches this task's architecture.
+            var folder = RuntimeInformation.ProcessArchitecture.ToString().ToLowerInvariant();
+
+            if (Directory.Exists(Path.Combine(baseFolder, folder)))
+            {
+                return folder;
+            }
+
+            // Try to fallback to "x86" folder.
+            if (folder != "x86" && Directory.Exists(Path.Combine(baseFolder, "x86")))
+            {
+                return "x86";
+            }
+
+            // Return empty, even though this isn't likely to be useful.
+            return String.Empty;
+        }
+#endif
+
+        private string GetDefaultToolFullPath()
+        {
+#if NETCOREAPP
+                var thisTaskFolder = Path.GetDirectoryName(typeof(BaseToolsetTask).Assembly.Location);
+
+                return Path.Combine(thisTaskFolder, this.ToolExe);
+#else
+                var thisTaskFolder = Path.GetDirectoryName(new Uri(typeof(BaseToolsetTask).Assembly.CodeBase).AbsolutePath);
+
+                var archFolder = GetArchitectureFolder(thisTaskFolder);
+
+                return Path.Combine(thisTaskFolder, archFolder, this.ToolExe);
+#endif
+        }
+
+        private string GetToolFullPath()
+        {
+            if (String.IsNullOrEmpty(this.ToolPath))
+            {
+                return this.GetDefaultToolFullPath();
+            }
+
+            return Path.Combine(this.ToolPath, this.ToolExe);
+        }
+    }
+}
diff --git a/src/internal/WixToolset.BaseBuildTasks.Sources/FileSearchHelperMethods.cs b/src/internal/WixToolset.BaseBuildTasks.Sources/FileSearchHelperMethods.cs
new file mode 100644
index 00000000..442fedd6
--- /dev/null
+++ b/src/internal/WixToolset.BaseBuildTasks.Sources/FileSearchHelperMethods.cs
@@ -0,0 +1,57 @@
+// 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 WixToolset.BaseBuildTasks
+{
+    using System;
+    using System.IO;
+
+    /// <summary>
+    /// Contains helper methods on searching for files
+    /// </summary>
+    public static class FileSearchHelperMethods
+    {
+        /// <summary>
+        /// Searches for the existence of a file in multiple directories. 
+        /// Search is satisfied if default file path is valid and exists. If not,
+        /// file name is extracted from default path and combined with each of the directories
+        /// looking to see if it exists. If not found, input default path is returned.
+        /// </summary>
+        /// <param name="directories">Array of directories to look in, without filenames in them</param>
+        /// <param name="defaultFullPath">Default path - to use if not found</param>
+        /// <returns>File path if file found. Empty string if not found</returns>
+        public static string SearchFilePaths(string[] directories, string defaultFullPath)
+        {
+            if (String.IsNullOrEmpty(defaultFullPath))
+            {
+                return String.Empty;
+            }
+
+            if (File.Exists(defaultFullPath))
+            {
+                return defaultFullPath;
+            }
+
+            if (directories == null)
+            {
+                return String.Empty;
+            }
+
+            var fileName = Path.GetFileName(defaultFullPath);
+            foreach (var currentPath in directories)
+            {
+                if (String.IsNullOrWhiteSpace(currentPath))
+                {
+                    continue;
+                }
+
+                var path = Path.Combine(currentPath, fileName);
+                if (File.Exists(path))
+                {
+                    return path;
+                }
+            }
+
+            return String.Empty;
+        }
+    }
+}
diff --git a/src/internal/WixToolset.BaseBuildTasks.Sources/WixCommandLineBuilder.cs b/src/internal/WixToolset.BaseBuildTasks.Sources/WixCommandLineBuilder.cs
new file mode 100644
index 00000000..152992dd
--- /dev/null
+++ b/src/internal/WixToolset.BaseBuildTasks.Sources/WixCommandLineBuilder.cs
@@ -0,0 +1,177 @@
+// 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 WixToolset.BaseBuildTasks
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+
+    /// <summary>
+    /// Helper class for appending the command line arguments.
+    /// </summary>
+    public class WixCommandLineBuilder : CommandLineBuilder
+    {
+        internal const int Unspecified = -1;
+
+        /// <summary>
+        /// Append a switch to the command line if the value has been specified.
+        /// </summary>
+        /// <param name="switchName">Switch to append.</param>
+        /// <param name="value">Value specified by the user.</param>
+        public void AppendIfSpecified(string switchName, int value)
+        {
+            if (value != Unspecified)
+            {
+                this.AppendSwitchIfNotNull(switchName, value.ToString(CultureInfo.InvariantCulture));
+            }
+        }
+
+        /// <summary>
+        /// Append a switch to the command line if the condition is true.
+        /// </summary>
+        /// <param name="switchName">Switch to append.</param>
+        /// <param name="condition">Condition specified by the user.</param>
+        public void AppendIfTrue(string switchName, bool condition)
+        {
+            if (condition)
+            {
+                this.AppendSwitch(switchName);
+            }
+        }
+
+        /// <summary>
+        /// Append a switch to the command line if any values in the array have been specified.
+        /// </summary>
+        /// <param name="switchName">Switch to append.</param>
+        /// <param name="values">Values specified by the user.</param>
+        public void AppendArrayIfNotNull(string switchName, IEnumerable<ITaskItem> values)
+        {
+            if (values != null)
+            {
+                foreach (ITaskItem value in values)
+                {
+                    this.AppendSwitchIfNotNull(switchName, value);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Append a switch to the command line if any values in the array have been specified.
+        /// </summary>
+        /// <param name="switchName">Switch to append.</param>
+        /// <param name="values">Values specified by the user.</param>
+        public void AppendArrayIfNotNull(string switchName, IEnumerable<string> values)
+        {
+            if (values != null)
+            {
+                foreach (string value in values)
+                {
+                    this.AppendSwitchIfNotNull(switchName, value);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Build the extensions argument. Each extension is searched in the current folder, user defined search
+        /// directories (ReferencePath), HintPath, and under Wix Extension Directory in that order.
+        /// The order of precedence is based off of that described in Microsoft.Common.Targets's SearchPaths
+        /// property for the ResolveAssemblyReferences task.
+        /// </summary>
+        /// <param name="extensions">The list of extensions to include.</param>
+        /// <param name="wixExtensionDirectory">Evaluated default folder for Wix Extensions</param>
+        /// <param name="referencePaths">User defined reference directories to search in</param>
+        public void AppendExtensions(ITaskItem[] extensions, string wixExtensionDirectory, string [] referencePaths)
+        {
+            if (extensions == null)
+            {
+                return;
+            }
+
+            foreach (ITaskItem extension in extensions)
+            {
+                string className = extension.GetMetadata("Class");
+
+                string fileName = Path.GetFileName(extension.ItemSpec);
+
+                if (String.IsNullOrEmpty(Path.GetExtension(fileName)))
+                {
+                    fileName += ".dll";
+                }
+
+                // First try reference paths
+                var resolvedPath = FileSearchHelperMethods.SearchFilePaths(referencePaths, fileName);
+
+                if (String.IsNullOrEmpty(resolvedPath))
+                {
+                    // Now try HintPath
+                    resolvedPath = extension.GetMetadata("HintPath");
+
+                    if (!File.Exists(resolvedPath))
+                    {
+                        // Now try the item itself
+                        resolvedPath = extension.ItemSpec;
+
+                        if (String.IsNullOrEmpty(Path.GetExtension(resolvedPath)))
+                        {
+                            resolvedPath += ".dll";
+                        }
+
+                        if (!File.Exists(resolvedPath))
+                        {
+                            if (!String.IsNullOrEmpty(wixExtensionDirectory))
+                            {
+                                // Now try the extension directory
+                                resolvedPath = Path.Combine(wixExtensionDirectory, Path.GetFileName(resolvedPath));
+                            }
+
+                            if (!File.Exists(resolvedPath))
+                            {
+                                // Extension wasn't found, just set it to the extension name passed in
+                                resolvedPath = extension.ItemSpec;
+                            }
+                        }
+                    }
+                }
+
+                if (String.IsNullOrEmpty(className))
+                {
+                    this.AppendSwitchIfNotNull("-ext ", resolvedPath);
+                }
+                else
+                {
+                    this.AppendSwitchIfNotNull("-ext ", className + ", " + resolvedPath);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Append arbitrary text to the command-line if specified.
+        /// </summary>
+        /// <param name="textToAppend">Text to append.</param>
+        public void AppendTextIfNotNull(string textToAppend)
+        {
+            if (!String.IsNullOrEmpty(textToAppend))
+            {
+                this.AppendSpaceIfNotEmpty();
+                this.AppendTextUnquoted(textToAppend);
+            }
+        }
+
+        /// <summary>
+        /// Append arbitrary text to the command-line if specified.
+        /// </summary>
+        /// <param name="textToAppend">Text to append.</param>
+        public void AppendTextIfNotWhitespace(string textToAppend)
+        {
+            if (!String.IsNullOrWhiteSpace(textToAppend))
+            {
+                this.AppendSpaceIfNotEmpty();
+                this.AppendTextUnquoted(textToAppend);
+            }
+        }
+    }
+}
diff --git a/src/internal/WixToolset.BaseBuildTasks.Sources/WixToolset.BaseBuildTasks.Sources.csproj b/src/internal/WixToolset.BaseBuildTasks.Sources/WixToolset.BaseBuildTasks.Sources.csproj
new file mode 100644
index 00000000..6ae5165e
--- /dev/null
+++ b/src/internal/WixToolset.BaseBuildTasks.Sources/WixToolset.BaseBuildTasks.Sources.csproj
@@ -0,0 +1,36 @@
+<?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>
+  <Import Project="Sdk.props" Sdk="Microsoft.NET.Sdk" />
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <PackageDescription>WiX Toolset BuildTasks Foundation Sources</PackageDescription>
+    <IsPackable>true</IsPackable>
+    <EnableDefaultItems>false</EnableDefaultItems>
+    <IncludeBuildOutput>false</IncludeBuildOutput>
+    <ContentTargetFolders>contentFiles</ContentTargetFolders>
+    <DisableImplicitFrameworkReferences>true</DisableImplicitFrameworkReferences>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
+    <NoWarn>CS8021</NoWarn>
+    <NoBuild>true</NoBuild>
+    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+    <SuppressDependenciesWhenPacking>true</SuppressDependenciesWhenPacking>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="*.cs" Pack="true" PackagePath="$(ContentTargetFolders)\cs\netstandard2.0\$(PackageId)\%(RecursiveDir)" />
+    <EmbeddedResource Include="*.resx" Pack="true" PackagePath="$(ContentTargetFolders)\any\any\$(PackageId)\%(RecursiveDir)" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Remove="@(PackageReference)" />
+  </ItemGroup>
+
+  <Import Project="Sdk.targets" Sdk="Microsoft.NET.Sdk" />
+
+  <Target Name="Compile" />
+  <Target Name="CopyFilesToOutputDirectory" />
+</Project>
diff --git a/src/internal/internal.cmd b/src/internal/internal.cmd
index 9380ce4e..32df26e9 100644
--- a/src/internal/internal.cmd
+++ b/src/internal/internal.cmd
@@ -33,8 +33,10 @@ msbuild internal_t.proj -p:Configuration=%_C% -nologo -warnaserror -bl:%_L%\inte
 @rd /s/q "..\..\build\internal" 2> nul
 @del "..\..\build\artifacts\WixBuildTools.TestSupport.*.nupkg" 2> nul
 @del "..\..\build\artifacts\WixBuildTools.TestSupport.Native.*.nupkg" 2> nul
+@del "..\..\build\artifacts\WixToolset.BaseBuildTasks.Sources.*.nupkg" 2> nul
 @rd /s/q "%USERPROFILE%\.nuget\packages\wixbuildtools.testsupport" 2> nul
 @rd /s/q "%USERPROFILE%\.nuget\packages\wixbuildtools.testsupport.native" 2> nul
+@rd /s/q "%USERPROFILE%\.nuget\packages\wixtoolset.basebuildtasks.sources" 2> nul
 @exit /b
 
 :end
diff --git a/src/internal/internal.sln b/src/internal/internal.sln
index 9d4fe69f..fe36efbe 100644
--- a/src/internal/internal.sln
+++ b/src/internal/internal.sln
@@ -1,12 +1,14 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.6.30114.105
+# Visual Studio Version 17
+VisualStudioVersion = 17.3.32929.385
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WixBuildTools.TestSupport", "WixBuildTools.TestSupport\WixBuildTools.TestSupport.csproj", "{8E082709-7355-41D5-AF86-6BBF9C89BDD7}"
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "WixBuildTools.TestSupport.Native", "WixBuildTools.TestSupport.Native\WixBuildTools.TestSupport.Native.vcxproj", "{95BABD97-FBDB-453A-AF8A-FA031A07B599}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WixToolset.BaseBuildTasks.Sources", "WixToolset.BaseBuildTasks.Sources\WixToolset.BaseBuildTasks.Sources.csproj", "{6B654490-AB0D-4F94-B564-DAA80044D5A3}"
+EndProject
 Global
         GlobalSection(SolutionConfigurationPlatforms) = preSolution
                 Debug|Any CPU = Debug|Any CPU
@@ -47,6 +49,22 @@ Global
                 {95BABD97-FBDB-453A-AF8A-FA031A07B599}.Release|x64.ActiveCfg = Release|Win32
                 {95BABD97-FBDB-453A-AF8A-FA031A07B599}.Release|x86.ActiveCfg = Release|Win32
                 {95BABD97-FBDB-453A-AF8A-FA031A07B599}.Release|x86.Build.0 = Release|Win32
+                {6B654490-AB0D-4F94-B564-DAA80044D5A3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+                {6B654490-AB0D-4F94-B564-DAA80044D5A3}.Debug|Any CPU.Build.0 = Debug|Any CPU
+                {6B654490-AB0D-4F94-B564-DAA80044D5A3}.Debug|ARM64.ActiveCfg = Debug|Any CPU
+                {6B654490-AB0D-4F94-B564-DAA80044D5A3}.Debug|ARM64.Build.0 = Debug|Any CPU
+                {6B654490-AB0D-4F94-B564-DAA80044D5A3}.Debug|x64.ActiveCfg = Debug|Any CPU
+                {6B654490-AB0D-4F94-B564-DAA80044D5A3}.Debug|x64.Build.0 = Debug|Any CPU
+                {6B654490-AB0D-4F94-B564-DAA80044D5A3}.Debug|x86.ActiveCfg = Debug|Any CPU
+                {6B654490-AB0D-4F94-B564-DAA80044D5A3}.Debug|x86.Build.0 = Debug|Any CPU
+                {6B654490-AB0D-4F94-B564-DAA80044D5A3}.Release|Any CPU.ActiveCfg = Release|Any CPU
+                {6B654490-AB0D-4F94-B564-DAA80044D5A3}.Release|Any CPU.Build.0 = Release|Any CPU
+                {6B654490-AB0D-4F94-B564-DAA80044D5A3}.Release|ARM64.ActiveCfg = Release|Any CPU
+                {6B654490-AB0D-4F94-B564-DAA80044D5A3}.Release|ARM64.Build.0 = Release|Any CPU
+                {6B654490-AB0D-4F94-B564-DAA80044D5A3}.Release|x64.ActiveCfg = Release|Any CPU
+                {6B654490-AB0D-4F94-B564-DAA80044D5A3}.Release|x64.Build.0 = Release|Any CPU
+                {6B654490-AB0D-4F94-B564-DAA80044D5A3}.Release|x86.ActiveCfg = Release|Any CPU
+                {6B654490-AB0D-4F94-B564-DAA80044D5A3}.Release|x86.Build.0 = Release|Any CPU
         EndGlobalSection
         GlobalSection(SolutionProperties) = preSolution
                 HideSolutionNode = FALSE
diff --git a/src/internal/internal_t.proj b/src/internal/internal_t.proj
index fda67786..fc4956d2 100644
--- a/src/internal/internal_t.proj
+++ b/src/internal/internal_t.proj
@@ -1,5 +1,6 @@
 <Project Sdk="Microsoft.Build.Traversal">
   <ItemGroup>
+    <ProjectReference Include="WixToolset.BaseBuildTasks.Sources\WixToolset.BaseBuildTasks.Sources.csproj" Targets="Pack" />
     <ProjectReference Include="WixBuildTools.TestSupport\WixBuildTools.TestSupport.csproj" Targets="Pack" />
     <ProjectReference Include="WixBuildTools.TestSupport.Native\WixBuildTools.TestSupport.Native.vcxproj" Properties="Platform=x86" />
     <ProjectReference Include="WixBuildTools.TestSupport.Native\WixBuildTools.TestSupport.Native.vcxproj" Properties="Platform=x64" />