@joebigelow / wix / commits / c4090531

Build and run x64 dutil tests.

Sean Hall committed Jun 15, 2022 at 17:08 UTC c4090531d4caac4b8cb3356cb971ff2e1c9f8704

8 files changed +81 -77

src/burn/burn_t.proj

+1 -1

@@ -1,7 +1,7 @@

1 <Project Sdk="Microsoft.Build.Traversal">

2 <ItemGroup>

3 - <ProjectReference Include="test\BurnUnitTest\BurnUnitTest.vcxproj" Properties="Platform=x86" BuildInParallel="false" />

3 <ProjectReference Include="test\BurnUnitTest\BurnUnitTest.vcxproj" Properties="Platform=x64" BuildInParallel="false" />

4 + <ProjectReference Include="test\BurnUnitTest\BurnUnitTest.vcxproj" Properties="Platform=x86" BuildInParallel="false" />

6 <ProjectReference Include="stub\stub.vcxproj" Properties="Platform=x86" />

7 <ProjectReference Include="stub\stub.vcxproj" Properties="Platform=x64" />

src/libs/dutil/dutil.sln

+6 -4

@@ -29,12 +29,14 @@ Global

29 {1244E671-F108-4334-BA52-8A7517F26ECD}.Release|x64.Build.0 = Release|x64

30 {1244E671-F108-4334-BA52-8A7517F26ECD}.Release|x86.ActiveCfg = Release|Win32

31 {1244E671-F108-4334-BA52-8A7517F26ECD}.Release|x86.Build.0 = Release|Win32

32 - {AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Debug|ARM64.ActiveCfg = Debug|Win32

33 - {AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Debug|x64.ActiveCfg = Debug|Win32

32 + {AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Debug|ARM64.ActiveCfg = Debug|x64

33 + {AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Debug|x64.ActiveCfg = Debug|x64

34 + {AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Debug|x64.Build.0 = Debug|x64

35 {AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Debug|x86.ActiveCfg = Debug|Win32

36 {AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Debug|x86.Build.0 = Debug|Win32

36 - {AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Release|ARM64.ActiveCfg = Release|Win32

37 - {AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Release|x64.ActiveCfg = Release|Win32

37 + {AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Release|ARM64.ActiveCfg = Release|x64

38 + {AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Release|x64.ActiveCfg = Release|x64

39 + {AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Release|x64.Build.0 = Release|x64

40 {AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Release|x86.ActiveCfg = Release|Win32

41 {AB7EE608-E5FB-42A5-831F-0DEEEA141223}.Release|x86.Build.0 = Release|Win32

42 EndGlobalSection

src/libs/dutil/dutil_t.proj

+1 -1

@@ -1,7 +1,7 @@

1 <Project Sdk="Microsoft.Build.Traversal">

2 <ItemGroup>

3 + <ProjectReference Include="test\DUtilUnitTest\DUtilUnitTest.vcxproj" Properties="Platform=x64" />

4 <ProjectReference Include="test\DUtilUnitTest\DUtilUnitTest.vcxproj" Properties="Platform=x86" />

4 - <ProjectReference Include="WixToolset.DUtil\dutil.vcxproj" Properties="Platform=x64" />

5 <ProjectReference Include="WixToolset.DUtil\dutil.vcxproj" Properties="Platform=ARM64" />

7 <ProjectReference Include="WixToolset.DUtil\dutil.vcxproj" Targets="PackNative" />

src/libs/dutil/test/DUtilUnitTest/FileUtilTest.cpp

+2 -2

@@ -58,9 +58,9 @@ namespace DutilTests

58 LPWSTR sczOutputPath = NULL;

59 FILE_ENCODING feEncodingFound = FILE_ENCODING_UNSPECIFIED;

60 BYTE *pbFile1 = NULL;

61 - DWORD cbFile1 = 0;

61 + SIZE_T cbFile1 = 0;

62 BYTE *pbFile2 = NULL;

63 - DWORD cbFile2 = 0;

63 + SIZE_T cbFile2 = 0;

64 size_t cbActualStringLength = 0;

66 try

src/libs/dutil/test/DUtilUnitTest/RegUtilTest.cpp

+2 -2

@@ -541,7 +541,7 @@ namespace DutilTests

541

542 hr = RegReadBinary(hkBase, L"Binary", &pbBuffer, &cbBuffer);

543 NativeAssert::Succeeded(hr, "Failed to read binary value.");

544 - Assert::Equal<DWORD>(4, cbBuffer);

544 + Assert::Equal<SIZE_T>(4, cbBuffer);

545 Assert::Equal<BYTE>(1, pbBuffer[0]);

546 Assert::Equal<BYTE>(2, pbBuffer[1]);

547 Assert::Equal<BYTE>(3, pbBuffer[2]);

@@ -581,7 +581,7 @@ namespace DutilTests

581

582 hr = RegReadBinary(hkBase, L"Binary", &pbBuffer, &cbBuffer);

583 NativeAssert::Succeeded(hr, "Failed to read binary value.");

584 - Assert::Equal<DWORD>(0, cbBuffer);

584 + Assert::Equal<SIZE_T>(0, cbBuffer);

585 }

586 finally

587 {

src/libs/dutil/test/DUtilUnitTest/VerUtilTests.cpp

+65 -65

@@ -40,7 +40,7 @@ namespace DutilTests

40 Assert::Equal<DWORD>(3, pVersion1->dwPatch);

41 Assert::Equal<DWORD>(4, pVersion1->dwRevision);

42 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);

43 - Assert::Equal<DWORD>(7, pVersion1->cchMetadataOffset);

43 + Assert::Equal<SIZE_T>(7, pVersion1->cchMetadataOffset);

44 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);

45 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);

46 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);

@@ -54,7 +54,7 @@ namespace DutilTests

54 Assert::Equal<DWORD>(3, pVersion2->dwPatch);

55 Assert::Equal<DWORD>(0, pVersion2->dwRevision);

56 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);

57 - Assert::Equal<DWORD>(5, pVersion2->cchMetadataOffset);

57 + Assert::Equal<SIZE_T>(5, pVersion2->cchMetadataOffset);

58 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);

59 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);

60 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor);

@@ -68,7 +68,7 @@ namespace DutilTests

68 Assert::Equal<DWORD>(3, pVersion3->dwPatch);

69 Assert::Equal<DWORD>(0, pVersion3->dwRevision);

70 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);

71 - Assert::Equal<DWORD>(7, pVersion3->cchMetadataOffset);

71 + Assert::Equal<SIZE_T>(7, pVersion3->cchMetadataOffset);

72 Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid);

73 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);

74 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor);

@@ -114,14 +114,14 @@ namespace DutilTests

114 Assert::Equal<BOOL>(TRUE, pVersion1->rgReleaseLabels[0].fNumeric);

115 Assert::Equal<DWORD>(2, pVersion1->rgReleaseLabels[0].dwValue);

116 Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[0].cchLabel);

