From c4090531d4caac4b8cb3356cb971ff2e1c9f8704 Mon Sep 17 00:00:00 2001
From: Sean Hall <r.sean.hall@gmail.com>
Date: Wed, 15 Jun 2022 17:08:04 -0500
Subject: Build and run x64 dutil tests.

---
 src/burn/burn_t.proj                               |   2 +-
 src/libs/dutil/dutil.sln                           |  10 +-
 src/libs/dutil/dutil_t.proj                        |   2 +-
 src/libs/dutil/test/DUtilUnitTest/FileUtilTest.cpp |   4 +-
 src/libs/dutil/test/DUtilUnitTest/RegUtilTest.cpp  |   4 +-
 src/libs/dutil/test/DUtilUnitTest/VerUtilTests.cpp | 130 ++++++++++-----------
 src/libs/libs.cmd                                  |   3 +-
 src/testresultfilelist.txt                         |   3 +-
 8 files changed, 81 insertions(+), 77 deletions(-)

diff --git a/src/burn/burn_t.proj b/src/burn/burn_t.proj
index d7902fe1..adf1ce1e 100644
--- a/src/burn/burn_t.proj
+++ b/src/burn/burn_t.proj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.Build.Traversal">
   <ItemGroup>
-    <ProjectReference Include="test\BurnUnitTest\BurnUnitTest.vcxproj" Properties="Platform=x86" BuildInParallel="false" />
     <ProjectReference Include="test\BurnUnitTest\BurnUnitTest.vcxproj" Properties="Platform=x64" BuildInParallel="false" />
+    <ProjectReference Include="test\BurnUnitTest\BurnUnitTest.vcxproj" Properties="Platform=x86" BuildInParallel="false" />
 
     <ProjectReference Include="stub\stub.vcxproj" Properties="Platform=x86" />
     <ProjectReference Include="stub\stub.vcxproj" Properties="Platform=x64" />
diff --git a/src/libs/dutil/dutil.sln b/src/libs/dutil/dutil.sln
index f6bfcc97..9dd7d62b 100644
--- a/src/libs/dutil/dutil.sln
+++ b/src/libs/dutil/dutil.sln
@@ -29,12 +29,14 @@ Global
 		{1244E671-F108-4334-BA52-8A7517F26ECD}.Release|x64.Build.0 = Release|x64
 		{1244E671-F108-4334-BA52-8A7517F26ECD}.Release|x86.ActiveCfg = Release|Win32
 		{1244E671-F108-4334-BA52-8A7517F26ECD}.Release|x86.Build.0 = Release|Win32
