@joebigelow / wix-1
Code Commits Issues Pulls Sessions CI/CD
main
main
cpp 1,179 lines 59.7 KB
Raw
1 // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
2
3 #include "precomp.h"
4
5 using namespace System;
6 using namespace Xunit;
7 using namespace WixInternal::TestSupport;
8
9 namespace DutilTests
10 {
11 public ref class VerUtil
12 {
13 public:
14 [Fact]
15 void VerCompareVersionsTreatsMissingRevisionAsZero()
16 {
17 HRESULT hr = S_OK;
18 VERUTIL_VERSION* pVersion1 = NULL;
19 VERUTIL_VERSION* pVersion2 = NULL;
20 VERUTIL_VERSION* pVersion3 = NULL;
21 LPCWSTR wzVersion1 = L"1.2.3.4";
22 LPCWSTR wzVersion2 = L"1.2.3";
23 LPCWSTR wzVersion3 = L"1.2.3.0";
24
25 try
26 {
27 hr = VerParseVersion(wzVersion1, 0, FALSE, &pVersion1);
28 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion1);
29
30 hr = VerParseVersion(wzVersion2, 0, FALSE, &pVersion2);
31 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion2);
32
33 hr = VerParseVersion(wzVersion3, 0, FALSE, &pVersion3);
34 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion3);
35
36 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
37 Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
38 Assert::Equal<DWORD>(1, pVersion1->dwMajor);
39 Assert::Equal<DWORD>(2, pVersion1->dwMinor);
40 Assert::Equal<DWORD>(3, pVersion1->dwPatch);
41 Assert::Equal<DWORD>(4, pVersion1->dwRevision);
42 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
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);
47 Assert::Equal<BOOL>(TRUE, pVersion1->fHasPatch);
48 Assert::Equal<BOOL>(TRUE, pVersion1->fHasRevision);
49
50 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
51 Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
52 Assert::Equal<DWORD>(1, pVersion2->dwMajor);
53 Assert::Equal<DWORD>(2, pVersion2->dwMinor);
54 Assert::Equal<DWORD>(3, pVersion2->dwPatch);
55 Assert::Equal<DWORD>(0, pVersion2->dwRevision);
56 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
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);
61 Assert::Equal<BOOL>(TRUE, pVersion2->fHasPatch);
62 Assert::Equal<BOOL>(FALSE, pVersion2->fHasRevision);
63
64 NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion);
65 Assert::Equal<WCHAR>(L'\0', pVersion3->chPrefix);
66 Assert::Equal<DWORD>(1, pVersion3->dwMajor);
67 Assert::Equal<DWORD>(2, pVersion3->dwMinor);
68 Assert::Equal<DWORD>(3, pVersion3->dwPatch);
69 Assert::Equal<DWORD>(0, pVersion3->dwRevision);
70 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
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);
75 Assert::Equal<BOOL>(TRUE, pVersion3->fHasPatch);
76 Assert::Equal<BOOL>(TRUE, pVersion3->fHasRevision);
77
78 TestVerutilCompareParsedVersions(pVersion1, pVersion2, 1);
79 TestVerutilCompareParsedVersions(pVersion3, pVersion2, 0);
80 }
81 finally
82 {
83 ReleaseVerutilVersion(pVersion1);
84 ReleaseVerutilVersion(pVersion2);
85 ReleaseVerutilVersion(pVersion3);
86 }
87 }
88
89 [Fact]
90 void VerCompareVersionsTreatsNumericReleaseLabelsAsNumbers()
91 {
92 HRESULT hr = S_OK;
93 VERUTIL_VERSION* pVersion1 = NULL;
94 VERUTIL_VERSION* pVersion2 = NULL;
95 LPCWSTR wzVersion1 = L"1.0-2.0";
96 LPCWSTR wzVersion2 = L"1.0-19";
97
98 try
99 {
100 hr = VerParseVersion(wzVersion1, 0, FALSE, &pVersion1);
101 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion1);
102
103 hr = VerParseVersion(wzVersion2, 0, FALSE, &pVersion2);
104 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion2);
105
106 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
107 Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
108 Assert::Equal<DWORD>(1, pVersion1->dwMajor);
109 Assert::Equal<DWORD>(0, pVersion1->dwMinor);
110 Assert::Equal<DWORD>(0, pVersion1->dwPatch);
111 Assert::Equal<DWORD>(0, pVersion1->dwRevision);
112 Assert::Equal<DWORD>(2, pVersion1->cReleaseLabels);
113
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<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<SIZE_T>(6, pVersion1->rgReleaseLabels[1].cchLabelOffset);
123
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);
128 Assert::Equal<BOOL>(FALSE, pVersion1->fHasPatch);
129 Assert::Equal<BOOL>(FALSE, pVersion1->fHasRevision);
130
131 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
132 Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
133 Assert::Equal<DWORD>(1, pVersion2->dwMajor);
134 Assert::Equal<DWORD>(0, pVersion2->dwMinor);
135 Assert::Equal<DWORD>(0, pVersion2->dwPatch);
136 Assert::Equal<DWORD>(0, pVersion2->dwRevision);
137 Assert::Equal<DWORD>(1, pVersion2->cReleaseLabels);
138
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<SIZE_T>(4, pVersion2->rgReleaseLabels[0].cchLabelOffset);
143
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);
148 Assert::Equal<BOOL>(FALSE, pVersion2->fHasPatch);
149 Assert::Equal<BOOL>(FALSE, pVersion2->fHasRevision);
150
151 TestVerutilCompareParsedVersions(pVersion1, pVersion2, -1);
152 }
153 finally
154 {
155 ReleaseVerutilVersion(pVersion1);
156 ReleaseVerutilVersion(pVersion2);
157 }
158 }
159
160 [Fact]
161 void VerCompareVersionsHandlesNormallyInvalidVersions()
162 {
163 HRESULT hr = S_OK;
164 VERUTIL_VERSION* pVersion1 = NULL;
165 VERUTIL_VERSION* pVersion2 = NULL;
166 VERUTIL_VERSION* pVersion3 = NULL;
167 VERUTIL_VERSION* pVersion4 = NULL;
168 VERUTIL_VERSION* pVersion5 = NULL;
169 VERUTIL_VERSION* pVersion6 = NULL;
170 LPCWSTR wzVersion1 = L"10.-4.0";
171 LPCWSTR wzVersion2 = L"10.-2.0";
172 LPCWSTR wzVersion3 = L"0";
173 LPCWSTR wzVersion4 = L"";
174 LPCWSTR wzVersion5 = L"10-2";
175 LPCWSTR wzVersion6 = L"10-4.@";
176
177 try
178 {
179 hr = VerParseVersion(wzVersion1, 0, FALSE, &pVersion1);
180 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion1);
181
182 hr = VerParseVersion(wzVersion2, 0, FALSE, &pVersion2);
183 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion2);
184
185 hr = VerParseVersion(wzVersion3, 0, FALSE, &pVersion3);
186 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion3);
187
188 hr = VerParseVersion(wzVersion4, 0, FALSE, &pVersion4);
189 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion4);
190
191 hr = VerParseVersion(wzVersion5, 0, FALSE, &pVersion5);
192 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion5);
193
194 hr = VerParseVersion(wzVersion6, 0, FALSE, &pVersion6);
195 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion6);
196
197 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
198 Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
199 Assert::Equal<DWORD>(10, pVersion1->dwMajor);
200 Assert::Equal<DWORD>(0, pVersion1->dwMinor);
201 Assert::Equal<DWORD>(0, pVersion1->dwPatch);
202 Assert::Equal<DWORD>(0, pVersion1->dwRevision);
203 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
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);
208 Assert::Equal<BOOL>(FALSE, pVersion1->fHasPatch);
209 Assert::Equal<BOOL>(FALSE, pVersion1->fHasRevision);
210
211 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
212 Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
213 Assert::Equal<DWORD>(10, pVersion2->dwMajor);
214 Assert::Equal<DWORD>(0, pVersion2->dwMinor);
215 Assert::Equal<DWORD>(0, pVersion2->dwPatch);
216 Assert::Equal<DWORD>(0, pVersion2->dwRevision);
217 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
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);
222 Assert::Equal<BOOL>(FALSE, pVersion2->fHasPatch);
223 Assert::Equal<BOOL>(FALSE, pVersion2->fHasRevision);
224
225 NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion);
226 Assert::Equal<WCHAR>(L'\0', pVersion3->chPrefix);
227 Assert::Equal<DWORD>(0, pVersion3->dwMajor);
228 Assert::Equal<DWORD>(0, pVersion3->dwMinor);
229 Assert::Equal<DWORD>(0, pVersion3->dwPatch);
230 Assert::Equal<DWORD>(0, pVersion3->dwRevision);
231 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
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);
236 Assert::Equal<BOOL>(FALSE, pVersion3->fHasPatch);
237 Assert::Equal<BOOL>(FALSE, pVersion3->fHasRevision);
238
239 NativeAssert::StringEqual(wzVersion4, pVersion4->sczVersion);
240 Assert::Equal<WCHAR>(L'\0', pVersion4->chPrefix);
241 Assert::Equal<DWORD>(0, pVersion4->dwMajor);
242 Assert::Equal<DWORD>(0, pVersion4->dwMinor);
243 Assert::Equal<DWORD>(0, pVersion4->dwPatch);
244 Assert::Equal<DWORD>(0, pVersion4->dwRevision);
245 Assert::Equal<DWORD>(0, pVersion4->cReleaseLabels);
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);
250 Assert::Equal<BOOL>(FALSE, pVersion4->fHasPatch);
251 Assert::Equal<BOOL>(FALSE, pVersion4->fHasRevision);
252
253 NativeAssert::StringEqual(wzVersion5, pVersion5->sczVersion);
254 Assert::Equal<WCHAR>(L'\0', pVersion5->chPrefix);
255 Assert::Equal<DWORD>(10, pVersion5->dwMajor);
256 Assert::Equal<DWORD>(0, pVersion5->dwMinor);
257 Assert::Equal<DWORD>(0, pVersion5->dwPatch);
258 Assert::Equal<DWORD>(0, pVersion5->dwRevision);
259 Assert::Equal<DWORD>(1, pVersion5->cReleaseLabels);
260
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<SIZE_T>(3, pVersion5->rgReleaseLabels[0].cchLabelOffset);
265
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);
270 Assert::Equal<BOOL>(FALSE, pVersion5->fHasPatch);
271 Assert::Equal<BOOL>(FALSE, pVersion5->fHasRevision);
272
273 NativeAssert::StringEqual(wzVersion6, pVersion6->sczVersion);
274 Assert::Equal<WCHAR>(L'\0', pVersion6->chPrefix);
275 Assert::Equal<DWORD>(10, pVersion6->dwMajor);
276 Assert::Equal<DWORD>(0, pVersion6->dwMinor);
277 Assert::Equal<DWORD>(0, pVersion6->dwPatch);
278 Assert::Equal<DWORD>(0, pVersion6->dwRevision);
279 Assert::Equal<DWORD>(1, pVersion6->cReleaseLabels);
280
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<SIZE_T>(3, pVersion6->rgReleaseLabels[0].cchLabelOffset);
285
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);
290 Assert::Equal<BOOL>(FALSE, pVersion6->fHasPatch);
291 Assert::Equal<BOOL>(FALSE, pVersion6->fHasRevision);
292
293 TestVerutilCompareParsedVersions(pVersion1, pVersion2, 1);
294 TestVerutilCompareParsedVersions(pVersion3, pVersion4, 1);
295 TestVerutilCompareParsedVersions(pVersion5, pVersion6, -1);
296 }
297 finally
298 {
299 ReleaseVerutilVersion(pVersion1);
300 ReleaseVerutilVersion(pVersion2);
301 ReleaseVerutilVersion(pVersion3);
302 ReleaseVerutilVersion(pVersion4);
303 ReleaseVerutilVersion(pVersion5);
304 ReleaseVerutilVersion(pVersion6);
305 }
306 }
307
308 [Fact]
309 void VerCompareVersionsTreatsHyphenAsVersionSeparator()
310 {
311 HRESULT hr = S_OK;
312 VERUTIL_VERSION* pVersion1 = NULL;
313 VERUTIL_VERSION* pVersion2 = NULL;
314 VERUTIL_VERSION* pVersion3 = NULL;
315 LPCWSTR wzVersion1 = L"0.0.1-a";
316 LPCWSTR wzVersion2 = L"0-2";
317 LPCWSTR wzVersion3 = L"1-2";
318
319 try
320 {
321 hr = VerParseVersion(wzVersion1, 0, FALSE, &pVersion1);
322 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion1);
323
324 hr = VerParseVersion(wzVersion2, 0, FALSE, &pVersion2);
325 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion2);
326
327 hr = VerParseVersion(wzVersion3, 0, FALSE, &pVersion3);
328 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion3);
329
330 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
331 Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
332 Assert::Equal<DWORD>(0, pVersion1->dwMajor);
333 Assert::Equal<DWORD>(0, pVersion1->dwMinor);
334 Assert::Equal<DWORD>(1, pVersion1->dwPatch);
335 Assert::Equal<DWORD>(0, pVersion1->dwRevision);
336 Assert::Equal<DWORD>(1, pVersion1->cReleaseLabels);
337
338 Assert::Equal<BOOL>(FALSE, pVersion1->rgReleaseLabels[0].fNumeric);
339 Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[0].cchLabel);
340 Assert::Equal<SIZE_T>(6, pVersion1->rgReleaseLabels[0].cchLabelOffset);
341
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);
346 Assert::Equal<BOOL>(TRUE, pVersion1->fHasPatch);
347 Assert::Equal<BOOL>(FALSE, pVersion1->fHasRevision);
348
349 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
350 Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
351 Assert::Equal<DWORD>(0, pVersion2->dwMajor);
352 Assert::Equal<DWORD>(0, pVersion2->dwMinor);
353 Assert::Equal<DWORD>(0, pVersion2->dwPatch);
354 Assert::Equal<DWORD>(0, pVersion2->dwRevision);
355 Assert::Equal<DWORD>(1, pVersion2->cReleaseLabels);
356
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<SIZE_T>(2, pVersion2->rgReleaseLabels[0].cchLabelOffset);
361
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);
366 Assert::Equal<BOOL>(FALSE, pVersion2->fHasPatch);
367 Assert::Equal<BOOL>(FALSE, pVersion2->fHasRevision);
368
369 NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion);
370 Assert::Equal<WCHAR>(L'\0', pVersion3->chPrefix);
371 Assert::Equal<DWORD>(1, pVersion3->dwMajor);
372 Assert::Equal<DWORD>(0, pVersion3->dwMinor);
373 Assert::Equal<DWORD>(0, pVersion3->dwPatch);
374 Assert::Equal<DWORD>(0, pVersion3->dwRevision);
375 Assert::Equal<DWORD>(1, pVersion3->cReleaseLabels);
376
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<SIZE_T>(2, pVersion3->rgReleaseLabels[0].cchLabelOffset);
381
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);
386 Assert::Equal<BOOL>(FALSE, pVersion3->fHasPatch);
387 Assert::Equal<BOOL>(FALSE, pVersion3->fHasRevision);
388
389 TestVerutilCompareParsedVersions(pVersion1, pVersion2, 1);
390 TestVerutilCompareParsedVersions(pVersion1, pVersion3, -1);
391 }
392 finally
393 {
394 ReleaseVerutilVersion(pVersion1);
395 ReleaseVerutilVersion(pVersion2);
396 ReleaseVerutilVersion(pVersion3);
397 }
398 }
399
400 [Fact]
401 void VerCompareVersionsIgnoresLeadingZeroes()
402 {
403 HRESULT hr = S_OK;
404 VERUTIL_VERSION* pVersion1 = NULL;
405 VERUTIL_VERSION* pVersion2 = NULL;
406 VERUTIL_VERSION* pVersion3 = NULL;
407 VERUTIL_VERSION* pVersion4 = NULL;
408 LPCWSTR wzVersion1 = L"0.01-a.1";
409 LPCWSTR wzVersion2 = L"0.1.0-a.1";
410 LPCWSTR wzVersion3 = L"0.1-a.b.0";
411 LPCWSTR wzVersion4 = L"0.1.0-a.b.000";
412
413 try
414 {
415 hr = VerParseVersion(wzVersion1, 0, FALSE, &pVersion1);
416 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion1);
417
418 hr = VerParseVersion(wzVersion2, 0, FALSE, &pVersion2);
419 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion2);
420
421 hr = VerParseVersion(wzVersion3, 0, FALSE, &pVersion3);
422 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion3);
423
424 hr = VerParseVersion(wzVersion4, 0, FALSE, &pVersion4);
425 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion4);
426
427 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
428 Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
429 Assert::Equal<DWORD>(0, pVersion1->dwMajor);
430 Assert::Equal<DWORD>(1, pVersion1->dwMinor);
431 Assert::Equal<DWORD>(0, pVersion1->dwPatch);
432 Assert::Equal<DWORD>(0, pVersion1->dwRevision);
433 Assert::Equal<DWORD>(2, pVersion1->cReleaseLabels);
434
435 Assert::Equal<BOOL>(FALSE, pVersion1->rgReleaseLabels[0].fNumeric);
436 Assert::Equal<DWORD>(1, pVersion1->rgReleaseLabels[0].cchLabel);
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<SIZE_T>(7, pVersion1->rgReleaseLabels[1].cchLabelOffset);
443
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);
448 Assert::Equal<BOOL>(FALSE, pVersion1->fHasPatch);
449 Assert::Equal<BOOL>(FALSE, pVersion1->fHasRevision);
450
451 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
452 Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
453 Assert::Equal<DWORD>(0, pVersion2->dwMajor);
454 Assert::Equal<DWORD>(1, pVersion2->dwMinor);
455 Assert::Equal<DWORD>(0, pVersion2->dwPatch);
456 Assert::Equal<DWORD>(0, pVersion2->dwRevision);
457 Assert::Equal<DWORD>(2, pVersion2->cReleaseLabels);
458
459 Assert::Equal<BOOL>(FALSE, pVersion2->rgReleaseLabels[0].fNumeric);
460 Assert::Equal<DWORD>(1, pVersion2->rgReleaseLabels[0].cchLabel);
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<SIZE_T>(8, pVersion2->rgReleaseLabels[1].cchLabelOffset);
467
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);
472 Assert::Equal<BOOL>(TRUE, pVersion2->fHasPatch);
473 Assert::Equal<BOOL>(FALSE, pVersion2->fHasRevision);
474
475 NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion);
476 Assert::Equal<WCHAR>(L'\0', pVersion3->chPrefix);
477 Assert::Equal<DWORD>(0, pVersion3->dwMajor);
478 Assert::Equal<DWORD>(1, pVersion3->dwMinor);
479 Assert::Equal<DWORD>(0, pVersion3->dwPatch);
480 Assert::Equal<DWORD>(0, pVersion3->dwRevision);
481 Assert::Equal<DWORD>(3, pVersion3->cReleaseLabels);
482
483 Assert::Equal<BOOL>(FALSE, pVersion3->rgReleaseLabels[0].fNumeric);
484 Assert::Equal<DWORD>(1, pVersion3->rgReleaseLabels[0].cchLabel);
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<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<SIZE_T>(8, pVersion3->rgReleaseLabels[2].cchLabelOffset);
495
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);
500 Assert::Equal<BOOL>(FALSE, pVersion3->fHasPatch);
501 Assert::Equal<BOOL>(FALSE, pVersion3->fHasRevision);
502
503 NativeAssert::StringEqual(wzVersion4, pVersion4->sczVersion);
504 Assert::Equal<WCHAR>(L'\0', pVersion4->chPrefix);
505 Assert::Equal<DWORD>(0, pVersion4->dwMajor);
506 Assert::Equal<DWORD>(1, pVersion4->dwMinor);
507 Assert::Equal<DWORD>(0, pVersion4->dwPatch);
508 Assert::Equal<DWORD>(0, pVersion4->dwRevision);
509 Assert::Equal<DWORD>(3, pVersion4->cReleaseLabels);
510
511 Assert::Equal<BOOL>(FALSE, pVersion4->rgReleaseLabels[0].fNumeric);
512 Assert::Equal<DWORD>(1, pVersion4->rgReleaseLabels[0].cchLabel);
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<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<SIZE_T>(10, pVersion4->rgReleaseLabels[2].cchLabelOffset);
523
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);
528 Assert::Equal<BOOL>(TRUE, pVersion4->fHasPatch);
529 Assert::Equal<BOOL>(FALSE, pVersion4->fHasRevision);
530
531 TestVerutilCompareParsedVersions(pVersion1, pVersion2, 0);
532 TestVerutilCompareParsedVersions(pVersion3, pVersion4, 0);
533 }
534 finally
535 {
536 ReleaseVerutilVersion(pVersion1);
537 ReleaseVerutilVersion(pVersion2);
538 ReleaseVerutilVersion(pVersion3);
539 ReleaseVerutilVersion(pVersion4);
540 }
541 }
542
543 [Fact]
544 void VerCompareVersionsTreatsUnexpectedContentAsMetadata()
545 {
546 HRESULT hr = S_OK;
547 VERUTIL_VERSION* pVersion1 = NULL;
548 VERUTIL_VERSION* pVersion2 = NULL;
549 VERUTIL_VERSION* pVersion3 = NULL;
550 LPCWSTR wzVersion1 = L"1.2.3+abcd";
551 LPCWSTR wzVersion2 = L"1.2.3.abcd";
552 LPCWSTR wzVersion3 = L"1.2.3.-abcd";
553
554 try
555 {
556 hr = VerParseVersion(wzVersion1, 0, FALSE, &pVersion1);
557 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion1);
558
559 hr = VerParseVersion(wzVersion2, 0, FALSE, &pVersion2);
560 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion2);
561
562 hr = VerParseVersion(wzVersion3, 0, FALSE, &pVersion3);
563 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion3);
564
565 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
566 Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
567 Assert::Equal<DWORD>(1, pVersion1->dwMajor);
568 Assert::Equal<DWORD>(2, pVersion1->dwMinor);
569 Assert::Equal<DWORD>(3, pVersion1->dwPatch);
570 Assert::Equal<DWORD>(0, pVersion1->dwRevision);
571 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
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);
576 Assert::Equal<BOOL>(TRUE, pVersion1->fHasPatch);
577 Assert::Equal<BOOL>(FALSE, pVersion1->fHasRevision);
578
579 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
580 Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
581 Assert::Equal<DWORD>(1, pVersion2->dwMajor);
582 Assert::Equal<DWORD>(2, pVersion2->dwMinor);
583 Assert::Equal<DWORD>(3, pVersion2->dwPatch);
584 Assert::Equal<DWORD>(0, pVersion2->dwRevision);
585 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
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);
590 Assert::Equal<BOOL>(TRUE, pVersion2->fHasPatch);
591 Assert::Equal<BOOL>(FALSE, pVersion2->fHasRevision);
592
593 NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion);
594 Assert::Equal<WCHAR>(L'\0', pVersion3->chPrefix);
595 Assert::Equal<DWORD>(1, pVersion3->dwMajor);
596 Assert::Equal<DWORD>(2, pVersion3->dwMinor);
597 Assert::Equal<DWORD>(3, pVersion3->dwPatch);
598 Assert::Equal<DWORD>(0, pVersion3->dwRevision);
599 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
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);
604 Assert::Equal<BOOL>(TRUE, pVersion3->fHasPatch);
605 Assert::Equal<BOOL>(FALSE, pVersion3->fHasRevision);
606
607 TestVerutilCompareParsedVersions(pVersion1, pVersion2, 1);
608 TestVerutilCompareParsedVersions(pVersion1, pVersion3, 1);
609 TestVerutilCompareParsedVersions(pVersion2, pVersion3, 1);
610 }
611 finally
612 {
613 ReleaseVerutilVersion(pVersion1);
614 ReleaseVerutilVersion(pVersion2);
615 ReleaseVerutilVersion(pVersion3);
616 }
617 }
618
619 [Fact]
620 void VerCompareVersionsIgnoresLeadingV()
621 {
622 HRESULT hr = S_OK;
623 VERUTIL_VERSION* pVersion1 = NULL;
624 VERUTIL_VERSION* pVersion2 = NULL;
625 VERUTIL_VERSION* pVersion3 = NULL;
626 VERUTIL_VERSION* pVersion4 = NULL;
627 VERUTIL_VERSION* pVersion5 = NULL;
628 LPCWSTR wzVersion1 = L"10.20.30.40";
629 LPCWSTR wzVersion2 = L"v10.20.30.40";
630 LPCWSTR wzVersion3 = L"V10.20.30.40";
631 LPCWSTR wzVersion4 = L"v10.20.30.40-abc";
632 LPCWSTR wzVersion5 = L"vvv";
633
634 try
635 {
636 hr = VerParseVersion(wzVersion1, 0, FALSE, &pVersion1);
637 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion1);
638
639 hr = VerParseVersion(wzVersion2, 0, FALSE, &pVersion2);
640 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion2);
641
642 hr = VerParseVersion(wzVersion3, 0, FALSE, &pVersion3);
643 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion3);
644
645 hr = VerParseVersion(wzVersion4, 0, FALSE, &pVersion4);
646 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion4);
647
648 hr = VerParseVersion(wzVersion5, 0, FALSE, &pVersion5);
649 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion5);
650
651 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
652 Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
653 Assert::Equal<DWORD>(10, pVersion1->dwMajor);
654 Assert::Equal<DWORD>(20, pVersion1->dwMinor);
655 Assert::Equal<DWORD>(30, pVersion1->dwPatch);
656 Assert::Equal<DWORD>(40, pVersion1->dwRevision);
657 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
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);
662 Assert::Equal<BOOL>(TRUE, pVersion1->fHasPatch);
663 Assert::Equal<BOOL>(TRUE, pVersion1->fHasRevision);
664
665 NativeAssert::StringEqual(wzVersion1, pVersion2->sczVersion);
666 Assert::Equal<WCHAR>(L'v', pVersion2->chPrefix);
667 Assert::Equal<DWORD>(10, pVersion2->dwMajor);
668 Assert::Equal<DWORD>(20, pVersion2->dwMinor);
669 Assert::Equal<DWORD>(30, pVersion2->dwPatch);
670 Assert::Equal<DWORD>(40, pVersion2->dwRevision);
671 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
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);
676 Assert::Equal<BOOL>(TRUE, pVersion2->fHasPatch);
677 Assert::Equal<BOOL>(TRUE, pVersion2->fHasRevision);
678
679 NativeAssert::StringEqual(wzVersion1, pVersion3->sczVersion);
680 Assert::Equal<WCHAR>(L'V', pVersion3->chPrefix);
681 Assert::Equal<DWORD>(10, pVersion3->dwMajor);
682 Assert::Equal<DWORD>(20, pVersion3->dwMinor);
683 Assert::Equal<DWORD>(30, pVersion3->dwPatch);
684 Assert::Equal<DWORD>(40, pVersion3->dwRevision);
685 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
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);
690 Assert::Equal<BOOL>(TRUE, pVersion3->fHasPatch);
691 Assert::Equal<BOOL>(TRUE, pVersion3->fHasRevision);
692
693 NativeAssert::StringEqual(L"10.20.30.40-abc", pVersion4->sczVersion);
694 Assert::Equal<WCHAR>(L'v', pVersion4->chPrefix);
695 Assert::Equal<DWORD>(10, pVersion4->dwMajor);
696 Assert::Equal<DWORD>(20, pVersion4->dwMinor);
697 Assert::Equal<DWORD>(30, pVersion4->dwPatch);
698 Assert::Equal<DWORD>(40, pVersion4->dwRevision);
699 Assert::Equal<DWORD>(1, pVersion4->cReleaseLabels);
700
701 Assert::Equal<BOOL>(FALSE, pVersion4->rgReleaseLabels[0].fNumeric);
702 Assert::Equal<DWORD>(3, pVersion4->rgReleaseLabels[0].cchLabel);
703 Assert::Equal<SIZE_T>(12, pVersion4->rgReleaseLabels[0].cchLabelOffset);
704
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);
709 Assert::Equal<BOOL>(TRUE, pVersion4->fHasPatch);
710 Assert::Equal<BOOL>(TRUE, pVersion4->fHasRevision);
711
712 NativeAssert::StringEqual(wzVersion5, pVersion5->sczVersion);
713 Assert::Equal<WCHAR>(L'\0', pVersion5->chPrefix);
714 Assert::Equal<DWORD>(0, pVersion5->dwMajor);
715 Assert::Equal<DWORD>(0, pVersion5->dwMinor);
716 Assert::Equal<DWORD>(0, pVersion5->dwPatch);
717 Assert::Equal<DWORD>(0, pVersion5->dwRevision);
718 Assert::Equal<DWORD>(0, pVersion5->cReleaseLabels);
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);
723 Assert::Equal<BOOL>(FALSE, pVersion5->fHasPatch);
724 Assert::Equal<BOOL>(FALSE, pVersion5->fHasRevision);
725
726 TestVerutilCompareParsedVersions(pVersion1, pVersion2, 0);
727 TestVerutilCompareParsedVersions(pVersion1, pVersion3, 0);
728 TestVerutilCompareParsedVersions(pVersion1, pVersion4, 1);
729 }
730 finally
731 {
732 ReleaseVerutilVersion(pVersion1);
733 ReleaseVerutilVersion(pVersion2);
734 ReleaseVerutilVersion(pVersion3);
735 ReleaseVerutilVersion(pVersion4);
736 ReleaseVerutilVersion(pVersion5);
737 }
738 }
739
740 [Fact]
741 void VerCompareVersionsHandlesTooLargeNumbers()
742 {
743 HRESULT hr = S_OK;
744 VERUTIL_VERSION* pVersion1 = NULL;
745 VERUTIL_VERSION* pVersion2 = NULL;
746 LPCWSTR wzVersion1 = L"4294967295.4294967295.4294967295.4294967295";
747 LPCWSTR wzVersion2 = L"4294967296.4294967296.4294967296.4294967296";
748
749 try
750 {
751 hr = VerParseVersion(wzVersion1, 0, FALSE, &pVersion1);
752 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion1);
753
754 hr = VerParseVersion(wzVersion2, 0, FALSE, &pVersion2);
755 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion2);
756
757 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
758 Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
759 Assert::Equal<DWORD>(4294967295, pVersion1->dwMajor);
760 Assert::Equal<DWORD>(4294967295, pVersion1->dwMinor);
761 Assert::Equal<DWORD>(4294967295, pVersion1->dwPatch);
762 Assert::Equal<DWORD>(4294967295, pVersion1->dwRevision);
763 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
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);
768 Assert::Equal<BOOL>(TRUE, pVersion1->fHasPatch);
769 Assert::Equal<BOOL>(TRUE, pVersion1->fHasRevision);
770
771 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
772 Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
773 Assert::Equal<DWORD>(0, pVersion2->dwMajor);
774 Assert::Equal<DWORD>(0, pVersion2->dwMinor);
775 Assert::Equal<DWORD>(0, pVersion2->dwPatch);
776 Assert::Equal<DWORD>(0, pVersion2->dwRevision);
777 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
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);
782 Assert::Equal<BOOL>(FALSE, pVersion2->fHasPatch);
783 Assert::Equal<BOOL>(FALSE, pVersion2->fHasRevision);
784
785 TestVerutilCompareParsedVersions(pVersion1, pVersion2, 1);
786 }
787 finally
788 {
789 ReleaseVerutilVersion(pVersion1);
790 ReleaseVerutilVersion(pVersion2);
791 }
792 }
793
794 [Fact]
795 void VerCompareVersionsIgnoresMetadataForValidVersions()
796 {
797 HRESULT hr = S_OK;
798 VERUTIL_VERSION* pVersion1 = NULL;
799 VERUTIL_VERSION* pVersion2 = NULL;
800 LPCWSTR wzVersion1 = L"1.2.3+abc";
801 LPCWSTR wzVersion2 = L"1.2.3+xyz";
802
803 try
804 {
805 hr = VerParseVersion(wzVersion1, 0, FALSE, &pVersion1);
806 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion1);
807
808 hr = VerParseVersion(wzVersion2, 0, FALSE, &pVersion2);
809 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion2);
810
811 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
812 Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
813 Assert::Equal<DWORD>(1, pVersion1->dwMajor);
814 Assert::Equal<DWORD>(2, pVersion1->dwMinor);
815 Assert::Equal<DWORD>(3, pVersion1->dwPatch);
816 Assert::Equal<DWORD>(0, pVersion1->dwRevision);
817 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
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);
822 Assert::Equal<BOOL>(TRUE, pVersion1->fHasPatch);
823 Assert::Equal<BOOL>(FALSE, pVersion1->fHasRevision);
824
825 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
826 Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
827 Assert::Equal<DWORD>(1, pVersion2->dwMajor);
828 Assert::Equal<DWORD>(2, pVersion2->dwMinor);
829 Assert::Equal<DWORD>(3, pVersion2->dwPatch);
830 Assert::Equal<DWORD>(0, pVersion2->dwRevision);
831 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
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);
836 Assert::Equal<BOOL>(TRUE, pVersion2->fHasPatch);
837 Assert::Equal<BOOL>(FALSE, pVersion2->fHasRevision);
838
839 TestVerutilCompareParsedVersions(pVersion1, pVersion2, 0);
840 }
841 finally
842 {
843 ReleaseVerutilVersion(pVersion1);
844 ReleaseVerutilVersion(pVersion2);
845 }
846 }
847
848 [Fact]
849 void VerCopyVersionCopiesVersion()
850 {
851 HRESULT hr = S_OK;
852 LPCWSTR wzVersion = L"1.2.3.4+abc123";
853 VERUTIL_VERSION* pSource = NULL;
854 VERUTIL_VERSION* pCopy = NULL;
855 int nResult = 0;
856
857 try
858 {
859 hr = VerParseVersion(wzVersion, 0, FALSE, &pSource);
860 NativeAssert::Succeeded(hr, "VerParseVersion failed");
861
862 NativeAssert::StringEqual(wzVersion, pSource->sczVersion);
863 Assert::Equal<WCHAR>(L'\0', pSource->chPrefix);
864 Assert::Equal<DWORD>(1, pSource->dwMajor);
865 Assert::Equal<DWORD>(2, pSource->dwMinor);
866 Assert::Equal<DWORD>(3, pSource->dwPatch);
867 Assert::Equal<DWORD>(4, pSource->dwRevision);
868 Assert::Equal<DWORD>(0, pSource->cReleaseLabels);
869
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);
874 Assert::Equal<BOOL>(TRUE, pSource->fHasPatch);
875 Assert::Equal<BOOL>(TRUE, pSource->fHasRevision);
876
877 hr = VerCopyVersion(pSource, &pCopy);
878 NativeAssert::Succeeded(hr, "VerCopyVersion failed");
879
880 Assert::False(pSource == pCopy);
881 Assert::False(pSource->sczVersion == pCopy->sczVersion);
882 Assert::Equal<WCHAR>(L'\0', pCopy->chPrefix);
883 Assert::Equal<BOOL>(TRUE, pCopy->fHasMajor);
884 Assert::Equal<BOOL>(TRUE, pCopy->fHasMinor);
885 Assert::Equal<BOOL>(TRUE, pCopy->fHasPatch);
886 Assert::Equal<BOOL>(TRUE, pCopy->fHasRevision);
887
888 hr = VerCompareParsedVersions(pSource, pCopy, &nResult);
889 NativeAssert::Succeeded(hr, "VerCompareParsedVersions failed");
890
891 Assert::Equal<int>(nResult, 0);
892 }
893 finally
894 {
895 ReleaseVerutilVersion(pCopy);
896 ReleaseVerutilVersion(pSource);
897 }
898 }
899
900 [Fact]
901 void VerCopyVersionCopiesPrereleaseVersion()
902 {
903 HRESULT hr = S_OK;
904 LPCWSTR wzVersion = L"v1.2.3.4-a.b.c.d.5.+abc123";
905 VERUTIL_VERSION* pSource = NULL;
906 VERUTIL_VERSION* pCopy = NULL;
907 int nResult = 0;
908
909 try
910 {
911 hr = VerParseVersion(wzVersion, 0, FALSE, &pSource);
912 NativeAssert::Succeeded(hr, "VerParseVersion failed");
913
914 NativeAssert::StringEqual(L"1.2.3.4-a.b.c.d.5.+abc123", pSource->sczVersion);
915 Assert::Equal<WCHAR>(L'v', pSource->chPrefix);
916 Assert::Equal<DWORD>(1, pSource->dwMajor);
917 Assert::Equal<DWORD>(2, pSource->dwMinor);
918 Assert::Equal<DWORD>(3, pSource->dwPatch);
919 Assert::Equal<DWORD>(4, pSource->dwRevision);
920 Assert::Equal<DWORD>(5, pSource->cReleaseLabels);
921
922 Assert::Equal<BOOL>(FALSE, pSource->rgReleaseLabels[0].fNumeric);
923 Assert::Equal<DWORD>(1, pSource->rgReleaseLabels[0].cchLabel);
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<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<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<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<SIZE_T>(16, pSource->rgReleaseLabels[4].cchLabelOffset);
942
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);
947 Assert::Equal<BOOL>(TRUE, pSource->fHasPatch);
948 Assert::Equal<BOOL>(TRUE, pSource->fHasRevision);
949
950 hr = VerCopyVersion(pSource, &pCopy);
951 NativeAssert::Succeeded(hr, "VerCopyVersion failed");
952
953 Assert::False(pSource == pCopy);
954 Assert::False(pSource->sczVersion == pCopy->sczVersion);
955 Assert::False(pSource->rgReleaseLabels == pCopy->rgReleaseLabels);
956 Assert::Equal<WCHAR>(L'v', pCopy->chPrefix);
957 Assert::Equal<BOOL>(TRUE, pCopy->fHasMajor);
958 Assert::Equal<BOOL>(TRUE, pCopy->fHasMinor);
959 Assert::Equal<BOOL>(TRUE, pCopy->fHasPatch);
960 Assert::Equal<BOOL>(TRUE, pCopy->fHasRevision);
961
962 hr = VerCompareParsedVersions(pSource, pCopy, &nResult);
963 NativeAssert::Succeeded(hr, "VerCompareParsedVersions failed");
964
965 Assert::Equal<int>(nResult, 0);
966 }
967 finally
968 {
969 ReleaseVerutilVersion(pCopy);
970 ReleaseVerutilVersion(pSource);
971 }
972 }
973
974 [Fact]
975 void VerParseVersionTreatsTrailingDotsAsInvalid()
976 {
977 HRESULT hr = S_OK;
978 VERUTIL_VERSION* pVersion1 = NULL;
979 VERUTIL_VERSION* pVersion2 = NULL;
980 VERUTIL_VERSION* pVersion3 = NULL;
981 VERUTIL_VERSION* pVersion4 = NULL;
982 VERUTIL_VERSION* pVersion5 = NULL;
983 VERUTIL_VERSION* pVersion6 = NULL;
984 VERUTIL_VERSION* pVersion7 = NULL;
985 LPCWSTR wzVersion1 = L".";
986 LPCWSTR wzVersion2 = L"1.";
987 LPCWSTR wzVersion3 = L"2.1.";
988 LPCWSTR wzVersion4 = L"3.2.1.";
989 LPCWSTR wzVersion5 = L"4.3.2.1.";
990 LPCWSTR wzVersion6 = L"5-.";
991 LPCWSTR wzVersion7 = L"6-a.";
992
993 try
994 {
995 hr = VerParseVersion(wzVersion1, 0, FALSE, &pVersion1);
996 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion1);
997
998 hr = VerParseVersion(wzVersion2, 0, FALSE, &pVersion2);
999 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion2);
1000
1001 hr = VerParseVersion(wzVersion3, 0, FALSE, &pVersion3);
1002 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion3);
1003
1004 hr = VerParseVersion(wzVersion4, 0, FALSE, &pVersion4);
1005 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion4);
1006
1007 hr = VerParseVersion(wzVersion5, 0, FALSE, &pVersion5);
1008 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion5);
1009
1010 hr = VerParseVersion(wzVersion6, 0, FALSE, &pVersion6);
1011 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion6);
1012
1013 hr = VerParseVersion(wzVersion7, 0, FALSE, &pVersion7);
1014 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion7);
1015
1016 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
1017 Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
1018 Assert::Equal<DWORD>(0, pVersion1->dwMajor);
1019 Assert::Equal<DWORD>(0, pVersion1->dwMinor);
1020 Assert::Equal<DWORD>(0, pVersion1->dwPatch);
1021 Assert::Equal<DWORD>(0, pVersion1->dwRevision);
1022 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
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);
1027 Assert::Equal<BOOL>(FALSE, pVersion1->fHasPatch);
1028 Assert::Equal<BOOL>(FALSE, pVersion1->fHasRevision);
1029
1030 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
1031 Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
1032 Assert::Equal<DWORD>(1, pVersion2->dwMajor);
1033 Assert::Equal<DWORD>(0, pVersion2->dwMinor);
1034 Assert::Equal<DWORD>(0, pVersion2->dwPatch);
1035 Assert::Equal<DWORD>(0, pVersion2->dwRevision);
1036 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
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);
1041 Assert::Equal<BOOL>(FALSE, pVersion2->fHasPatch);
1042 Assert::Equal<BOOL>(FALSE, pVersion2->fHasRevision);
1043
1044 NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion);
1045 Assert::Equal<WCHAR>(L'\0', pVersion3->chPrefix);
1046 Assert::Equal<DWORD>(2, pVersion3->dwMajor);
1047 Assert::Equal<DWORD>(1, pVersion3->dwMinor);
1048 Assert::Equal<DWORD>(0, pVersion3->dwPatch);
1049 Assert::Equal<DWORD>(0, pVersion3->dwRevision);
1050 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
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);
1055 Assert::Equal<BOOL>(FALSE, pVersion3->fHasPatch);
1056 Assert::Equal<BOOL>(FALSE, pVersion3->fHasRevision);
1057
1058 NativeAssert::StringEqual(wzVersion4, pVersion4->sczVersion);
1059 Assert::Equal<WCHAR>(L'\0', pVersion4->chPrefix);
1060 Assert::Equal<DWORD>(3, pVersion4->dwMajor);
1061 Assert::Equal<DWORD>(2, pVersion4->dwMinor);
1062 Assert::Equal<DWORD>(1, pVersion4->dwPatch);
1063 Assert::Equal<DWORD>(0, pVersion4->dwRevision);
1064 Assert::Equal<DWORD>(0, pVersion4->cReleaseLabels);
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);
1069 Assert::Equal<BOOL>(TRUE, pVersion4->fHasPatch);
1070 Assert::Equal<BOOL>(FALSE, pVersion4->fHasRevision);
1071
1072 NativeAssert::StringEqual(wzVersion5, pVersion5->sczVersion);
1073 Assert::Equal<WCHAR>(L'\0', pVersion5->chPrefix);
1074 Assert::Equal<DWORD>(4, pVersion5->dwMajor);
1075 Assert::Equal<DWORD>(3, pVersion5->dwMinor);
1076 Assert::Equal<DWORD>(2, pVersion5->dwPatch);
1077 Assert::Equal<DWORD>(1, pVersion5->dwRevision);
1078 Assert::Equal<DWORD>(0, pVersion5->cReleaseLabels);
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);
1083 Assert::Equal<BOOL>(TRUE, pVersion5->fHasPatch);
1084 Assert::Equal<BOOL>(TRUE, pVersion5->fHasRevision);
1085
1086 NativeAssert::StringEqual(wzVersion6, pVersion6->sczVersion);
1087 Assert::Equal<WCHAR>(L'\0', pVersion6->chPrefix);
1088 Assert::Equal<DWORD>(5, pVersion6->dwMajor);
1089 Assert::Equal<DWORD>(0, pVersion6->dwMinor);
1090 Assert::Equal<DWORD>(0, pVersion6->dwPatch);
1091 Assert::Equal<DWORD>(0, pVersion6->dwRevision);
1092 Assert::Equal<DWORD>(0, pVersion6->cReleaseLabels);
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);
1097 Assert::Equal<BOOL>(FALSE, pVersion6->fHasPatch);
1098 Assert::Equal<BOOL>(FALSE, pVersion6->fHasRevision);
1099
1100 NativeAssert::StringEqual(wzVersion7, pVersion7->sczVersion);
1101 Assert::Equal<WCHAR>(L'\0', pVersion7->chPrefix);
1102 Assert::Equal<DWORD>(6, pVersion7->dwMajor);
1103 Assert::Equal<DWORD>(0, pVersion7->dwMinor);
1104 Assert::Equal<DWORD>(0, pVersion7->dwPatch);
1105 Assert::Equal<DWORD>(0, pVersion7->dwRevision);
1106 Assert::Equal<DWORD>(1, pVersion7->cReleaseLabels);
1107
1108 Assert::Equal<BOOL>(FALSE, pVersion7->rgReleaseLabels[0].fNumeric);
1109 Assert::Equal<DWORD>(1, pVersion7->rgReleaseLabels[0].cchLabel);
1110 Assert::Equal<SIZE_T>(2, pVersion7->rgReleaseLabels[0].cchLabelOffset);
1111
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);
1116 Assert::Equal<BOOL>(FALSE, pVersion7->fHasPatch);
1117 Assert::Equal<BOOL>(FALSE, pVersion7->fHasRevision);
1118 }
1119 finally
1120 {
1121 ReleaseVerutilVersion(pVersion1);
1122 ReleaseVerutilVersion(pVersion2);
1123 ReleaseVerutilVersion(pVersion3);
1124 ReleaseVerutilVersion(pVersion4);
1125 ReleaseVerutilVersion(pVersion5);
1126 ReleaseVerutilVersion(pVersion6);
1127 ReleaseVerutilVersion(pVersion7);
1128 }
1129 }
1130
1131 [Fact]
1132 void VerVersionFromQwordCreatesVersion()
1133 {
1134 HRESULT hr = S_OK;
1135 VERUTIL_VERSION* pVersion1 = NULL;
1136
1137 try
1138 {
1139 hr = VerVersionFromQword(MAKEQWORDVERSION(1, 2, 3, 4), &pVersion1);
1140 NativeAssert::Succeeded(hr, "VerVersionFromQword failed");
1141
1142 NativeAssert::StringEqual(L"1.2.3.4", pVersion1->sczVersion);
1143 Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
1144 Assert::Equal<DWORD>(1, pVersion1->dwMajor);
1145 Assert::Equal<DWORD>(2, pVersion1->dwMinor);
1146 Assert::Equal<DWORD>(3, pVersion1->dwPatch);
1147 Assert::Equal<DWORD>(4, pVersion1->dwRevision);
1148 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
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);
1153 Assert::Equal<BOOL>(TRUE, pVersion1->fHasPatch);
1154 Assert::Equal<BOOL>(TRUE, pVersion1->fHasRevision);
1155 }
1156 finally
1157 {
1158 ReleaseVerutilVersion(pVersion1);
1159 }
1160 }
1161
1162 private:
1163 void TestVerutilCompareParsedVersions(VERUTIL_VERSION* pVersion1, VERUTIL_VERSION* pVersion2, int nExpectedResult)
1164 {
1165 HRESULT hr = S_OK;
1166 int nResult = 0;
1167
1168 hr = VerCompareParsedVersions(pVersion1, pVersion2, &nResult);
1169 NativeAssert::Succeeded(hr, "Failed to compare versions '{0}' and '{1}'", pVersion1->sczVersion, pVersion2->sczVersion);
1170
1171 Assert::Equal(nExpectedResult, nResult);
1172
1173 hr = VerCompareParsedVersions(pVersion2, pVersion1, &nResult);
1174 NativeAssert::Succeeded(hr, "Failed to compare versions '{0}' and '{1}'", pVersion1->sczVersion, pVersion2->sczVersion);
1175
1176 Assert::Equal(nExpectedResult, -nResult);
1177 }
1178 };
1179 }