117 - Assert::Equal<DWORD>(4, pVersion1->rgReleaseLabels[0].cchLabelOffset);

117 + Assert::Equal<SIZE_T>(4, pVersion1->rgReleaseLabels[0].cchLabelOffset);

118

119 Assert::Equal<BOOL>(TRUE, pVersion1->rgReleaseLabels[1].fNumeric);

120 Assert::Equal<DWORD>(0, pVersion1->rgReleaseLabels[1].dwValue);

121 Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[1].cchLabel);

122 - Assert::Equal<DWORD>(6, pVersion1->rgReleaseLabels[1].cchLabelOffset);

122 + Assert::Equal<SIZE_T>(6, pVersion1->rgReleaseLabels[1].cchLabelOffset);

123

124 - Assert::Equal<DWORD>(7, pVersion1->cchMetadataOffset);

124 + Assert::Equal<SIZE_T>(7, pVersion1->cchMetadataOffset);

125 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);

126 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);

127 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);

@@ -139,9 +139,9 @@ namespace DutilTests

139 Assert::Equal<BOOL>(TRUE, pVersion2->rgReleaseLabels[0].fNumeric);

140 Assert::Equal<DWORD>(19, pVersion2->rgReleaseLabels[0].dwValue);

141 Assert::Equal<DWORD>(2, pVersion2->rgReleaseLabels[0].cchLabel);

142 - Assert::Equal<DWORD>(4, pVersion2->rgReleaseLabels[0].cchLabelOffset);

142 + Assert::Equal<SIZE_T>(4, pVersion2->rgReleaseLabels[0].cchLabelOffset);

143

144 - Assert::Equal<DWORD>(6, pVersion2->cchMetadataOffset);

144 + Assert::Equal<SIZE_T>(6, pVersion2->cchMetadataOffset);

145 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);

146 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);

147 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor);

@@ -201,7 +201,7 @@ namespace DutilTests

201 Assert::Equal<DWORD>(0, pVersion1->dwPatch);

202 Assert::Equal<DWORD>(0, pVersion1->dwRevision);

203 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);

204 - Assert::Equal<DWORD>(3, pVersion1->cchMetadataOffset);

204 + Assert::Equal<SIZE_T>(3, pVersion1->cchMetadataOffset);

205 Assert::Equal<BOOL>(TRUE, pVersion1->fInvalid);

206 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);

207 Assert::Equal<BOOL>(FALSE, pVersion1->fHasMinor);

@@ -215,7 +215,7 @@ namespace DutilTests

215 Assert::Equal<DWORD>(0, pVersion2->dwPatch);

216 Assert::Equal<DWORD>(0, pVersion2->dwRevision);

217 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);

218 - Assert::Equal<DWORD>(3, pVersion2->cchMetadataOffset);

218 + Assert::Equal<SIZE_T>(3, pVersion2->cchMetadataOffset);

219 Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid);

220 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);

221 Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor);