-		{AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Debug|ARM64.ActiveCfg = Debug|Win32
-		{AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Debug|x64.ActiveCfg = Debug|Win32
+		{AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Debug|ARM64.ActiveCfg = Debug|x64
+		{AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Debug|x64.ActiveCfg = Debug|x64
+		{AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Debug|x64.Build.0 = Debug|x64
 		{AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Debug|x86.ActiveCfg = Debug|Win32
 		{AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Debug|x86.Build.0 = Debug|Win32
-		{AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Release|ARM64.ActiveCfg = Release|Win32
-		{AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Release|x64.ActiveCfg = Release|Win32
+		{AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Release|ARM64.ActiveCfg = Release|x64
+		{AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Release|x64.ActiveCfg = Release|x64
+		{AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Release|x64.Build.0 = Release|x64
 		{AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Release|x86.ActiveCfg = Release|Win32
 		{AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Release|x86.Build.0 = Release|Win32
 	EndGlobalSection
diff --git a/src/libs/dutil/dutil_t.proj b/src/libs/dutil/dutil_t.proj
index ee33dae1..bd9ee7c8 100644
--- a/src/libs/dutil/dutil_t.proj
+++ b/src/libs/dutil/dutil_t.proj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.Build.Traversal">
   <ItemGroup>
+    <ProjectReference Include="test\DUtilUnitTest\DUtilUnitTest.vcxproj" Properties="Platform=x64" />
     <ProjectReference Include="test\DUtilUnitTest\DUtilUnitTest.vcxproj" Properties="Platform=x86" />
-    <ProjectReference Include="WixToolset.DUtil\dutil.vcxproj" Properties="Platform=x64" />
     <ProjectReference Include="WixToolset.DUtil\dutil.vcxproj" Properties="Platform=ARM64" />
 
     <ProjectReference Include="WixToolset.DUtil\dutil.vcxproj" Targets="PackNative" />
diff --git a/src/libs/dutil/test/DUtilUnitTest/FileUtilTest.cpp b/src/libs/dutil/test/DUtilUnitTest/FileUtilTest.cpp
index ac071ef2..522361ae 100644
--- a/src/libs/dutil/test/DUtilUnitTest/FileUtilTest.cpp
+++ b/src/libs/dutil/test/DUtilUnitTest/FileUtilTest.cpp
@@ -58,9 +58,9 @@ namespace DutilTests
             LPWSTR sczOutputPath = NULL;
             FILE_ENCODING feEncodingFound = FILE_ENCODING_UNSPECIFIED;
             BYTE *pbFile1 = NULL;
-            DWORD cbFile1 = 0;
+            SIZE_T cbFile1 = 0;
             BYTE *pbFile2 = NULL;
-            DWORD cbFile2 = 0;
+            SIZE_T cbFile2 = 0;
             size_t cbActualStringLength = 0;
 
             try
diff --git a/src/libs/dutil/test/DUtilUnitTest/RegUtilTest.cpp b/src/libs/dutil/test/DUtilUnitTest/RegUtilTest.cpp
index 9e97f5e0..7c67bedf 100644
--- a/src/libs/dutil/test/DUtilUnitTest/RegUtilTest.cpp
+++ b/src/libs/dutil/test/DUtilUnitTest/RegUtilTest.cpp
@@ -541,7 +541,7 @@ namespace DutilTests
 
                 hr = RegReadBinary(hkBase, L"Binary", &pbBuffer, &cbBuffer);
                 NativeAssert::Succeeded(hr, "Failed to read binary value.");
-                Assert::Equal<DWORD>(4, cbBuffer);
+                Assert::Equal<SIZE_T>(4, cbBuffer);
                 Assert::Equal<BYTE>(1, pbBuffer[0]);
                 Assert::Equal<BYTE>(2, pbBuffer[1]);
                 Assert::Equal<BYTE>(3, pbBuffer[2]);
@@ -581,7 +581,7 @@ namespace DutilTests
 
                 hr = RegReadBinary(hkBase, L"Binary", &pbBuffer, &cbBuffer);
                 NativeAssert::Succeeded(hr, "Failed to read binary value.");
-                Assert::Equal<DWORD>(0, cbBuffer);
+                Assert::Equal<SIZE_T>(0, cbBuffer);
             }
             finally
             {
diff --git a/src/libs/dutil/test/DUtilUnitTest/VerUtilTests.cpp b/src/libs/dutil/test/DUtilUnitTest/VerUtilTests.cpp
index 3402097c..f4085c33 100644
--- a/src/libs/dutil/test/DUtilUnitTest/VerUtilTests.cpp
+++ b/src/libs/dutil/test/DUtilUnitTest/VerUtilTests.cpp
@@ -40,7 +40,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(3, pVersion1->dwPatch);
                 Assert::Equal<DWORD>(4, pVersion1->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
-                Assert::Equal<DWORD>(7, pVersion1->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(7, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);
@@ -54,7 +54,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(3, pVersion2->dwPatch);
                 Assert::Equal<DWORD>(0, pVersion2->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
-                Assert::Equal<DWORD>(5, pVersion2->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(5, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor);
@@ -68,7 +68,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(3, pVersion3->dwPatch);
                 Assert::Equal<DWORD>(0, pVersion3->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
-                Assert::Equal<DWORD>(7, pVersion3->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(7, pVersion3->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor);
@@ -114,14 +114,14 @@ namespace DutilTests
                 Assert::Equal<BOOL>(TRUE, pVersion1->rgReleaseLabels[0].fNumeric);
                 Assert::Equal<DWORD>(2, pVersion1->rgReleaseLabels[0].dwValue);
                 Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[0].cchLabel);
-                Assert::Equal<DWORD>(4, pVersion1->rgReleaseLabels[0].cchLabelOffset);
+                Assert::Equal<SIZE_T>(4, pVersion1->rgReleaseLabels[0].cchLabelOffset);
 
                 Assert::Equal<BOOL>(TRUE, pVersion1->rgReleaseLabels[1].fNumeric);
                 Assert::Equal<DWORD>(0, pVersion1->rgReleaseLabels[1].dwValue);
                 Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[1].cchLabel);
-                Assert::Equal<DWORD>(6, pVersion1->rgReleaseLabels[1].cchLabelOffset);
+                Assert::Equal<SIZE_T>(6, pVersion1->rgReleaseLabels[1].cchLabelOffset);
 
-                Assert::Equal<DWORD>(7, pVersion1->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(7, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);
@@ -139,9 +139,9 @@ namespace DutilTests
                 Assert::Equal<BOOL>(TRUE, pVersion2->rgReleaseLabels[0].fNumeric);
                 Assert::Equal<DWORD>(19, pVersion2->rgReleaseLabels[0].dwValue);
                 Assert::Equal<DWORD>(2, pVersion2->rgReleaseLabels[0].cchLabel);
-                Assert::Equal<DWORD>(4, pVersion2->rgReleaseLabels[0].cchLabelOffset);
+                Assert::Equal<SIZE_T>(4, pVersion2->rgReleaseLabels[0].cchLabelOffset);
 
-                Assert::Equal<DWORD>(6, pVersion2->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(6, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor);
@@ -201,7 +201,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion1->dwPatch);
                 Assert::Equal<DWORD>(0, pVersion1->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
-                Assert::Equal<DWORD>(3, pVersion1->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(3, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fHasMinor);
@@ -215,7 +215,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion2->dwPatch);
                 Assert::Equal<DWORD>(0, pVersion2->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
-                Assert::Equal<DWORD>(3, pVersion2->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(3, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);
                 Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor);
@@ -229,7 +229,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion3->dwPatch);
                 Assert::Equal<DWORD>(0, pVersion3->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
-                Assert::Equal<DWORD>(1, pVersion3->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(1, pVersion3->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);
                 Assert::Equal<BOOL>(FALSE, pVersion3->fHasMinor);
@@ -243,7 +243,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion4->dwPatch);
                 Assert::Equal<DWORD>(0, pVersion4->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion4->cReleaseLabels);
-                Assert::Equal<DWORD>(0, pVersion4->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(0, pVersion4->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion4->fInvalid);
                 Assert::Equal<BOOL>(FALSE, pVersion4->fHasMajor);
                 Assert::Equal<BOOL>(FALSE, pVersion4->fHasMinor);
@@ -261,9 +261,9 @@ namespace DutilTests
                 Assert::Equal<BOOL>(TRUE, pVersion5->rgReleaseLabels[0].fNumeric);
                 Assert::Equal<DWORD>(2, pVersion5->rgReleaseLabels[0].dwValue);
                 Assert::Equal<DWORD>(1, pVersion5->rgReleaseLabels[0].cchLabel);
-                Assert::Equal<DWORD>(3, pVersion5->rgReleaseLabels[0].cchLabelOffset);
+                Assert::Equal<SIZE_T>(3, pVersion5->rgReleaseLabels[0].cchLabelOffset);
 
-                Assert::Equal<DWORD>(4, pVersion5->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(4, pVersion5->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion5->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion5->fHasMajor);
                 Assert::Equal<BOOL>(FALSE, pVersion5->fHasMinor);
@@ -281,9 +281,9 @@ namespace DutilTests
                 Assert::Equal<BOOL>(TRUE, pVersion6->rgReleaseLabels[0].fNumeric);
                 Assert::Equal<DWORD>(4, pVersion6->rgReleaseLabels[0].dwValue);
                 Assert::Equal<DWORD>(1, pVersion6->rgReleaseLabels[0].cchLabel);
-                Assert::Equal<DWORD>(3, pVersion6->rgReleaseLabels[0].cchLabelOffset);
+                Assert::Equal<SIZE_T>(3, pVersion6->rgReleaseLabels[0].cchLabelOffset);
 
-                Assert::Equal<DWORD>(5, pVersion6->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(5, pVersion6->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion6->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion6->fHasMajor);
                 Assert::Equal<BOOL>(FALSE, pVersion6->fHasMinor);
@@ -337,9 +337,9 @@ namespace DutilTests
 
                 Assert::Equal<BOOL>(FALSE, pVersion1->rgReleaseLabels[0].fNumeric);
                 Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[0].cchLabel);
-                Assert::Equal<DWORD>(6, pVersion1->rgReleaseLabels[0].cchLabelOffset);
+                Assert::Equal<SIZE_T>(6, pVersion1->rgReleaseLabels[0].cchLabelOffset);
 
-                Assert::Equal<DWORD>(7, pVersion1->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(7, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);
@@ -357,9 +357,9 @@ namespace DutilTests
                 Assert::Equal<BOOL>(TRUE, pVersion2->rgReleaseLabels[0].fNumeric);
                 Assert::Equal<DWORD>(2, pVersion2->rgReleaseLabels[0].dwValue);
                 Assert::Equal<DWORD>(1, pVersion2->rgReleaseLabels[0].cchLabel);
-                Assert::Equal<DWORD>(2, pVersion2->rgReleaseLabels[0].cchLabelOffset);
+                Assert::Equal<SIZE_T>(2, pVersion2->rgReleaseLabels[0].cchLabelOffset);
 
-                Assert::Equal<DWORD>(3, pVersion2->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(3, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);
                 Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor);
@@ -377,9 +377,9 @@ namespace DutilTests
                 Assert::Equal<BOOL>(TRUE, pVersion3->rgReleaseLabels[0].fNumeric);
                 Assert::Equal<DWORD>(2, pVersion3->rgReleaseLabels[0].dwValue);
                 Assert::Equal<DWORD>(1, pVersion3->rgReleaseLabels[0].cchLabel);
-                Assert::Equal<DWORD>(2, pVersion3->rgReleaseLabels[0].cchLabelOffset);
+                Assert::Equal<SIZE_T>(2, pVersion3->rgReleaseLabels[0].cchLabelOffset);
 
-                Assert::Equal<DWORD>(3, pVersion3->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(3, pVersion3->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);
                 Assert::Equal<BOOL>(FALSE, pVersion3->fHasMinor);
@@ -434,14 +434,14 @@ namespace DutilTests
 
                 Assert::Equal<BOOL>(FALSE, pVersion1->rgReleaseLabels[0].fNumeric);
                 Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[0].cchLabel);
-                Assert::Equal<DWORD>(5, pVersion1->rgReleaseLabels[0].cchLabelOffset);
+                Assert::Equal<SIZE_T>(5, pVersion1->rgReleaseLabels[0].cchLabelOffset);
 
                 Assert::Equal<BOOL>(TRUE, pVersion1->rgReleaseLabels[1].fNumeric);
                 Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[1].dwValue);
                 Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[1].cchLabel);
-                Assert::Equal<DWORD>(7, pVersion1->rgReleaseLabels[1].cchLabelOffset);
+                Assert::Equal<SIZE_T>(7, pVersion1->rgReleaseLabels[1].cchLabelOffset);
 
-                Assert::Equal<DWORD>(8, pVersion1->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(8, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);
@@ -458,14 +458,14 @@ namespace DutilTests
 
                 Assert::Equal<BOOL>(FALSE, pVersion2->rgReleaseLabels[0].fNumeric);
                 Assert::Equal<DWORD>(1, pVersion2->rgReleaseLabels[0].cchLabel);
-                Assert::Equal<DWORD>(6, pVersion2->rgReleaseLabels[0].cchLabelOffset);
+                Assert::Equal<SIZE_T>(6, pVersion2->rgReleaseLabels[0].cchLabelOffset);
 
                 Assert::Equal<BOOL>(TRUE, pVersion2->rgReleaseLabels[1].fNumeric);
                 Assert::Equal<DWORD>(1, pVersion2->rgReleaseLabels[1].dwValue);
                 Assert::Equal<DWORD>(1, pVersion2->rgReleaseLabels[1].cchLabel);
-                Assert::Equal<DWORD>(8, pVersion2->rgReleaseLabels[1].cchLabelOffset);
+                Assert::Equal<SIZE_T>(8, pVersion2->rgReleaseLabels[1].cchLabelOffset);
 
-                Assert::Equal<DWORD>(9, pVersion2->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(9, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor);
@@ -482,18 +482,18 @@ namespace DutilTests
 
                 Assert::Equal<BOOL>(FALSE, pVersion3->rgReleaseLabels[0].fNumeric);
                 Assert::Equal<DWORD>(1, pVersion3->rgReleaseLabels[0].cchLabel);
-                Assert::Equal<DWORD>(4, pVersion3->rgReleaseLabels[0].cchLabelOffset);
+                Assert::Equal<SIZE_T>(4, pVersion3->rgReleaseLabels[0].cchLabelOffset);
 
                 Assert::Equal<BOOL>(FALSE, pVersion3->rgReleaseLabels[1].fNumeric);
                 Assert::Equal<DWORD>(1, pVersion3->rgReleaseLabels[1].cchLabel);
-                Assert::Equal<DWORD>(6, pVersion3->rgReleaseLabels[1].cchLabelOffset);
+                Assert::Equal<SIZE_T>(6, pVersion3->rgReleaseLabels[1].cchLabelOffset);
 
                 Assert::Equal<BOOL>(TRUE, pVersion3->rgReleaseLabels[2].fNumeric);
                 Assert::Equal<DWORD>(0, pVersion3->rgReleaseLabels[2].dwValue);
                 Assert::Equal<DWORD>(1, pVersion3->rgReleaseLabels[2].cchLabel);
-                Assert::Equal<DWORD>(8, pVersion3->rgReleaseLabels[2].cchLabelOffset);
+                Assert::Equal<SIZE_T>(8, pVersion3->rgReleaseLabels[2].cchLabelOffset);
 
-                Assert::Equal<DWORD>(9, pVersion3->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(9, pVersion3->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor);
@@ -510,18 +510,18 @@ namespace DutilTests
 
                 Assert::Equal<BOOL>(FALSE, pVersion4->rgReleaseLabels[0].fNumeric);
                 Assert::Equal<DWORD>(1, pVersion4->rgReleaseLabels[0].cchLabel);
-                Assert::Equal<DWORD>(6, pVersion4->rgReleaseLabels[0].cchLabelOffset);
+                Assert::Equal<SIZE_T>(6, pVersion4->rgReleaseLabels[0].cchLabelOffset);
 
                 Assert::Equal<BOOL>(FALSE, pVersion4->rgReleaseLabels[1].fNumeric);
                 Assert::Equal<DWORD>(1, pVersion4->rgReleaseLabels[1].cchLabel);
-                Assert::Equal<DWORD>(8, pVersion4->rgReleaseLabels[1].cchLabelOffset);
+                Assert::Equal<SIZE_T>(8, pVersion4->rgReleaseLabels[1].cchLabelOffset);
 
                 Assert::Equal<BOOL>(TRUE, pVersion4->rgReleaseLabels[2].fNumeric);
                 Assert::Equal<DWORD>(0, pVersion4->rgReleaseLabels[2].dwValue);
                 Assert::Equal<DWORD>(3, pVersion4->rgReleaseLabels[2].cchLabel);
-                Assert::Equal<DWORD>(10, pVersion4->rgReleaseLabels[2].cchLabelOffset);
+                Assert::Equal<SIZE_T>(10, pVersion4->rgReleaseLabels[2].cchLabelOffset);
 
-                Assert::Equal<DWORD>(13, pVersion4->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(13, pVersion4->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion4->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion4->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion4->fHasMinor);
@@ -569,7 +569,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(3, pVersion1->dwPatch);
                 Assert::Equal<DWORD>(0, pVersion1->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
-                Assert::Equal<DWORD>(6, pVersion1->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(6, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);
@@ -583,7 +583,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(3, pVersion2->dwPatch);
                 Assert::Equal<DWORD>(0, pVersion2->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
-                Assert::Equal<DWORD>(6, pVersion2->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(6, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor);
@@ -597,7 +597,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(3, pVersion3->dwPatch);
                 Assert::Equal<DWORD>(0, pVersion3->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
-                Assert::Equal<DWORD>(6, pVersion3->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(6, pVersion3->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion3->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor);
@@ -655,7 +655,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(30, pVersion1->dwPatch);
                 Assert::Equal<DWORD>(40, pVersion1->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
-                Assert::Equal<DWORD>(11, pVersion1->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(11, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);
@@ -669,7 +669,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(30, pVersion2->dwPatch);
                 Assert::Equal<DWORD>(40, pVersion2->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
-                Assert::Equal<DWORD>(11, pVersion2->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(11, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor);
@@ -683,7 +683,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(30, pVersion3->dwPatch);
                 Assert::Equal<DWORD>(40, pVersion3->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
-                Assert::Equal<DWORD>(11, pVersion3->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(11, pVersion3->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor);
@@ -700,9 +700,9 @@ namespace DutilTests
 
                 Assert::Equal<BOOL>(FALSE, pVersion4->rgReleaseLabels[0].fNumeric);
                 Assert::Equal<DWORD>(3, pVersion4->rgReleaseLabels[0].cchLabel);
-                Assert::Equal<DWORD>(12, pVersion4->rgReleaseLabels[0].cchLabelOffset);
+                Assert::Equal<SIZE_T>(12, pVersion4->rgReleaseLabels[0].cchLabelOffset);
 
-                Assert::Equal<DWORD>(15, pVersion4->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(15, pVersion4->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion4->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion4->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion4->fHasMinor);
@@ -716,7 +716,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion5->dwPatch);
                 Assert::Equal<DWORD>(0, pVersion5->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion5->cReleaseLabels);
-                Assert::Equal<DWORD>(0, pVersion5->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(0, pVersion5->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion5->fInvalid);
                 Assert::Equal<BOOL>(FALSE, pVersion5->fHasMajor);
                 Assert::Equal<BOOL>(FALSE, pVersion5->fHasMinor);
@@ -761,7 +761,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(4294967295, pVersion1->dwPatch);
                 Assert::Equal<DWORD>(4294967295, pVersion1->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
-                Assert::Equal<DWORD>(43, pVersion1->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(43, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);
@@ -775,7 +775,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion2->dwPatch);
                 Assert::Equal<DWORD>(0, pVersion2->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
-                Assert::Equal<DWORD>(0, pVersion2->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(0, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid);
                 Assert::Equal<BOOL>(FALSE, pVersion2->fHasMajor);
                 Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor);
@@ -815,7 +815,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(3, pVersion1->dwPatch);
                 Assert::Equal<DWORD>(0, pVersion1->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
-                Assert::Equal<DWORD>(6, pVersion1->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(6, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);
@@ -829,7 +829,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(3, pVersion2->dwPatch);
                 Assert::Equal<DWORD>(0, pVersion2->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
-                Assert::Equal<DWORD>(6, pVersion2->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(6, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor);
@@ -867,7 +867,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(4, pSource->dwRevision);
                 Assert::Equal<DWORD>(0, pSource->cReleaseLabels);
 
-                Assert::Equal<DWORD>(8, pSource->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(8, pSource->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pSource->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pSource->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pSource->fHasMinor);
@@ -921,26 +921,26 @@ namespace DutilTests
 
                 Assert::Equal<BOOL>(FALSE, pSource->rgReleaseLabels[0].fNumeric);
                 Assert::Equal<DWORD>(1, pSource->rgReleaseLabels[0].cchLabel);
-                Assert::Equal<DWORD>(8, pSource->rgReleaseLabels[0].cchLabelOffset);
+                Assert::Equal<SIZE_T>(8, pSource->rgReleaseLabels[0].cchLabelOffset);
 
                 Assert::Equal<BOOL>(FALSE, pSource->rgReleaseLabels[1].fNumeric);
                 Assert::Equal<DWORD>(1, pSource->rgReleaseLabels[1].cchLabel);
-                Assert::Equal<DWORD>(10, pSource->rgReleaseLabels[1].cchLabelOffset);
+                Assert::Equal<SIZE_T>(10, pSource->rgReleaseLabels[1].cchLabelOffset);
 
                 Assert::Equal<BOOL>(FALSE, pSource->rgReleaseLabels[2].fNumeric);
                 Assert::Equal<DWORD>(1, pSource->rgReleaseLabels[2].cchLabel);
-                Assert::Equal<DWORD>(12, pSource->rgReleaseLabels[2].cchLabelOffset);
+                Assert::Equal<SIZE_T>(12, pSource->rgReleaseLabels[2].cchLabelOffset);
 
                 Assert::Equal<BOOL>(FALSE, pSource->rgReleaseLabels[3].fNumeric);
                 Assert::Equal<DWORD>(1, pSource->rgReleaseLabels[3].cchLabel);
-                Assert::Equal<DWORD>(14, pSource->rgReleaseLabels[3].cchLabelOffset);
+                Assert::Equal<SIZE_T>(14, pSource->rgReleaseLabels[3].cchLabelOffset);
 
                 Assert::Equal<BOOL>(TRUE, pSource->rgReleaseLabels[4].fNumeric);
                 Assert::Equal<DWORD>(5, pSource->rgReleaseLabels[4].dwValue);
                 Assert::Equal<DWORD>(1, pSource->rgReleaseLabels[4].cchLabel);
-                Assert::Equal<DWORD>(16, pSource->rgReleaseLabels[4].cchLabelOffset);
+                Assert::Equal<SIZE_T>(16, pSource->rgReleaseLabels[4].cchLabelOffset);
 
-                Assert::Equal<DWORD>(18, pSource->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(18, pSource->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pSource->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pSource->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pSource->fHasMinor);
@@ -1020,7 +1020,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion1->dwPatch);
                 Assert::Equal<DWORD>(0, pVersion1->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
-                Assert::Equal<DWORD>(0, pVersion1->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(0, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fInvalid);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fHasMajor);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fHasMinor);
@@ -1034,7 +1034,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion2->dwPatch);
                 Assert::Equal<DWORD>(0, pVersion2->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
-                Assert::Equal<DWORD>(2, pVersion2->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(2, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);
                 Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor);
@@ -1048,7 +1048,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion3->dwPatch);
                 Assert::Equal<DWORD>(0, pVersion3->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
-                Assert::Equal<DWORD>(4, pVersion3->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(4, pVersion3->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion3->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor);
@@ -1062,7 +1062,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(1, pVersion4->dwPatch);
                 Assert::Equal<DWORD>(0, pVersion4->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion4->cReleaseLabels);
-                Assert::Equal<DWORD>(6, pVersion4->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(6, pVersion4->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion4->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion4->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion4->fHasMinor);
@@ -1076,7 +1076,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(2, pVersion5->dwPatch);
                 Assert::Equal<DWORD>(1, pVersion5->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion5->cReleaseLabels);
-                Assert::Equal<DWORD>(8, pVersion5->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(8, pVersion5->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion5->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion5->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion5->fHasMinor);
@@ -1090,7 +1090,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion6->dwPatch);
                 Assert::Equal<DWORD>(0, pVersion6->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion6->cReleaseLabels);
-                Assert::Equal<DWORD>(2, pVersion6->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(2, pVersion6->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion6->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion6->fHasMajor);
                 Assert::Equal<BOOL>(FALSE, pVersion6->fHasMinor);
@@ -1107,9 +1107,9 @@ namespace DutilTests
 
                 Assert::Equal<BOOL>(FALSE, pVersion7->rgReleaseLabels[0].fNumeric);
                 Assert::Equal<DWORD>(1, pVersion7->rgReleaseLabels[0].cchLabel);
-                Assert::Equal<DWORD>(2, pVersion7->rgReleaseLabels[0].cchLabelOffset);
+                Assert::Equal<SIZE_T>(2, pVersion7->rgReleaseLabels[0].cchLabelOffset);
 
-                Assert::Equal<DWORD>(4, pVersion7->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(4, pVersion7->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion7->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion7->fHasMajor);
                 Assert::Equal<BOOL>(FALSE, pVersion7->fHasMinor);
@@ -1146,7 +1146,7 @@ namespace DutilTests
                 Assert::Equal<DWORD>(3, pVersion1->dwPatch);
                 Assert::Equal<DWORD>(4, pVersion1->dwRevision);
                 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
-                Assert::Equal<DWORD>(7, pVersion1->cchMetadataOffset);
+                Assert::Equal<SIZE_T>(7, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);
diff --git a/src/libs/libs.cmd b/src/libs/libs.cmd
index 50a2db55..f44d88e4 100644
--- a/src/libs/libs.cmd
+++ b/src/libs/libs.cmd
@@ -11,7 +11,8 @@
 
 msbuild -Restore libs_t.proj -p:Configuration=%_C% -nologo -m -warnaserror -bl:%_L%\libs_build.binlog || exit /b
 
-msbuild dutil\test\DutilUnitTest -t:Test -p:Configuration=%_C% -nologo -p:CppCliTestResultsFile="%_L%\TestResults\DutilUnitTest.xunit2.xml" || exit /b
+msbuild dutil\test\DutilUnitTest -t:Test -p:Configuration=%_C% -p:Platform=Win32 -nologo -p:CppCliTestResultsFile="%_L%\TestResults\DutilUnitTest32.xunit2.xml" || exit /b
+msbuild dutil\test\DutilUnitTest -t:Test -p:Configuration=%_C% -p:Platform=x64 -nologo -p:CppCliTestResultsFile="%_L%\TestResults\DutilUnitTest64.xunit2.xml" || exit /b
 
 @popd
 @endlocal
diff --git a/src/testresultfilelist.txt b/src/testresultfilelist.txt
index 60fc168b..ca6e5a81 100644
--- a/src/testresultfilelist.txt
+++ b/src/testresultfilelist.txt
@@ -3,7 +3,8 @@ build/logs/TestResults/BalUtilUnitTest.xunit2.xml
 build/logs/TestResults/BextUtilUnitTest.xunit2.xml
 build/logs/TestResults/BurnUnitTest32.xunit2.xml
 build/logs/TestResults/BurnUnitTest64.xunit2.xml
-build/logs/TestResults/DutilUnitTest.xunit2.xml
+build/logs/TestResults/DutilUnitTest32.xunit2.xml
+build/logs/TestResults/DutilUnitTest64.xunit2.xml
 build/logs/TestResults/WixToolsetTest.Bal.trx
 build/logs/TestResults/WixToolsetTest.BuildTasks.trx
 build/logs/TestResults/WixToolsetTest.BurnE2E.trx
-- 
cgit v1.2.3-55-g6feb