diff options
author | Sean Hall <r.sean.hall@gmail.com> | 2022-06-15 17:08:04 -0500 |
---|---|---|
committer | Sean Hall <r.sean.hall@gmail.com> | 2022-06-15 18:27:22 -0500 |
commit | c4090531d4caac4b8cb3356cb971ff2e1c9f8704 (patch) | |
tree | 95fb6f68690da8d79f23e3b0e957f28eef036797 /src/libs/dutil/test/DUtilUnitTest | |
parent | 09501680d4fcef277b33200c702ce409e9f9c1ef (diff) | |
download | wix-c4090531d4caac4b8cb3356cb971ff2e1c9f8704.tar.gz wix-c4090531d4caac4b8cb3356cb971ff2e1c9f8704.tar.bz2 wix-c4090531d4caac4b8cb3356cb971ff2e1c9f8704.zip |
Build and run x64 dutil tests.
Diffstat (limited to 'src/libs/dutil/test/DUtilUnitTest')
-rw-r--r-- | src/libs/dutil/test/DUtilUnitTest/FileUtilTest.cpp | 4 | ||||
-rw-r--r-- | src/libs/dutil/test/DUtilUnitTest/RegUtilTest.cpp | 4 | ||||
-rw-r--r-- | src/libs/dutil/test/DUtilUnitTest/VerUtilTests.cpp | 130 |
3 files changed, 69 insertions, 69 deletions
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 | |||
58 | LPWSTR sczOutputPath = NULL; | 58 | LPWSTR sczOutputPath = NULL; |
59 | FILE_ENCODING feEncodingFound = FILE_ENCODING_UNSPECIFIED; | 59 | FILE_ENCODING feEncodingFound = FILE_ENCODING_UNSPECIFIED; |
60 | BYTE *pbFile1 = NULL; | 60 | BYTE *pbFile1 = NULL; |
61 | DWORD cbFile1 = 0; | 61 | SIZE_T cbFile1 = 0; |
62 | BYTE *pbFile2 = NULL; | 62 | BYTE *pbFile2 = NULL; |
63 | DWORD cbFile2 = 0; | 63 | SIZE_T cbFile2 = 0; |
64 | size_t cbActualStringLength = 0; | 64 | size_t cbActualStringLength = 0; |
65 | 65 | ||
66 | try | 66 | 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 | |||
541 | 541 | ||
542 | hr = RegReadBinary(hkBase, L"Binary", &pbBuffer, &cbBuffer); | 542 | hr = RegReadBinary(hkBase, L"Binary", &pbBuffer, &cbBuffer); |
543 | NativeAssert::Succeeded(hr, "Failed to read binary value."); | 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]); | 545 | Assert::Equal<BYTE>(1, pbBuffer[0]); |
546 | Assert::Equal<BYTE>(2, pbBuffer[1]); | 546 | Assert::Equal<BYTE>(2, pbBuffer[1]); |
547 | Assert::Equal<BYTE>(3, pbBuffer[2]); | 547 | Assert::Equal<BYTE>(3, pbBuffer[2]); |
@@ -581,7 +581,7 @@ namespace DutilTests | |||
581 | 581 | ||
582 | hr = RegReadBinary(hkBase, L"Binary", &pbBuffer, &cbBuffer); | 582 | hr = RegReadBinary(hkBase, L"Binary", &pbBuffer, &cbBuffer); |
583 | NativeAssert::Succeeded(hr, "Failed to read binary value."); | 583 | NativeAssert::Succeeded(hr, "Failed to read binary value."); |
584 | Assert::Equal<DWORD>(0, cbBuffer); | 584 | Assert::Equal<SIZE_T>(0, cbBuffer); |
585 | } | 585 | } |
586 | finally | 586 | finally |
587 | { | 587 | { |
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 | |||
40 | Assert::Equal<DWORD>(3, pVersion1->dwPatch); | 40 | Assert::Equal<DWORD>(3, pVersion1->dwPatch); |
41 | Assert::Equal<DWORD>(4, pVersion1->dwRevision); | 41 | Assert::Equal<DWORD>(4, pVersion1->dwRevision); |
42 | Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels); | 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); | 44 | Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid); |
45 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); | 45 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); |
46 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor); | 46 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor); |
@@ -54,7 +54,7 @@ namespace DutilTests | |||
54 | Assert::Equal<DWORD>(3, pVersion2->dwPatch); | 54 | Assert::Equal<DWORD>(3, pVersion2->dwPatch); |
55 | Assert::Equal<DWORD>(0, pVersion2->dwRevision); | 55 | Assert::Equal<DWORD>(0, pVersion2->dwRevision); |
56 | Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels); | 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); | 58 | Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid); |
59 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor); | 59 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor); |
60 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor); | 60 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor); |
@@ -68,7 +68,7 @@ namespace DutilTests | |||
68 | Assert::Equal<DWORD>(3, pVersion3->dwPatch); | 68 | Assert::Equal<DWORD>(3, pVersion3->dwPatch); |
69 | Assert::Equal<DWORD>(0, pVersion3->dwRevision); | 69 | Assert::Equal<DWORD>(0, pVersion3->dwRevision); |
70 | Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels); | 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); | 72 | Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid); |
73 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor); | 73 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor); |
74 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor); | 74 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor); |
@@ -114,14 +114,14 @@ namespace DutilTests | |||
114 | Assert::Equal<BOOL>(TRUE, pVersion1->rgReleaseLabels[0].fNumeric); | 114 | Assert::Equal<BOOL>(TRUE, pVersion1->rgReleaseLabels[0].fNumeric); |
115 | Assert::Equal<DWORD>(2, pVersion1->rgReleaseLabels[0].dwValue); | 115 | Assert::Equal<DWORD>(2, pVersion1->rgReleaseLabels[0].dwValue); |
116 | Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[0].cchLabel); | 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 | 118 | ||
119 | Assert::Equal<BOOL>(TRUE, pVersion1->rgReleaseLabels[1].fNumeric); | 119 | Assert::Equal<BOOL>(TRUE, pVersion1->rgReleaseLabels[1].fNumeric); |
120 | Assert::Equal<DWORD>(0, pVersion1->rgReleaseLabels[1].dwValue); | 120 | Assert::Equal<DWORD>(0, pVersion1->rgReleaseLabels[1].dwValue); |
121 | Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[1].cchLabel); | 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 | 123 | ||
124 | Assert::Equal<DWORD>(7, pVersion1->cchMetadataOffset); | 124 | Assert::Equal<SIZE_T>(7, pVersion1->cchMetadataOffset); |
125 | Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid); | 125 | Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid); |
126 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); | 126 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); |
127 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor); | 127 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor); |
@@ -139,9 +139,9 @@ namespace DutilTests | |||
139 | Assert::Equal<BOOL>(TRUE, pVersion2->rgReleaseLabels[0].fNumeric); | 139 | Assert::Equal<BOOL>(TRUE, pVersion2->rgReleaseLabels[0].fNumeric); |
140 | Assert::Equal<DWORD>(19, pVersion2->rgReleaseLabels[0].dwValue); | 140 | Assert::Equal<DWORD>(19, pVersion2->rgReleaseLabels[0].dwValue); |
141 | Assert::Equal<DWORD>(2, pVersion2->rgReleaseLabels[0].cchLabel); | 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 | 143 | ||
144 | Assert::Equal<DWORD>(6, pVersion2->cchMetadataOffset); | 144 | Assert::Equal<SIZE_T>(6, pVersion2->cchMetadataOffset); |
145 | Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid); | 145 | Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid); |
146 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor); | 146 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor); |
147 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor); | 147 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor); |
@@ -201,7 +201,7 @@ namespace DutilTests | |||
201 | Assert::Equal<DWORD>(0, pVersion1->dwPatch); | 201 | Assert::Equal<DWORD>(0, pVersion1->dwPatch); |
202 | Assert::Equal<DWORD>(0, pVersion1->dwRevision); | 202 | Assert::Equal<DWORD>(0, pVersion1->dwRevision); |
203 | Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels); | 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); | 205 | Assert::Equal<BOOL>(TRUE, pVersion1->fInvalid); |
206 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); | 206 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); |
207 | Assert::Equal<BOOL>(FALSE, pVersion1->fHasMinor); | 207 | Assert::Equal<BOOL>(FALSE, pVersion1->fHasMinor); |
@@ -215,7 +215,7 @@ namespace DutilTests | |||
215 | Assert::Equal<DWORD>(0, pVersion2->dwPatch); | 215 | Assert::Equal<DWORD>(0, pVersion2->dwPatch); |
216 | Assert::Equal<DWORD>(0, pVersion2->dwRevision); | 216 | Assert::Equal<DWORD>(0, pVersion2->dwRevision); |
217 | Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels); | 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); | 219 | Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid); |
220 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor); | 220 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor); |
221 | Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor); | 221 | Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor); |
@@ -229,7 +229,7 @@ namespace DutilTests | |||
229 | Assert::Equal<DWORD>(0, pVersion3->dwPatch); | 229 | Assert::Equal<DWORD>(0, pVersion3->dwPatch); |
230 | Assert::Equal<DWORD>(0, pVersion3->dwRevision); | 230 | Assert::Equal<DWORD>(0, pVersion3->dwRevision); |
231 | Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels); | 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); | 233 | Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid); |
234 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor); | 234 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor); |
235 | Assert::Equal<BOOL>(FALSE, pVersion3->fHasMinor); | 235 | Assert::Equal<BOOL>(FALSE, pVersion3->fHasMinor); |
@@ -243,7 +243,7 @@ namespace DutilTests | |||
243 | Assert::Equal<DWORD>(0, pVersion4->dwPatch); | 243 | Assert::Equal<DWORD>(0, pVersion4->dwPatch); |
244 | Assert::Equal<DWORD>(0, pVersion4->dwRevision); | 244 | Assert::Equal<DWORD>(0, pVersion4->dwRevision); |
245 | Assert::Equal<DWORD>(0, pVersion4->cReleaseLabels); | 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); | 247 | Assert::Equal<BOOL>(TRUE, pVersion4->fInvalid); |
248 | Assert::Equal<BOOL>(FALSE, pVersion4->fHasMajor); | 248 | Assert::Equal<BOOL>(FALSE, pVersion4->fHasMajor); |
249 | Assert::Equal<BOOL>(FALSE, pVersion4->fHasMinor); | 249 | Assert::Equal<BOOL>(FALSE, pVersion4->fHasMinor); |
@@ -261,9 +261,9 @@ namespace DutilTests | |||
261 | Assert::Equal<BOOL>(TRUE, pVersion5->rgReleaseLabels[0].fNumeric); | 261 | Assert::Equal<BOOL>(TRUE, pVersion5->rgReleaseLabels[0].fNumeric); |
262 | Assert::Equal<DWORD>(2, pVersion5->rgReleaseLabels[0].dwValue); | 262 | Assert::Equal<DWORD>(2, pVersion5->rgReleaseLabels[0].dwValue); |
263 | Assert::Equal<DWORD>(1, pVersion5->rgReleaseLabels[0].cchLabel); | 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 | 265 | ||
266 | Assert::Equal<DWORD>(4, pVersion5->cchMetadataOffset); | 266 | Assert::Equal<SIZE_T>(4, pVersion5->cchMetadataOffset); |
267 | Assert::Equal<BOOL>(FALSE, pVersion5->fInvalid); | 267 | Assert::Equal<BOOL>(FALSE, pVersion5->fInvalid); |
268 | Assert::Equal<BOOL>(TRUE, pVersion5->fHasMajor); | 268 | Assert::Equal<BOOL>(TRUE, pVersion5->fHasMajor); |
269 | Assert::Equal<BOOL>(FALSE, pVersion5->fHasMinor); | 269 | Assert::Equal<BOOL>(FALSE, pVersion5->fHasMinor); |
@@ -281,9 +281,9 @@ namespace DutilTests | |||
281 | Assert::Equal<BOOL>(TRUE, pVersion6->rgReleaseLabels[0].fNumeric); | 281 | Assert::Equal<BOOL>(TRUE, pVersion6->rgReleaseLabels[0].fNumeric); |
282 | Assert::Equal<DWORD>(4, pVersion6->rgReleaseLabels[0].dwValue); | 282 | Assert::Equal<DWORD>(4, pVersion6->rgReleaseLabels[0].dwValue); |
283 | Assert::Equal<DWORD>(1, pVersion6->rgReleaseLabels[0].cchLabel); | 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 | 285 | ||
286 | Assert::Equal<DWORD>(5, pVersion6->cchMetadataOffset); | 286 | Assert::Equal<SIZE_T>(5, pVersion6->cchMetadataOffset); |
287 | Assert::Equal<BOOL>(TRUE, pVersion6->fInvalid); | 287 | Assert::Equal<BOOL>(TRUE, pVersion6->fInvalid); |
288 | Assert::Equal<BOOL>(TRUE, pVersion6->fHasMajor); | 288 | Assert::Equal<BOOL>(TRUE, pVersion6->fHasMajor); |
289 | Assert::Equal<BOOL>(FALSE, pVersion6->fHasMinor); | 289 | Assert::Equal<BOOL>(FALSE, pVersion6->fHasMinor); |
@@ -337,9 +337,9 @@ namespace DutilTests | |||
337 | 337 | ||
338 | Assert::Equal<BOOL>(FALSE, pVersion1->rgReleaseLabels[0].fNumeric); | 338 | Assert::Equal<BOOL>(FALSE, pVersion1->rgReleaseLabels[0].fNumeric); |
339 | Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[0].cchLabel); | 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 | 341 | ||
342 | Assert::Equal<DWORD>(7, pVersion1->cchMetadataOffset); | 342 | Assert::Equal<SIZE_T>(7, pVersion1->cchMetadataOffset); |
343 | Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid); | 343 | Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid); |
344 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); | 344 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); |
345 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor); | 345 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor); |
@@ -357,9 +357,9 @@ namespace DutilTests | |||
357 | Assert::Equal<BOOL>(TRUE, pVersion2->rgReleaseLabels[0].fNumeric); | 357 | Assert::Equal<BOOL>(TRUE, pVersion2->rgReleaseLabels[0].fNumeric); |
358 | Assert::Equal<DWORD>(2, pVersion2->rgReleaseLabels[0].dwValue); | 358 | Assert::Equal<DWORD>(2, pVersion2->rgReleaseLabels[0].dwValue); |
359 | Assert::Equal<DWORD>(1, pVersion2->rgReleaseLabels[0].cchLabel); | 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 | 361 | ||
362 | Assert::Equal<DWORD>(3, pVersion2->cchMetadataOffset); | 362 | Assert::Equal<SIZE_T>(3, pVersion2->cchMetadataOffset); |
363 | Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid); | 363 | Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid); |
364 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor); | 364 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor); |
365 | Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor); | 365 | Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor); |
@@ -377,9 +377,9 @@ namespace DutilTests | |||
377 | Assert::Equal<BOOL>(TRUE, pVersion3->rgReleaseLabels[0].fNumeric); | 377 | Assert::Equal<BOOL>(TRUE, pVersion3->rgReleaseLabels[0].fNumeric); |
378 | Assert::Equal<DWORD>(2, pVersion3->rgReleaseLabels[0].dwValue); | 378 | Assert::Equal<DWORD>(2, pVersion3->rgReleaseLabels[0].dwValue); |
379 | Assert::Equal<DWORD>(1, pVersion3->rgReleaseLabels[0].cchLabel); | 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 | 381 | ||
382 | Assert::Equal<DWORD>(3, pVersion3->cchMetadataOffset); | 382 | Assert::Equal<SIZE_T>(3, pVersion3->cchMetadataOffset); |
383 | Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid); | 383 | Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid); |
384 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor); | 384 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor); |
385 | Assert::Equal<BOOL>(FALSE, pVersion3->fHasMinor); | 385 | Assert::Equal<BOOL>(FALSE, pVersion3->fHasMinor); |
@@ -434,14 +434,14 @@ namespace DutilTests | |||
434 | 434 | ||
435 | Assert::Equal<BOOL>(FALSE, pVersion1->rgReleaseLabels[0].fNumeric); | 435 | Assert::Equal<BOOL>(FALSE, pVersion1->rgReleaseLabels[0].fNumeric); |
436 | Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[0].cchLabel); | 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 | 438 | ||
439 | Assert::Equal<BOOL>(TRUE, pVersion1->rgReleaseLabels[1].fNumeric); | 439 | Assert::Equal<BOOL>(TRUE, pVersion1->rgReleaseLabels[1].fNumeric); |
440 | Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[1].dwValue); | 440 | Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[1].dwValue); |
441 | Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[1].cchLabel); | 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 | 443 | ||
444 | Assert::Equal<DWORD>(8, pVersion1->cchMetadataOffset); | 444 | Assert::Equal<SIZE_T>(8, pVersion1->cchMetadataOffset); |
445 | Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid); | 445 | Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid); |
446 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); | 446 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); |
447 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor); | 447 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor); |
@@ -458,14 +458,14 @@ namespace DutilTests | |||
458 | 458 | ||
459 | Assert::Equal<BOOL>(FALSE, pVersion2->rgReleaseLabels[0].fNumeric); | 459 | Assert::Equal<BOOL>(FALSE, pVersion2->rgReleaseLabels[0].fNumeric); |
460 | Assert::Equal<DWORD>(1, pVersion2->rgReleaseLabels[0].cchLabel); | 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 | 462 | ||
463 | Assert::Equal<BOOL>(TRUE, pVersion2->rgReleaseLabels[1].fNumeric); | 463 | Assert::Equal<BOOL>(TRUE, pVersion2->rgReleaseLabels[1].fNumeric); |
464 | Assert::Equal<DWORD>(1, pVersion2->rgReleaseLabels[1].dwValue); | 464 | Assert::Equal<DWORD>(1, pVersion2->rgReleaseLabels[1].dwValue); |
465 | Assert::Equal<DWORD>(1, pVersion2->rgReleaseLabels[1].cchLabel); | 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 | 467 | ||
468 | Assert::Equal<DWORD>(9, pVersion2->cchMetadataOffset); | 468 | Assert::Equal<SIZE_T>(9, pVersion2->cchMetadataOffset); |
469 | Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid); | 469 | Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid); |
470 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor); | 470 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor); |
471 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor); | 471 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor); |
@@ -482,18 +482,18 @@ namespace DutilTests | |||
482 | 482 | ||
483 | Assert::Equal<BOOL>(FALSE, pVersion3->rgReleaseLabels[0].fNumeric); | 483 | Assert::Equal<BOOL>(FALSE, pVersion3->rgReleaseLabels[0].fNumeric); |
484 | Assert::Equal<DWORD>(1, pVersion3->rgReleaseLabels[0].cchLabel); | 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 | 486 | ||
487 | Assert::Equal<BOOL>(FALSE, pVersion3->rgReleaseLabels[1].fNumeric); | 487 | Assert::Equal<BOOL>(FALSE, pVersion3->rgReleaseLabels[1].fNumeric); |
488 | Assert::Equal<DWORD>(1, pVersion3->rgReleaseLabels[1].cchLabel); | 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 | 490 | ||
491 | Assert::Equal<BOOL>(TRUE, pVersion3->rgReleaseLabels[2].fNumeric); | 491 | Assert::Equal<BOOL>(TRUE, pVersion3->rgReleaseLabels[2].fNumeric); |
492 | Assert::Equal<DWORD>(0, pVersion3->rgReleaseLabels[2].dwValue); | 492 | Assert::Equal<DWORD>(0, pVersion3->rgReleaseLabels[2].dwValue); |
493 | Assert::Equal<DWORD>(1, pVersion3->rgReleaseLabels[2].cchLabel); | 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 | 495 | ||
496 | Assert::Equal<DWORD>(9, pVersion3->cchMetadataOffset); | 496 | Assert::Equal<SIZE_T>(9, pVersion3->cchMetadataOffset); |
497 | Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid); | 497 | Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid); |
498 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor); | 498 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor); |
499 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor); | 499 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor); |
@@ -510,18 +510,18 @@ namespace DutilTests | |||
510 | 510 | ||
511 | Assert::Equal<BOOL>(FALSE, pVersion4->rgReleaseLabels[0].fNumeric); | 511 | Assert::Equal<BOOL>(FALSE, pVersion4->rgReleaseLabels[0].fNumeric); |
512 | Assert::Equal<DWORD>(1, pVersion4->rgReleaseLabels[0].cchLabel); | 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 | 514 | ||
515 | Assert::Equal<BOOL>(FALSE, pVersion4->rgReleaseLabels[1].fNumeric); | 515 | Assert::Equal<BOOL>(FALSE, pVersion4->rgReleaseLabels[1].fNumeric); |
516 | Assert::Equal<DWORD>(1, pVersion4->rgReleaseLabels[1].cchLabel); | 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 | 518 | ||
519 | Assert::Equal<BOOL>(TRUE, pVersion4->rgReleaseLabels[2].fNumeric); | 519 | Assert::Equal<BOOL>(TRUE, pVersion4->rgReleaseLabels[2].fNumeric); |
520 | Assert::Equal<DWORD>(0, pVersion4->rgReleaseLabels[2].dwValue); | 520 | Assert::Equal<DWORD>(0, pVersion4->rgReleaseLabels[2].dwValue); |
521 | Assert::Equal<DWORD>(3, pVersion4->rgReleaseLabels[2].cchLabel); | 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 | 523 | ||
524 | Assert::Equal<DWORD>(13, pVersion4->cchMetadataOffset); | 524 | Assert::Equal<SIZE_T>(13, pVersion4->cchMetadataOffset); |
525 | Assert::Equal<BOOL>(FALSE, pVersion4->fInvalid); | 525 | Assert::Equal<BOOL>(FALSE, pVersion4->fInvalid); |
526 | Assert::Equal<BOOL>(TRUE, pVersion4->fHasMajor); | 526 | Assert::Equal<BOOL>(TRUE, pVersion4->fHasMajor); |
527 | Assert::Equal<BOOL>(TRUE, pVersion4->fHasMinor); | 527 | Assert::Equal<BOOL>(TRUE, pVersion4->fHasMinor); |
@@ -569,7 +569,7 @@ namespace DutilTests | |||
569 | Assert::Equal<DWORD>(3, pVersion1->dwPatch); | 569 | Assert::Equal<DWORD>(3, pVersion1->dwPatch); |
570 | Assert::Equal<DWORD>(0, pVersion1->dwRevision); | 570 | Assert::Equal<DWORD>(0, pVersion1->dwRevision); |
571 | Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels); | 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); | 573 | Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid); |
574 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); | 574 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); |
575 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor); | 575 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor); |
@@ -583,7 +583,7 @@ namespace DutilTests | |||
583 | Assert::Equal<DWORD>(3, pVersion2->dwPatch); | 583 | Assert::Equal<DWORD>(3, pVersion2->dwPatch); |
584 | Assert::Equal<DWORD>(0, pVersion2->dwRevision); | 584 | Assert::Equal<DWORD>(0, pVersion2->dwRevision); |
585 | Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels); | 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); | 587 | Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid); |
588 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor); | 588 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor); |
589 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor); | 589 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor); |
@@ -597,7 +597,7 @@ namespace DutilTests | |||
597 | Assert::Equal<DWORD>(3, pVersion3->dwPatch); | 597 | Assert::Equal<DWORD>(3, pVersion3->dwPatch); |
598 | Assert::Equal<DWORD>(0, pVersion3->dwRevision); | 598 | Assert::Equal<DWORD>(0, pVersion3->dwRevision); |
599 | Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels); | 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); | 601 | Assert::Equal<BOOL>(TRUE, pVersion3->fInvalid); |
602 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor); | 602 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor); |
603 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor); | 603 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor); |
@@ -655,7 +655,7 @@ namespace DutilTests | |||
655 | Assert::Equal<DWORD>(30, pVersion1->dwPatch); | 655 | Assert::Equal<DWORD>(30, pVersion1->dwPatch); |
656 | Assert::Equal<DWORD>(40, pVersion1->dwRevision); | 656 | Assert::Equal<DWORD>(40, pVersion1->dwRevision); |
657 | Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels); | 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); | 659 | Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid); |
660 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); | 660 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); |
661 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor); | 661 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor); |
@@ -669,7 +669,7 @@ namespace DutilTests | |||
669 | Assert::Equal<DWORD>(30, pVersion2->dwPatch); | 669 | Assert::Equal<DWORD>(30, pVersion2->dwPatch); |
670 | Assert::Equal<DWORD>(40, pVersion2->dwRevision); | 670 | Assert::Equal<DWORD>(40, pVersion2->dwRevision); |
671 | Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels); | 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); | 673 | Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid); |
674 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor); | 674 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor); |
675 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor); | 675 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor); |
@@ -683,7 +683,7 @@ namespace DutilTests | |||
683 | Assert::Equal<DWORD>(30, pVersion3->dwPatch); | 683 | Assert::Equal<DWORD>(30, pVersion3->dwPatch); |
684 | Assert::Equal<DWORD>(40, pVersion3->dwRevision); | 684 | Assert::Equal<DWORD>(40, pVersion3->dwRevision); |
685 | Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels); | 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); | 687 | Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid); |
688 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor); | 688 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor); |
689 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor); | 689 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor); |
@@ -700,9 +700,9 @@ namespace DutilTests | |||
700 | 700 | ||
701 | Assert::Equal<BOOL>(FALSE, pVersion4->rgReleaseLabels[0].fNumeric); | 701 | Assert::Equal<BOOL>(FALSE, pVersion4->rgReleaseLabels[0].fNumeric); |
702 | Assert::Equal<DWORD>(3, pVersion4->rgReleaseLabels[0].cchLabel); | 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 | 704 | ||
705 | Assert::Equal<DWORD>(15, pVersion4->cchMetadataOffset); | 705 | Assert::Equal<SIZE_T>(15, pVersion4->cchMetadataOffset); |
706 | Assert::Equal<BOOL>(FALSE, pVersion4->fInvalid); | 706 | Assert::Equal<BOOL>(FALSE, pVersion4->fInvalid); |
707 | Assert::Equal<BOOL>(TRUE, pVersion4->fHasMajor); | 707 | Assert::Equal<BOOL>(TRUE, pVersion4->fHasMajor); |
708 | Assert::Equal<BOOL>(TRUE, pVersion4->fHasMinor); | 708 | Assert::Equal<BOOL>(TRUE, pVersion4->fHasMinor); |
@@ -716,7 +716,7 @@ namespace DutilTests | |||
716 | Assert::Equal<DWORD>(0, pVersion5->dwPatch); | 716 | Assert::Equal<DWORD>(0, pVersion5->dwPatch); |
717 | Assert::Equal<DWORD>(0, pVersion5->dwRevision); | 717 | Assert::Equal<DWORD>(0, pVersion5->dwRevision); |
718 | Assert::Equal<DWORD>(0, pVersion5->cReleaseLabels); | 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); | 720 | Assert::Equal<BOOL>(TRUE, pVersion5->fInvalid); |
721 | Assert::Equal<BOOL>(FALSE, pVersion5->fHasMajor); | 721 | Assert::Equal<BOOL>(FALSE, pVersion5->fHasMajor); |
722 | Assert::Equal<BOOL>(FALSE, pVersion5->fHasMinor); | 722 | Assert::Equal<BOOL>(FALSE, pVersion5->fHasMinor); |
@@ -761,7 +761,7 @@ namespace DutilTests | |||
761 | Assert::Equal<DWORD>(4294967295, pVersion1->dwPatch); | 761 | Assert::Equal<DWORD>(4294967295, pVersion1->dwPatch); |
762 | Assert::Equal<DWORD>(4294967295, pVersion1->dwRevision); | 762 | Assert::Equal<DWORD>(4294967295, pVersion1->dwRevision); |
763 | Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels); | 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); | 765 | Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid); |
766 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); | 766 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); |
767 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor); | 767 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor); |
@@ -775,7 +775,7 @@ namespace DutilTests | |||
775 | Assert::Equal<DWORD>(0, pVersion2->dwPatch); | 775 | Assert::Equal<DWORD>(0, pVersion2->dwPatch); |
776 | Assert::Equal<DWORD>(0, pVersion2->dwRevision); | 776 | Assert::Equal<DWORD>(0, pVersion2->dwRevision); |
777 | Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels); | 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); | 779 | Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid); |
780 | Assert::Equal<BOOL>(FALSE, pVersion2->fHasMajor); | 780 | Assert::Equal<BOOL>(FALSE, pVersion2->fHasMajor); |
781 | Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor); | 781 | Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor); |
@@ -815,7 +815,7 @@ namespace DutilTests | |||
815 | Assert::Equal<DWORD>(3, pVersion1->dwPatch); | 815 | Assert::Equal<DWORD>(3, pVersion1->dwPatch); |
816 | Assert::Equal<DWORD>(0, pVersion1->dwRevision); | 816 | Assert::Equal<DWORD>(0, pVersion1->dwRevision); |
817 | Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels); | 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); | 819 | Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid); |
820 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); | 820 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); |
821 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor); | 821 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor); |
@@ -829,7 +829,7 @@ namespace DutilTests | |||
829 | Assert::Equal<DWORD>(3, pVersion2->dwPatch); | 829 | Assert::Equal<DWORD>(3, pVersion2->dwPatch); |
830 | Assert::Equal<DWORD>(0, pVersion2->dwRevision); | 830 | Assert::Equal<DWORD>(0, pVersion2->dwRevision); |
831 | Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels); | 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); | 833 | Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid); |
834 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor); | 834 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor); |
835 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor); | 835 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor); |
@@ -867,7 +867,7 @@ namespace DutilTests | |||
867 | Assert::Equal<DWORD>(4, pSource->dwRevision); | 867 | Assert::Equal<DWORD>(4, pSource->dwRevision); |
868 | Assert::Equal<DWORD>(0, pSource->cReleaseLabels); | 868 | Assert::Equal<DWORD>(0, pSource->cReleaseLabels); |
869 | 869 | ||
870 | Assert::Equal<DWORD>(8, pSource->cchMetadataOffset); | 870 | Assert::Equal<SIZE_T>(8, pSource->cchMetadataOffset); |
871 | Assert::Equal<BOOL>(FALSE, pSource->fInvalid); | 871 | Assert::Equal<BOOL>(FALSE, pSource->fInvalid); |
872 | Assert::Equal<BOOL>(TRUE, pSource->fHasMajor); | 872 | Assert::Equal<BOOL>(TRUE, pSource->fHasMajor); |
873 | Assert::Equal<BOOL>(TRUE, pSource->fHasMinor); | 873 | Assert::Equal<BOOL>(TRUE, pSource->fHasMinor); |
@@ -921,26 +921,26 @@ namespace DutilTests | |||
921 | 921 | ||
922 | Assert::Equal<BOOL>(FALSE, pSource->rgReleaseLabels[0].fNumeric); | 922 | Assert::Equal<BOOL>(FALSE, pSource->rgReleaseLabels[0].fNumeric); |
923 | Assert::Equal<DWORD>(1, pSource->rgReleaseLabels[0].cchLabel); | 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 | 925 | ||
926 | Assert::Equal<BOOL>(FALSE, pSource->rgReleaseLabels[1].fNumeric); | 926 | Assert::Equal<BOOL>(FALSE, pSource->rgReleaseLabels[1].fNumeric); |
927 | Assert::Equal<DWORD>(1, pSource->rgReleaseLabels[1].cchLabel); | 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 | 929 | ||
930 | Assert::Equal<BOOL>(FALSE, pSource->rgReleaseLabels[2].fNumeric); | 930 | Assert::Equal<BOOL>(FALSE, pSource->rgReleaseLabels[2].fNumeric); |
931 | Assert::Equal<DWORD>(1, pSource->rgReleaseLabels[2].cchLabel); | 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 | 933 | ||
934 | Assert::Equal<BOOL>(FALSE, pSource->rgReleaseLabels[3].fNumeric); | 934 | Assert::Equal<BOOL>(FALSE, pSource->rgReleaseLabels[3].fNumeric); |
935 | Assert::Equal<DWORD>(1, pSource->rgReleaseLabels[3].cchLabel); | 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 | 937 | ||
938 | Assert::Equal<BOOL>(TRUE, pSource->rgReleaseLabels[4].fNumeric); | 938 | Assert::Equal<BOOL>(TRUE, pSource->rgReleaseLabels[4].fNumeric); |
939 | Assert::Equal<DWORD>(5, pSource->rgReleaseLabels[4].dwValue); | 939 | Assert::Equal<DWORD>(5, pSource->rgReleaseLabels[4].dwValue); |
940 | Assert::Equal<DWORD>(1, pSource->rgReleaseLabels[4].cchLabel); | 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 | 942 | ||
943 | Assert::Equal<DWORD>(18, pSource->cchMetadataOffset); | 943 | Assert::Equal<SIZE_T>(18, pSource->cchMetadataOffset); |
944 | Assert::Equal<BOOL>(TRUE, pSource->fInvalid); | 944 | Assert::Equal<BOOL>(TRUE, pSource->fInvalid); |
945 | Assert::Equal<BOOL>(TRUE, pSource->fHasMajor); | 945 | Assert::Equal<BOOL>(TRUE, pSource->fHasMajor); |
946 | Assert::Equal<BOOL>(TRUE, pSource->fHasMinor); | 946 | Assert::Equal<BOOL>(TRUE, pSource->fHasMinor); |
@@ -1020,7 +1020,7 @@ namespace DutilTests | |||
1020 | Assert::Equal<DWORD>(0, pVersion1->dwPatch); | 1020 | Assert::Equal<DWORD>(0, pVersion1->dwPatch); |
1021 | Assert::Equal<DWORD>(0, pVersion1->dwRevision); | 1021 | Assert::Equal<DWORD>(0, pVersion1->dwRevision); |
1022 | Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels); | 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); | 1024 | Assert::Equal<BOOL>(TRUE, pVersion1->fInvalid); |
1025 | Assert::Equal<BOOL>(FALSE, pVersion1->fHasMajor); | 1025 | Assert::Equal<BOOL>(FALSE, pVersion1->fHasMajor); |
1026 | Assert::Equal<BOOL>(FALSE, pVersion1->fHasMinor); | 1026 | Assert::Equal<BOOL>(FALSE, pVersion1->fHasMinor); |
@@ -1034,7 +1034,7 @@ namespace DutilTests | |||
1034 | Assert::Equal<DWORD>(0, pVersion2->dwPatch); | 1034 | Assert::Equal<DWORD>(0, pVersion2->dwPatch); |
1035 | Assert::Equal<DWORD>(0, pVersion2->dwRevision); | 1035 | Assert::Equal<DWORD>(0, pVersion2->dwRevision); |
1036 | Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels); | 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); | 1038 | Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid); |
1039 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor); | 1039 | Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor); |
1040 | Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor); | 1040 | Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor); |
@@ -1048,7 +1048,7 @@ namespace DutilTests | |||
1048 | Assert::Equal<DWORD>(0, pVersion3->dwPatch); | 1048 | Assert::Equal<DWORD>(0, pVersion3->dwPatch); |
1049 | Assert::Equal<DWORD>(0, pVersion3->dwRevision); | 1049 | Assert::Equal<DWORD>(0, pVersion3->dwRevision); |
1050 | Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels); | 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); | 1052 | Assert::Equal<BOOL>(TRUE, pVersion3->fInvalid); |
1053 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor); | 1053 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor); |
1054 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor); | 1054 | Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor); |
@@ -1062,7 +1062,7 @@ namespace DutilTests | |||
1062 | Assert::Equal<DWORD>(1, pVersion4->dwPatch); | 1062 | Assert::Equal<DWORD>(1, pVersion4->dwPatch); |
1063 | Assert::Equal<DWORD>(0, pVersion4->dwRevision); | 1063 | Assert::Equal<DWORD>(0, pVersion4->dwRevision); |
1064 | Assert::Equal<DWORD>(0, pVersion4->cReleaseLabels); | 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); | 1066 | Assert::Equal<BOOL>(TRUE, pVersion4->fInvalid); |
1067 | Assert::Equal<BOOL>(TRUE, pVersion4->fHasMajor); | 1067 | Assert::Equal<BOOL>(TRUE, pVersion4->fHasMajor); |
1068 | Assert::Equal<BOOL>(TRUE, pVersion4->fHasMinor); | 1068 | Assert::Equal<BOOL>(TRUE, pVersion4->fHasMinor); |
@@ -1076,7 +1076,7 @@ namespace DutilTests | |||
1076 | Assert::Equal<DWORD>(2, pVersion5->dwPatch); | 1076 | Assert::Equal<DWORD>(2, pVersion5->dwPatch); |
1077 | Assert::Equal<DWORD>(1, pVersion5->dwRevision); | 1077 | Assert::Equal<DWORD>(1, pVersion5->dwRevision); |
1078 | Assert::Equal<DWORD>(0, pVersion5->cReleaseLabels); | 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); | 1080 | Assert::Equal<BOOL>(TRUE, pVersion5->fInvalid); |
1081 | Assert::Equal<BOOL>(TRUE, pVersion5->fHasMajor); | 1081 | Assert::Equal<BOOL>(TRUE, pVersion5->fHasMajor); |
1082 | Assert::Equal<BOOL>(TRUE, pVersion5->fHasMinor); | 1082 | Assert::Equal<BOOL>(TRUE, pVersion5->fHasMinor); |
@@ -1090,7 +1090,7 @@ namespace DutilTests | |||
1090 | Assert::Equal<DWORD>(0, pVersion6->dwPatch); | 1090 | Assert::Equal<DWORD>(0, pVersion6->dwPatch); |
1091 | Assert::Equal<DWORD>(0, pVersion6->dwRevision); | 1091 | Assert::Equal<DWORD>(0, pVersion6->dwRevision); |
1092 | Assert::Equal<DWORD>(0, pVersion6->cReleaseLabels); | 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); | 1094 | Assert::Equal<BOOL>(TRUE, pVersion6->fInvalid); |
1095 | Assert::Equal<BOOL>(TRUE, pVersion6->fHasMajor); | 1095 | Assert::Equal<BOOL>(TRUE, pVersion6->fHasMajor); |
1096 | Assert::Equal<BOOL>(FALSE, pVersion6->fHasMinor); | 1096 | Assert::Equal<BOOL>(FALSE, pVersion6->fHasMinor); |
@@ -1107,9 +1107,9 @@ namespace DutilTests | |||
1107 | 1107 | ||
1108 | Assert::Equal<BOOL>(FALSE, pVersion7->rgReleaseLabels[0].fNumeric); | 1108 | Assert::Equal<BOOL>(FALSE, pVersion7->rgReleaseLabels[0].fNumeric); |
1109 | Assert::Equal<DWORD>(1, pVersion7->rgReleaseLabels[0].cchLabel); | 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 | 1111 | ||
1112 | Assert::Equal<DWORD>(4, pVersion7->cchMetadataOffset); | 1112 | Assert::Equal<SIZE_T>(4, pVersion7->cchMetadataOffset); |
1113 | Assert::Equal<BOOL>(TRUE, pVersion7->fInvalid); | 1113 | Assert::Equal<BOOL>(TRUE, pVersion7->fInvalid); |
1114 | Assert::Equal<BOOL>(TRUE, pVersion7->fHasMajor); | 1114 | Assert::Equal<BOOL>(TRUE, pVersion7->fHasMajor); |
1115 | Assert::Equal<BOOL>(FALSE, pVersion7->fHasMinor); | 1115 | Assert::Equal<BOOL>(FALSE, pVersion7->fHasMinor); |
@@ -1146,7 +1146,7 @@ namespace DutilTests | |||
1146 | Assert::Equal<DWORD>(3, pVersion1->dwPatch); | 1146 | Assert::Equal<DWORD>(3, pVersion1->dwPatch); |
1147 | Assert::Equal<DWORD>(4, pVersion1->dwRevision); | 1147 | Assert::Equal<DWORD>(4, pVersion1->dwRevision); |
1148 | Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels); | 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); | 1150 | Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid); |
1151 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); | 1151 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor); |
1152 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor); | 1152 | Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor); |