@@ -229,7 +229,7 @@ namespace DutilTests

229 Assert::Equal<DWORD>(0, pVersion3->dwPatch);

230 Assert::Equal<DWORD>(0, pVersion3->dwRevision);

231 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);

232 - Assert::Equal<DWORD>(1, pVersion3->cchMetadataOffset);

232 + Assert::Equal<SIZE_T>(1, pVersion3->cchMetadataOffset);

233 Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid);

234 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);

235 Assert::Equal<BOOL>(FALSE, pVersion3->fHasMinor);

@@ -243,7 +243,7 @@ namespace DutilTests

243 Assert::Equal<DWORD>(0, pVersion4->dwPatch);

244 Assert::Equal<DWORD>(0, pVersion4->dwRevision);

245 Assert::Equal<DWORD>(0, pVersion4->cReleaseLabels);

246 - Assert::Equal<DWORD>(0, pVersion4->cchMetadataOffset);

246 + Assert::Equal<SIZE_T>(0, pVersion4->cchMetadataOffset);

247 Assert::Equal<BOOL>(TRUE, pVersion4->fInvalid);

248 Assert::Equal<BOOL>(FALSE, pVersion4->fHasMajor);

249 Assert::Equal<BOOL>(FALSE, pVersion4->fHasMinor);

@@ -261,9 +261,9 @@ namespace DutilTests

261 Assert::Equal<BOOL>(TRUE, pVersion5->rgReleaseLabels[0].fNumeric);

262 Assert::Equal<DWORD>(2, pVersion5->rgReleaseLabels[0].dwValue);

263 Assert::Equal<DWORD>(1, pVersion5->rgReleaseLabels[0].cchLabel);

264 - Assert::Equal<DWORD>(3, pVersion5->rgReleaseLabels[0].cchLabelOffset);

264 + Assert::Equal<SIZE_T>(3, pVersion5->rgReleaseLabels[0].cchLabelOffset);

265

266 - Assert::Equal<DWORD>(4, pVersion5->cchMetadataOffset);

266 + Assert::Equal<SIZE_T>(4, pVersion5->cchMetadataOffset);

267 Assert::Equal<BOOL>(FALSE, pVersion5->fInvalid);

268 Assert::Equal<BOOL>(TRUE, pVersion5->fHasMajor);

269 Assert::Equal<BOOL>(FALSE, pVersion5->fHasMinor);

@@ -281,9 +281,9 @@ namespace DutilTests

281 Assert::Equal<BOOL>(TRUE, pVersion6->rgReleaseLabels[0].fNumeric);

282 Assert::Equal<DWORD>(4, pVersion6->rgReleaseLabels[0].dwValue);

283 Assert::Equal<DWORD>(1, pVersion6->rgReleaseLabels[0].cchLabel);

284 - Assert::Equal<DWORD>(3, pVersion6->rgReleaseLabels[0].cchLabelOffset);

284 + Assert::Equal<SIZE_T>(3, pVersion6->rgReleaseLabels[0].cchLabelOffset);

285

286 - Assert::Equal<DWORD>(5, pVersion6->cchMetadataOffset);

286 + Assert::Equal<SIZE_T>(5, pVersion6->cchMetadataOffset);

287 Assert::Equal<BOOL>(TRUE, pVersion6->fInvalid);

288 Assert::Equal<BOOL>(TRUE, pVersion6->fHasMajor);

289 Assert::Equal<BOOL>(FALSE, pVersion6->fHasMinor);

@@ -337,9 +337,9 @@ namespace DutilTests

337

338 Assert::Equal<BOOL>(FALSE, pVersion1->rgReleaseLabels[0].fNumeric);

339 Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[0].cchLabel);

340 - Assert::Equal<DWORD>(6, pVersion1->rgReleaseLabels[0].cchLabelOffset);

340 + Assert::Equal<SIZE_T>(6, pVersion1->rgReleaseLabels[0].cchLabelOffset);

341

342 - Assert::Equal<DWORD>(7, pVersion1->cchMetadataOffset);

342 + Assert::Equal<SIZE_T>(7, pVersion1->cchMetadataOffset);

343 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);

344 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);

345 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);

@@ -357,9 +357,9 @@ namespace DutilTests

357 Assert::Equal<BOOL>(TRUE, pVersion2->rgReleaseLabels[0].fNumeric);

358 Assert::Equal<DWORD>(2, pVersion2->rgReleaseLabels[0].dwValue);

359 Assert::Equal<DWORD>(1, pVersion2->rgReleaseLabels[0].cchLabel);

360 - Assert::Equal<DWORD>(2, pVersion2->rgReleaseLabels[0].cchLabelOffset);

360 + Assert::Equal<SIZE_T>(2, pVersion2->rgReleaseLabels[0].cchLabelOffset);

361

362 - Assert::Equal<DWORD>(3, pVersion2->cchMetadataOffset);

362 + Assert::Equal<SIZE_T>(3, pVersion2->cchMetadataOffset);

363 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);

364 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);

365 Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor);

@@ -377,9 +377,9 @@ namespace DutilTests

377 Assert::Equal<BOOL>(TRUE, pVersion3->rgReleaseLabels[0].fNumeric);

378 Assert::Equal<DWORD>(2, pVersion3->rgReleaseLabels[0].dwValue);

379 Assert::Equal<DWORD>(1, pVersion3->rgReleaseLabels[0].cchLabel);

380 - Assert::Equal<DWORD>(2, pVersion3->rgReleaseLabels[0].cchLabelOffset);

380 + Assert::Equal<SIZE_T>(2, pVersion3->rgReleaseLabels[0].cchLabelOffset);

381

382 - Assert::Equal<DWORD>(3, pVersion3->cchMetadataOffset);

382 + Assert::Equal<SIZE_T>(3, pVersion3->cchMetadataOffset);

383 Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid);

384 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);

385 Assert::Equal<BOOL>(FALSE, pVersion3->fHasMinor);

@@ -434,14 +434,14 @@ namespace DutilTests

434

435 Assert::Equal<BOOL>(FALSE, pVersion1->rgReleaseLabels[0].fNumeric);

436 Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[0].cchLabel);

437 - Assert::Equal<DWORD>(5, pVersion1->rgReleaseLabels[0].cchLabelOffset);

437 + Assert::Equal<SIZE_T>(5, pVersion1->rgReleaseLabels[0].cchLabelOffset);

438

439 Assert::Equal<BOOL>(TRUE, pVersion1->rgReleaseLabels[1].fNumeric);

440 Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[1].dwValue);

441 Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[1].cchLabel);

442 - Assert::Equal<DWORD>(7, pVersion1->rgReleaseLabels[1].cchLabelOffset);

442 + Assert::Equal<SIZE_T>(7, pVersion1->rgReleaseLabels[1].cchLabelOffset);

443

444 - Assert::Equal<DWORD>(8, pVersion1->cchMetadataOffset);

444 + Assert::Equal<SIZE_T>(8, pVersion1->cchMetadataOffset);

445 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);

446 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);

447 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);

@@ -458,14 +458,14 @@ namespace DutilTests

458

459 Assert::Equal<BOOL>(FALSE, pVersion2->rgReleaseLabels[0].fNumeric);

460 Assert::Equal<DWORD>(1, pVersion2->rgReleaseLabels[0].cchLabel);

461 - Assert::Equal<DWORD>(6, pVersion2->rgReleaseLabels[0].cchLabelOffset);

461 + Assert::Equal<SIZE_T>(6, pVersion2->rgReleaseLabels[0].cchLabelOffset);

462

463 Assert::Equal<BOOL>(TRUE, pVersion2->rgReleaseLabels[1].fNumeric);

464 Assert::Equal<DWORD>(1, pVersion2->rgReleaseLabels[1].dwValue);

465 Assert::Equal<DWORD>(1, pVersion2->rgReleaseLabels[1].cchLabel);

466 - Assert::Equal<DWORD>(8, pVersion2->rgReleaseLabels[1].cchLabelOffset);

466 + Assert::Equal<SIZE_T>(8, pVersion2->rgReleaseLabels[1].cchLabelOffset);

467

468 - Assert::Equal<DWORD>(9, pVersion2->cchMetadataOffset);

468 + Assert::Equal<SIZE_T>(9, pVersion2->cchMetadataOffset);

469 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);

470 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);

471 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor);

@@ -482,18 +482,18 @@ namespace DutilTests

482

483 Assert::Equal<BOOL>(FALSE, pVersion3->rgReleaseLabels[0].fNumeric);

484 Assert::Equal<DWORD>(1, pVersion3->rgReleaseLabels[0].cchLabel);

485 - Assert::Equal<DWORD>(4, pVersion3->rgReleaseLabels[0].cchLabelOffset);

485 + Assert::Equal<SIZE_T>(4, pVersion3->rgReleaseLabels[0].cchLabelOffset);

486

487 Assert::Equal<BOOL>(FALSE, pVersion3->rgReleaseLabels[1].fNumeric);

488 Assert::Equal<DWORD>(1, pVersion3->rgReleaseLabels[1].cchLabel);

489 - Assert::Equal<DWORD>(6, pVersion3->rgReleaseLabels[1].cchLabelOffset);

489 + Assert::Equal<SIZE_T>(6, pVersion3->rgReleaseLabels[1].cchLabelOffset);

490

491 Assert::Equal<BOOL>(TRUE, pVersion3->rgReleaseLabels[2].fNumeric);

492 Assert::Equal<DWORD>(0, pVersion3->rgReleaseLabels[2].dwValue);

493 Assert::Equal<DWORD>(1, pVersion3->rgReleaseLabels[2].cchLabel);

494 - Assert::Equal<DWORD>(8, pVersion3->rgReleaseLabels[2].cchLabelOffset);

494 + Assert::Equal<SIZE_T>(8, pVersion3->rgReleaseLabels[2].cchLabelOffset);

495

496 - Assert::Equal<DWORD>(9, pVersion3->cchMetadataOffset);

496 + Assert::Equal<SIZE_T>(9, pVersion3->cchMetadataOffset);

497 Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid);

498 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);

499 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor);

@@ -510,18 +510,18 @@ namespace DutilTests

510

511 Assert::Equal<BOOL>(FALSE, pVersion4->rgReleaseLabels[0].fNumeric);

512 Assert::Equal<DWORD>(1, pVersion4->rgReleaseLabels[0].cchLabel);

513 - Assert::Equal<DWORD>(6, pVersion4->rgReleaseLabels[0].cchLabelOffset);

513 + Assert::Equal<SIZE_T>(6, pVersion4->rgReleaseLabels[0].cchLabelOffset);

514

515 Assert::Equal<BOOL>(FALSE, pVersion4->rgReleaseLabels[1].fNumeric);

516 Assert::Equal<DWORD>(1, pVersion4->rgReleaseLabels[1].cchLabel);

517 - Assert::Equal<DWORD>(8, pVersion4->rgReleaseLabels[1].cchLabelOffset);

517 + Assert::Equal<SIZE_T>(8, pVersion4->rgReleaseLabels[1].cchLabelOffset);

518

519 Assert::Equal<BOOL>(TRUE, pVersion4->rgReleaseLabels[2].fNumeric);

520 Assert::Equal<DWORD>(0, pVersion4->rgReleaseLabels[2].dwValue);

521 Assert::Equal<DWORD>(3, pVersion4->rgReleaseLabels[2].cchLabel);

522 - Assert::Equal<DWORD>(10, pVersion4->rgReleaseLabels[2].cchLabelOffset);

522 + Assert::Equal<SIZE_T>(10, pVersion4->rgReleaseLabels[2].cchLabelOffset);

523

524 - Assert::Equal<DWORD>(13, pVersion4->cchMetadataOffset);

524 + Assert::Equal<SIZE_T>(13, pVersion4->cchMetadataOffset);

525 Assert::Equal<BOOL>(FALSE, pVersion4->fInvalid);

526 Assert::Equal<BOOL>(TRUE, pVersion4->fHasMajor);

527 Assert::Equal<BOOL>(TRUE, pVersion4->fHasMinor);

@@ -569,7 +569,7 @@ namespace DutilTests

569 Assert::Equal<DWORD>(3, pVersion1->dwPatch);

570 Assert::Equal<DWORD>(0, pVersion1->dwRevision);

571 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);

572 - Assert::Equal<DWORD>(6, pVersion1->cchMetadataOffset);

572 + Assert::Equal<SIZE_T>(6, pVersion1->cchMetadataOffset);

573 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);

574 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);

575 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);

@@ -583,7 +583,7 @@ namespace DutilTests

583 Assert::Equal<DWORD>(3, pVersion2->dwPatch);

584 Assert::Equal<DWORD>(0, pVersion2->dwRevision);

585 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);

586 - Assert::Equal<DWORD>(6, pVersion2->cchMetadataOffset);

586 + Assert::Equal<SIZE_T>(6, pVersion2->cchMetadataOffset);

587 Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid);

588 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);

589 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor);

@@ -597,7 +597,7 @@ namespace DutilTests

597 Assert::Equal<DWORD>(3, pVersion3->dwPatch);

598 Assert::Equal<DWORD>(0, pVersion3->dwRevision);

599 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);

600 - Assert::Equal<DWORD>(6, pVersion3->cchMetadataOffset);

600 + Assert::Equal<SIZE_T>(6, pVersion3->cchMetadataOffset);

601 Assert::Equal<BOOL>(TRUE, pVersion3->fInvalid);

602 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);

603 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor);

@@ -655,7 +655,7 @@ namespace DutilTests

655 Assert::Equal<DWORD>(30, pVersion1->dwPatch);

656 Assert::Equal<DWORD>(40, pVersion1->dwRevision);

657 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);

658 - Assert::Equal<DWORD>(11, pVersion1->cchMetadataOffset);

658 + Assert::Equal<SIZE_T>(11, pVersion1->cchMetadataOffset);

659 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);

660 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);

661 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);

@@ -669,7 +669,7 @@ namespace DutilTests

669 Assert::Equal<DWORD>(30, pVersion2->dwPatch);

670 Assert::Equal<DWORD>(40, pVersion2->dwRevision);

671 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);

672 - Assert::Equal<DWORD>(11, pVersion2->cchMetadataOffset);

672 + Assert::Equal<SIZE_T>(11, pVersion2->cchMetadataOffset);

673 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);

674 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);

675 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor);

@@ -683,7 +683,7 @@ namespace DutilTests

683 Assert::Equal<DWORD>(30, pVersion3->dwPatch);

684 Assert::Equal<DWORD>(40, pVersion3->dwRevision);

685 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);

686 - Assert::Equal<DWORD>(11, pVersion3->cchMetadataOffset);

686 + Assert::Equal<SIZE_T>(11, pVersion3->cchMetadataOffset);

687 Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid);

688 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);

689 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor);

@@ -700,9 +700,9 @@ namespace DutilTests

700

701 Assert::Equal<BOOL>(FALSE, pVersion4->rgReleaseLabels[0].fNumeric);

702 Assert::Equal<DWORD>(3, pVersion4->rgReleaseLabels[0].cchLabel);

703 - Assert::Equal<DWORD>(12, pVersion4->rgReleaseLabels[0].cchLabelOffset);

703 + Assert::Equal<SIZE_T>(12, pVersion4->rgReleaseLabels[0].cchLabelOffset);

704

705 - Assert::Equal<DWORD>(15, pVersion4->cchMetadataOffset);

705 + Assert::Equal<SIZE_T>(15, pVersion4->cchMetadataOffset);

706 Assert::Equal<BOOL>(FALSE, pVersion4->fInvalid);

707 Assert::Equal<BOOL>(TRUE, pVersion4->fHasMajor);

708 Assert::Equal<BOOL>(TRUE, pVersion4->fHasMinor);

@@ -716,7 +716,7 @@ namespace DutilTests

716 Assert::Equal<DWORD>(0, pVersion5->dwPatch);

717 Assert::Equal<DWORD>(0, pVersion5->dwRevision);

718 Assert::Equal<DWORD>(0, pVersion5->cReleaseLabels);

719 - Assert::Equal<DWORD>(0, pVersion5->cchMetadataOffset);

719 + Assert::Equal<SIZE_T>(0, pVersion5->cchMetadataOffset);

720 Assert::Equal<BOOL>(TRUE, pVersion5->fInvalid);

721 Assert::Equal<BOOL>(FALSE, pVersion5->fHasMajor);

722 Assert::Equal<BOOL>(FALSE, pVersion5->fHasMinor);

@@ -761,7 +761,7 @@ namespace DutilTests

761 Assert::Equal<DWORD>(4294967295, pVersion1->dwPatch);

762 Assert::Equal<DWORD>(4294967295, pVersion1->dwRevision);

763 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);

764 - Assert::Equal<DWORD>(43, pVersion1->cchMetadataOffset);

764 + Assert::Equal<SIZE_T>(43, pVersion1->cchMetadataOffset);

765 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);

766 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);

767 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);

@@ -775,7 +775,7 @@ namespace DutilTests

775 Assert::Equal<DWORD>(0, pVersion2->dwPatch);

776 Assert::Equal<DWORD>(0, pVersion2->dwRevision);

777 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);

778 - Assert::Equal<DWORD>(0, pVersion2->cchMetadataOffset);

778 + Assert::Equal<SIZE_T>(0, pVersion2->cchMetadataOffset);

779 Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid);

780 Assert::Equal<BOOL>(FALSE, pVersion2->fHasMajor);

781 Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor);

@@ -815,7 +815,7 @@ namespace DutilTests

815 Assert::Equal<DWORD>(3, pVersion1->dwPatch);

816 Assert::Equal<DWORD>(0, pVersion1->dwRevision);

817 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);

818 - Assert::Equal<DWORD>(6, pVersion1->cchMetadataOffset);

818 + Assert::Equal<SIZE_T>(6, pVersion1->cchMetadataOffset);

819 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);

820 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);

821 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);

@@ -829,7 +829,7 @@ namespace DutilTests

829 Assert::Equal<DWORD>(3, pVersion2->dwPatch);

830 Assert::Equal<DWORD>(0, pVersion2->dwRevision);

831 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);

832 - Assert::Equal<DWORD>(6, pVersion2->cchMetadataOffset);

832 + Assert::Equal<SIZE_T>(6, pVersion2->cchMetadataOffset);

833 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);

834 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);

835 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor);

@@ -867,7 +867,7 @@ namespace DutilTests

867 Assert::Equal<DWORD>(4, pSource->dwRevision);

868 Assert::Equal<DWORD>(0, pSource->cReleaseLabels);

869

870 - Assert::Equal<DWORD>(8, pSource->cchMetadataOffset);

870 + Assert::Equal<SIZE_T>(8, pSource->cchMetadataOffset);

871 Assert::Equal<BOOL>(FALSE, pSource->fInvalid);

872 Assert::Equal<BOOL>(TRUE, pSource->fHasMajor);

873 Assert::Equal<BOOL>(TRUE, pSource->fHasMinor);

@@ -921,26 +921,26 @@ namespace DutilTests

921

922 Assert::Equal<BOOL>(FALSE, pSource->rgReleaseLabels[0].fNumeric);

923 Assert::Equal<DWORD>(1, pSource->rgReleaseLabels[0].cchLabel);

924 - Assert::Equal<DWORD>(8, pSource->rgReleaseLabels[0].cchLabelOffset);

924 + Assert::Equal<SIZE_T>(8, pSource->rgReleaseLabels[0].cchLabelOffset);

925

926 Assert::Equal<BOOL>(FALSE, pSource->rgReleaseLabels[1].fNumeric);

927 Assert::Equal<DWORD>(1, pSource->rgReleaseLabels[1].cchLabel);

928 - Assert::Equal<DWORD>(10, pSource->rgReleaseLabels[1].cchLabelOffset);

928 + Assert::Equal<SIZE_T>(10, pSource->rgReleaseLabels[1].cchLabelOffset);

929

930 Assert::Equal<BOOL>(FALSE, pSource->rgReleaseLabels[2].fNumeric);

931 Assert::Equal<DWORD>(1, pSource->rgReleaseLabels[2].cchLabel);

932 - Assert::Equal<DWORD>(12, pSource->rgReleaseLabels[2].cchLabelOffset);

932 + Assert::Equal<SIZE_T>(12, pSource->rgReleaseLabels[2].cchLabelOffset);

933

934 Assert::Equal<BOOL>(FALSE, pSource->rgReleaseLabels[3].fNumeric);

935 Assert::Equal<DWORD>(1, pSource->rgReleaseLabels[3].cchLabel);

936 - Assert::Equal<DWORD>(14, pSource->rgReleaseLabels[3].cchLabelOffset);

936 + Assert::Equal<SIZE_T>(14, pSource->rgReleaseLabels[3].cchLabelOffset);

937

938 Assert::Equal<BOOL>(TRUE, pSource->rgReleaseLabels[4].fNumeric);

939 Assert::Equal<DWORD>(5, pSource->rgReleaseLabels[4].dwValue);

940 Assert::Equal<DWORD>(1, pSource->rgReleaseLabels[4].cchLabel);

941 - Assert::Equal<DWORD>(16, pSource->rgReleaseLabels[4].cchLabelOffset);

941 + Assert::Equal<SIZE_T>(16, pSource->rgReleaseLabels[4].cchLabelOffset);

942

943 - Assert::Equal<DWORD>(18, pSource->cchMetadataOffset);

943 + Assert::Equal<SIZE_T>(18, pSource->cchMetadataOffset);

944 Assert::Equal<BOOL>(TRUE, pSource->fInvalid);

945 Assert::Equal<BOOL>(TRUE, pSource->fHasMajor);

946 Assert::Equal<BOOL>(TRUE, pSource->fHasMinor);

@@ -1020,7 +1020,7 @@ namespace DutilTests

1020 Assert::Equal<DWORD>(0, pVersion1->dwPatch);

1021 Assert::Equal<DWORD>(0, pVersion1->dwRevision);

1022 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);

1023 - Assert::Equal<DWORD>(0, pVersion1->cchMetadataOffset);

1023 + Assert::Equal<SIZE_T>(0, pVersion1->cchMetadataOffset);

1024 Assert::Equal<BOOL>(TRUE, pVersion1->fInvalid);

1025 Assert::Equal<BOOL>(FALSE, pVersion1->fHasMajor);

1026 Assert::Equal<BOOL>(FALSE, pVersion1->fHasMinor);

@@ -1034,7 +1034,7 @@ namespace DutilTests

1034 Assert::Equal<DWORD>(0, pVersion2->dwPatch);

1035 Assert::Equal<DWORD>(0, pVersion2->dwRevision);

1036 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);

1037 - Assert::Equal<DWORD>(2, pVersion2->cchMetadataOffset);

1037 + Assert::Equal<SIZE_T>(2, pVersion2->cchMetadataOffset);

1038 Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid);

1039 Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);

1040 Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor);

@@ -1048,7 +1048,7 @@ namespace DutilTests

1048 Assert::Equal<DWORD>(0, pVersion3->dwPatch);

1049 Assert::Equal<DWORD>(0, pVersion3->dwRevision);

1050 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);

1051 - Assert::Equal<DWORD>(4, pVersion3->cchMetadataOffset);

1051 + Assert::Equal<SIZE_T>(4, pVersion3->cchMetadataOffset);

1052 Assert::Equal<BOOL>(TRUE, pVersion3->fInvalid);

1053 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);

1054 Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor);

@@ -1062,7 +1062,7 @@ namespace DutilTests

1062 Assert::Equal<DWORD>(1, pVersion4->dwPatch);

1063 Assert::Equal<DWORD>(0, pVersion4->dwRevision);

1064 Assert::Equal<DWORD>(0, pVersion4->cReleaseLabels);

1065 - Assert::Equal<DWORD>(6, pVersion4->cchMetadataOffset);

1065 + Assert::Equal<SIZE_T>(6, pVersion4->cchMetadataOffset);

1066 Assert::Equal<BOOL>(TRUE, pVersion4->fInvalid);

1067 Assert::Equal<BOOL>(TRUE, pVersion4->fHasMajor);

1068 Assert::Equal<BOOL>(TRUE, pVersion4->fHasMinor);

@@ -1076,7 +1076,7 @@ namespace DutilTests

1076 Assert::Equal<DWORD>(2, pVersion5->dwPatch);

1077 Assert::Equal<DWORD>(1, pVersion5->dwRevision);

1078 Assert::Equal<DWORD>(0, pVersion5->cReleaseLabels);

1079 - Assert::Equal<DWORD>(8, pVersion5->cchMetadataOffset);

1079 + Assert::Equal<SIZE_T>(8, pVersion5->cchMetadataOffset);

1080 Assert::Equal<BOOL>(TRUE, pVersion5->fInvalid);

1081 Assert::Equal<BOOL>(TRUE, pVersion5->fHasMajor);

1082 Assert::Equal<BOOL>(TRUE, pVersion5->fHasMinor);

@@ -1090,7 +1090,7 @@ namespace DutilTests

1090 Assert::Equal<DWORD>(0, pVersion6->dwPatch);

1091 Assert::Equal<DWORD>(0, pVersion6->dwRevision);

1092 Assert::Equal<DWORD>(0, pVersion6->cReleaseLabels);

1093 - Assert::Equal<DWORD>(2, pVersion6->cchMetadataOffset);

1093 + Assert::Equal<SIZE_T>(2, pVersion6->cchMetadataOffset);

1094 Assert::Equal<BOOL>(TRUE, pVersion6->fInvalid);

1095 Assert::Equal<BOOL>(TRUE, pVersion6->fHasMajor);

1096 Assert::Equal<BOOL>(FALSE, pVersion6->fHasMinor);

@@ -1107,9 +1107,9 @@ namespace DutilTests

1107

1108 Assert::Equal<BOOL>(FALSE, pVersion7->rgReleaseLabels[0].fNumeric);

1109 Assert::Equal<DWORD>(1, pVersion7->rgReleaseLabels[0].cchLabel);

1110 - Assert::Equal<DWORD>(2, pVersion7->rgReleaseLabels[0].cchLabelOffset);

1110 + Assert::Equal<SIZE_T>(2, pVersion7->rgReleaseLabels[0].cchLabelOffset);

1111

1112 - Assert::Equal<DWORD>(4, pVersion7->cchMetadataOffset);

1112 + Assert::Equal<SIZE_T>(4, pVersion7->cchMetadataOffset);

1113 Assert::Equal<BOOL>(TRUE, pVersion7->fInvalid);

1114 Assert::Equal<BOOL>(TRUE, pVersion7->fHasMajor);

1115 Assert::Equal<BOOL>(FALSE, pVersion7->fHasMinor);

@@ -1146,7 +1146,7 @@ namespace DutilTests

1146 Assert::Equal<DWORD>(3, pVersion1->dwPatch);

1147 Assert::Equal<DWORD>(4, pVersion1->dwRevision);

1148 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);

1149 - Assert::Equal<DWORD>(7, pVersion1->cchMetadataOffset);

1149 + Assert::Equal<SIZE_T>(7, pVersion1->cchMetadataOffset);

1150 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);

1151 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);

1152 Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);

src/libs/libs.cmd

+2 -1

@@ -11,7 +11,8 @@

12 msbuild -Restore libs_t.proj -p:Configuration=%_C% -nologo -m -warnaserror -bl:%_L%\libs_build.binlog || exit /b

14 -msbuild dutil\test\DutilUnitTest -t:Test -p:Configuration=%_C% -nologo -p:CppCliTestResultsFile="%_L%\TestResults\DutilUnitTest.xunit2.xml" || exit /b

14 +msbuild dutil\test\DutilUnitTest -t:Test -p:Configuration=%_C% -p:Platform=Win32 -nologo -p:CppCliTestResultsFile="%_L%\TestResults\DutilUnitTest32.xunit2.xml" || exit /b

15 +msbuild dutil\test\DutilUnitTest -t:Test -p:Configuration=%_C% -p:Platform=x64 -nologo -p:CppCliTestResultsFile="%_L%\TestResults\DutilUnitTest64.xunit2.xml" || exit /b

17 @popd

18 @endlocal

src/testresultfilelist.txt

+2 -1

@@ -3,7 +3,8 @@ build/logs/TestResults/BalUtilUnitTest.xunit2.xml

3 build/logs/TestResults/BextUtilUnitTest.xunit2.xml

4 build/logs/TestResults/BurnUnitTest32.xunit2.xml

5 build/logs/TestResults/BurnUnitTest64.xunit2.xml

6 -build/logs/TestResults/DutilUnitTest.xunit2.xml

6 +build/logs/TestResults/DutilUnitTest32.xunit2.xml

7 +build/logs/TestResults/DutilUnitTest64.xunit2.xml

8 build/logs/TestResults/WixToolsetTest.Bal.trx

9 build/logs/TestResults/WixToolsetTest.BuildTasks.trx

10 build/logs/TestResults/WixToolsetTest.BurnE2E.trx