@joebigelow / wix-1 / commits / 46fb0597

Keep track of when parts of verutil/WixVersions are missing.

Return null when WixVersion.TryParse returns false. 6776

Sean Hall committed May 16, 2022 at 16:07 UTC 46fb0597d4d6192833ddcf836f4bcf6295ef0aaf
9 files changed +322 -22
src/api/burn/WixToolset.Mba.Core/VerUtil.cs
+4
@@ -68,6 +68,10 @@ namespace WixToolset.Mba.Core
68 public IntPtr rgReleaseLabels;
69 public IntPtr cchMetadataOffset;
70 public bool fInvalid;
71 + public bool fHasMajor;
72 + public bool fHasMinor;
73 + public bool fHasPatch;
74 + public bool fHasRevision;
75 }
76
77 internal static string VersionStringFromOffset(IntPtr wzVersion, IntPtr cchOffset, int? cchLength = null)
src/api/burn/WixToolset.Mba.Core/VerUtilVersion.cs
+24
@@ -25,6 +25,10 @@ namespace WixToolset.Mba.Core
25 this.ReleaseLabels = new VerUtilVersionReleaseLabel[version.cReleaseLabels];
26 this.Metadata = VerUtil.VersionStringFromOffset(version.sczVersion, version.cchMetadataOffset);
27 this.IsInvalid = version.fInvalid;
28 + this.HasMajor = version.fHasMajor;
29 + this.HasMinor = version.fHasMinor;
30 + this.HasPatch = version.fHasPatch;
31 + this.HasRevision = version.fHasRevision;
32
33 for (var i = 0; i < version.cReleaseLabels; ++i)
34 {
@@ -80,6 +84,26 @@ namespace WixToolset.Mba.Core
84 /// </summary>
85 public bool IsInvalid { get; private set; }
86
87 + /// <summary>
88 + /// Whether the Major part was specified.
89 + /// </summary>
90 + public bool HasMajor { get; private set; }
91 +
92 + /// <summary>
93 + /// Whether the Minor part was specified.
94 + /// </summary>
95 + public bool HasMinor { get; private set; }
96 +
97 + /// <summary>
98 + /// Whether the Patch part was specified.
99 + /// </summary>
100 + public bool HasPatch { get; private set; }
101 +
102 + /// <summary>
103 + /// Whether the Revision part was specified.
104 + /// </summary>
105 + public bool HasRevision { get; private set; }
106 +
107 /// <inheritdoc/>
108 public void Dispose()
109 {
src/api/burn/test/WixToolsetTest.Mba.Core/VerUtilFixture.cs
+8
@@ -57,6 +57,10 @@ namespace WixToolsetTest.Mba.Core
57 Assert.Empty(parsedVersion.ReleaseLabels);
58 Assert.Equal("", parsedVersion.Metadata);
59 Assert.False(parsedVersion.IsInvalid);
60 + Assert.True(parsedVersion.HasMajor);
61 + Assert.True(parsedVersion.HasMinor);
62 + Assert.True(parsedVersion.HasPatch);
63 + Assert.True(parsedVersion.HasRevision);
64 }
65
66 [Fact]
@@ -74,6 +78,10 @@ namespace WixToolsetTest.Mba.Core
78 Assert.Equal(5, parsedVersion.ReleaseLabels.Length);
79 Assert.Equal("+abc123", parsedVersion.Metadata);
80 Assert.True(parsedVersion.IsInvalid);
81 + Assert.True(parsedVersion.HasMajor);
82 + Assert.True(parsedVersion.HasMinor);
83 + Assert.True(parsedVersion.HasPatch);
84 + Assert.True(parsedVersion.HasRevision);
85
86 Assert.Equal("a", parsedVersion.ReleaseLabels[0].Label);
87 Assert.False(parsedVersion.ReleaseLabels[0].IsNumeric);
src/api/wix/WixToolset.Data/WixVersion.cs
+29 -4
@@ -22,22 +22,42 @@ namespace WixToolset.Data
22 /// <summary>
23 /// Gets or sets the major version.
24 /// </summary>
25 - public uint? Major { get; set; }
25 + public uint Major { get; set; }
26
27 /// <summary>
28 /// Gets or sets the minor version.
29 /// </summary>
30 - public uint? Minor { get; set; }
30 + public uint Minor { get; set; }
31
32 /// <summary>
33 /// Gets or sets the patch version.
34 /// </summary>
35 - public uint? Patch { get; set; }
35 + public uint Patch { get; set; }
36
37 /// <summary>
38 /// Gets or sets the revision version.
39 /// </summary>
40 - public uint? Revision { get; set; }
40 + public uint Revision { get; set; }
41 +
42 + /// <summary>
43 + /// Gets or sets whether the major version was defined.
44 + /// </summary>
45 + public bool HasMajor { get; set; }
46 +
47 + /// <summary>
48 + /// Gets or sets the whether the minor version was defined.
49 + /// </summary>
50 + public bool HasMinor { get; set; }
51 +
52 + /// <summary>
53 + /// Gets or sets the whether the patch version was defined.
54 + /// </summary>
55 + public bool HasPatch { get; set; }
56 +
57 + /// <summary>
58 + /// Gets or sets the whether the revision version was defined.
59 + /// </summary>
60 + public bool HasRevision { get; set; }
61
62 /// <summary>
63 /// Gets or sets the labels in the version.
@@ -143,15 +163,19 @@ namespace WixToolset.Data
163 {
164 case 0:
165 version.Major = part;
166 + version.HasMajor = true;
167 break;
168 case 1:
169 version.Minor = part;
170 + version.HasMinor = true;
171 break;
172 case 2:
173 version.Patch = part;
174 + version.HasPatch = true;
175 break;
176 case 3:
177 version.Revision = part;
178 + version.HasRevision = true;
179 break;
180 }
181
@@ -264,6 +288,7 @@ namespace WixToolset.Data
288
289 if (invalid)
290 {
291 + version = null;
292 return false;
293 }
294
src/api/wix/test/WixToolsetTest.Data/WixVerFixture.cs
+67 -13
@@ -11,13 +11,15 @@ namespace WixToolsetTest.Data
11 [Fact]
12 public void CannotParseEmptyStringAsVersion()
13 {
14 - Assert.False(WixVersion.TryParse(String.Empty, out var _));
14 + Assert.False(WixVersion.TryParse(String.Empty, out var version));
15 + Assert.Null(version);
16 }
17
18 [Fact]
19 public void CannotParseInvalidStringAsVersion()
20 {
20 - Assert.False(WixVersion.TryParse("invalid", out var _));
21 + Assert.False(WixVersion.TryParse("invalid", out var version));
22 + Assert.Null(version);
23 }
24
25 [Fact]
@@ -29,6 +31,10 @@ namespace WixToolsetTest.Data
31 Assert.Equal((uint)2, version.Minor);
32 Assert.Equal((uint)3, version.Patch);
33 Assert.Equal((uint)4, version.Revision);
34 + Assert.True(version.HasMajor);
35 + Assert.True(version.HasMinor);
36 + Assert.True(version.HasPatch);
37 + Assert.True(version.HasRevision);
38 Assert.Null(version.Labels);
39 Assert.Null(version.Metadata);
40 }
@@ -41,7 +47,11 @@ namespace WixToolsetTest.Data
47 Assert.Equal((uint)1, version.Major);
48 Assert.Equal((uint)2, version.Minor);
49 Assert.Equal((uint)3, version.Patch);
44 - Assert.Null(version.Revision);
50 + Assert.Equal((uint)0, version.Revision);
51 + Assert.True(version.HasMajor);
52 + Assert.True(version.HasMinor);
53 + Assert.True(version.HasPatch);
54 + Assert.False(version.HasRevision);
55 Assert.Null(version.Labels);
56 Assert.Null(version.Metadata);
57 }
@@ -55,6 +65,10 @@ namespace WixToolsetTest.Data
65 Assert.Equal((uint)2, version.Minor);
66 Assert.Equal((uint)3, version.Patch);
67 Assert.Equal((uint)0, version.Revision);
68 + Assert.True(version.HasMajor);
69 + Assert.True(version.HasMinor);
70 + Assert.True(version.HasPatch);
71 + Assert.True(version.HasRevision);
72 Assert.Null(version.Labels);
73 Assert.Null(version.Metadata);
74 }
@@ -66,8 +80,12 @@ namespace WixToolsetTest.Data
80 Assert.Null(version.Prefix);
81 Assert.Equal((uint)1, version.Major);
82 Assert.Equal((uint)2, version.Minor);
69 - Assert.Null(version.Patch);
70 - Assert.Null(version.Revision);
83 + Assert.Equal((uint)0, version.Patch);
84 + Assert.Equal((uint)0, version.Revision);
85 + Assert.True(version.HasMajor);
86 + Assert.True(version.HasMinor);
87 + Assert.False(version.HasPatch);
88 + Assert.False(version.HasRevision);
89 Assert.Equal("19", version.Labels[0].Label);
90 Assert.Equal((uint)19, version.Labels[0].Numeric);
91 Assert.Null(version.Metadata);
@@ -80,8 +98,12 @@ namespace WixToolsetTest.Data
98 Assert.Null(version.Prefix);
99 Assert.Equal((uint)1, version.Major);
100 Assert.Equal((uint)2, version.Minor);
83 - Assert.Null(version.Patch);
84 - Assert.Null(version.Revision);
101 + Assert.Equal((uint)0, version.Patch);
102 + Assert.Equal((uint)0, version.Revision);
103 + Assert.True(version.HasMajor);
104 + Assert.True(version.HasMinor);
105 + Assert.False(version.HasPatch);
106 + Assert.False(version.HasRevision);
107 Assert.Equal("2", version.Labels[0].Label);
108 Assert.Equal((uint)2, version.Labels[0].Numeric);
109 Assert.Equal("0", version.Labels[1].Label);
@@ -97,6 +119,11 @@ namespace WixToolsetTest.Data
119 Assert.Equal((uint)0, version.Major);
120 Assert.Equal((uint)0, version.Minor);
121 Assert.Equal((uint)1, version.Patch);
122 + Assert.Equal((uint)0, version.Revision);
123 + Assert.True(version.HasMajor);
124 + Assert.True(version.HasMinor);
125 + Assert.True(version.HasPatch);
126 + Assert.False(version.HasRevision);
127 Assert.Equal("a", version.Labels[0].Label);
128 Assert.Null(version.Labels[0].Numeric);
129 Assert.Null(version.Metadata);
@@ -109,8 +136,12 @@ namespace WixToolsetTest.Data
136 Assert.Null(version.Prefix);
137 Assert.Equal((uint)0, version.Major);
138 Assert.Equal((uint)1, version.Minor);
112 - Assert.Null(version.Patch);
113 - Assert.Null(version.Revision);
139 + Assert.Equal((uint)0, version.Patch);
140 + Assert.Equal((uint)0, version.Revision);
141 + Assert.True(version.HasMajor);
142 + Assert.True(version.HasMinor);
143 + Assert.False(version.HasPatch);
144 + Assert.False(version.HasRevision);
145 Assert.Equal("a", version.Labels[0].Label);
146 Assert.Null(version.Labels[0].Numeric);
147 Assert.Equal("000", version.Labels[1].Label);
@@ -126,7 +157,11 @@ namespace WixToolsetTest.Data
157 Assert.Equal((uint)1, version.Major);
158 Assert.Equal((uint)2, version.Minor);
159 Assert.Equal((uint)3, version.Patch);
129 - Assert.Null(version.Revision);
160 + Assert.Equal((uint)0, version.Revision);
161 + Assert.True(version.HasMajor);
162 + Assert.True(version.HasMinor);
163 + Assert.True(version.HasPatch);
164 + Assert.False(version.HasRevision);
165 Assert.Null(version.Labels);
166 Assert.Equal("abcd", version.Metadata);
167 }
@@ -134,8 +169,10 @@ namespace WixToolsetTest.Data
169 [Fact]
170 public void CannotParseUnexpectedContentAsMetadata()
171 {
137 - Assert.False(WixVersion.TryParse("1.2.3.abcd", out var _));
138 - Assert.False(WixVersion.TryParse("1.2.3.-abcd", out var _));
172 + Assert.False(WixVersion.TryParse("1.2.3.abcd", out var version));
173 + Assert.Null(version);
174 + Assert.False(WixVersion.TryParse("1.2.3.-abcd", out version));
175 + Assert.Null(version);
176 }
177
178 [Fact]
@@ -147,6 +184,10 @@ namespace WixToolsetTest.Data
184 Assert.Equal((uint)20, version.Minor);
185 Assert.Equal((uint)30, version.Patch);
186 Assert.Equal((uint)40, version.Revision);
187 + Assert.True(version.HasMajor);
188 + Assert.True(version.HasMinor);
189 + Assert.True(version.HasPatch);
190 + Assert.True(version.HasRevision);
191 Assert.Null(version.Labels);
192 Assert.Null(version.Metadata);
193
@@ -156,6 +197,10 @@ namespace WixToolsetTest.Data
197 Assert.Equal((uint)200, version2.Minor);
198 Assert.Equal((uint)300, version2.Patch);
199 Assert.Equal((uint)400, version2.Revision);
200 + Assert.True(version.HasMajor);
201 + Assert.True(version.HasMinor);
202 + Assert.True(version.HasPatch);
203 + Assert.True(version.HasRevision);
204 Assert.Null(version2.Labels);
205 Assert.Null(version2.Metadata);
206 }
@@ -169,6 +214,10 @@ namespace WixToolsetTest.Data
214 Assert.Equal(4294967295, version.Minor);
215 Assert.Equal(4294967295, version.Patch);
216 Assert.Equal(4294967295, version.Revision);
217 + Assert.True(version.HasMajor);
218 + Assert.True(version.HasMinor);
219 + Assert.True(version.HasPatch);
220 + Assert.True(version.HasRevision);
221 Assert.Null(version.Labels);
222 Assert.Null(version.Metadata);
223 }
@@ -176,7 +225,8 @@ namespace WixToolsetTest.Data
225 [Fact]
226 public void CannotParseTooLargeNumbers()
227 {
179 - Assert.False(WixVersion.TryParse("4294967296.4294967296.4294967296.4294967296", out var _));
228 + Assert.False(WixVersion.TryParse("4294967296.4294967296.4294967296.4294967296", out var version));
229 + Assert.Null(version);
230 }
231
232 [Fact]
@@ -188,6 +238,10 @@ namespace WixToolsetTest.Data
238 Assert.Equal((uint)2, version.Minor);
239 Assert.Equal((uint)3, version.Patch);
240 Assert.Equal((uint)4, version.Revision);
241 + Assert.True(version.HasMajor);
242 + Assert.True(version.HasMinor);
243 + Assert.True(version.HasPatch);
244 + Assert.True(version.HasRevision);
245 Assert.Equal("a", version.Labels[0].Label);
246 Assert.Null(version.Labels[0].Numeric);
247 Assert.Equal("b", version.Labels[1].Label);
src/libs/dutil/WixToolset.DUtil/inc/verutil.h
+4
@@ -28,6 +28,10 @@ typedef struct _VERUTIL_VERSION
28 VERUTIL_VERSION_RELEASE_LABEL* rgReleaseLabels;
29 SIZE_T cchMetadataOffset;
30 BOOL fInvalid;
31 + BOOL fHasMajor;
32 + BOOL fHasMinor;
33 + BOOL fHasPatch;
34 + BOOL fHasRevision;
35 } VERUTIL_VERSION;
36
37 /*******************************************************************
src/libs/dutil/WixToolset.DUtil/verutil.cpp
+13
@@ -196,9 +196,13 @@ DAPI_(HRESULT) VerCopyVersion(
196
197 pCopy->chPrefix = pSource->chPrefix;
198 pCopy->dwMajor = pSource->dwMajor;
199 + pCopy->fHasMajor = pSource->fHasMajor;
200 pCopy->dwMinor = pSource->dwMinor;
201 + pCopy->fHasMinor = pSource->fHasMinor;
202 pCopy->dwPatch = pSource->dwPatch;
203 + pCopy->fHasPatch = pSource->fHasPatch;
204 pCopy->dwRevision = pSource->dwRevision;
205 + pCopy->fHasRevision = pSource->fHasRevision;
206
207 if (pSource->cReleaseLabels)
208 {
@@ -370,15 +374,19 @@ DAPI_(HRESULT) VerParseVersion(
374 {
375 case 0:
376 pVersion->dwMajor = uPart;
377 + pVersion->fHasMajor = TRUE;
378 break;
379 case 1:
380 pVersion->dwMinor = uPart;
381 + pVersion->fHasMinor = TRUE;
382 break;
383 case 2:
384 pVersion->dwPatch = uPart;
385 + pVersion->fHasPatch = TRUE;
386 break;
387 case 3:
388 pVersion->dwRevision = uPart;
389 + pVersion->fHasRevision = TRUE;
390 break;
391 }
392
@@ -549,6 +557,11 @@ DAPI_(HRESULT) VerVersionFromQword(
557 pVersion->dwPatch = (WORD)(qwVersion >> 16 & 0xffff);
558 pVersion->dwRevision = (WORD)(qwVersion & 0xffff);
559
560 + pVersion->fHasMajor = TRUE;
561 + pVersion->fHasMinor = TRUE;
562 + pVersion->fHasPatch = TRUE;
563 + pVersion->fHasRevision = TRUE;
564 +
565 hr = StrAllocFormatted(&pVersion->sczVersion, L"%lu.%lu.%lu.%lu", pVersion->dwMajor, pVersion->dwMinor, pVersion->dwPatch, pVersion->dwRevision);
566 ExitOnFailure(hr, "Failed to allocate and format the version string.");
567
src/libs/dutil/test/DUtilUnitTest/VerUtilTests.cpp
+168
@@ -42,6 +42,10 @@ namespace DutilTests
42 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
43 Assert::Equal<DWORD>(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,6 +56,10 @@ namespace DutilTests
56 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
57 Assert::Equal<DWORD>(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);
@@ -62,6 +70,10 @@ namespace DutilTests
70 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
71 Assert::Equal<DWORD>(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);
@@ -111,6 +123,10 @@ namespace DutilTests
123
124 Assert::Equal<DWORD>(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);
@@ -127,6 +143,10 @@ namespace DutilTests
143
144 Assert::Equal<DWORD>(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 }
@@ -183,6 +203,10 @@ namespace DutilTests
203 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
204 Assert::Equal<DWORD>(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);
@@ -193,6 +217,10 @@ namespace DutilTests
217 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
218 Assert::Equal<DWORD>(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);
@@ -203,6 +231,10 @@ namespace DutilTests
231 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
232 Assert::Equal<DWORD>(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);
@@ -213,6 +245,10 @@ namespace DutilTests
245 Assert::Equal<DWORD>(0, pVersion4->cReleaseLabels);
246 Assert::Equal<DWORD>(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);
@@ -229,6 +265,10 @@ namespace DutilTests
265
266 Assert::Equal<DWORD>(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);
@@ -245,6 +285,10 @@ namespace DutilTests
285
286 Assert::Equal<DWORD>(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);
@@ -297,6 +341,10 @@ namespace DutilTests
341
342 Assert::Equal<DWORD>(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);
@@ -313,6 +361,10 @@ namespace DutilTests
361
362 Assert::Equal<DWORD>(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);
@@ -329,6 +381,10 @@ namespace DutilTests
381
382 Assert::Equal<DWORD>(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);
@@ -387,6 +443,10 @@ namespace DutilTests
443
444 Assert::Equal<DWORD>(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);
@@ -407,6 +467,10 @@ namespace DutilTests
467
468 Assert::Equal<DWORD>(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);
@@ -431,6 +495,10 @@ namespace DutilTests
495
496 Assert::Equal<DWORD>(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);
@@ -455,6 +523,10 @@ namespace DutilTests
523
524 Assert::Equal<DWORD>(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);
@@ -499,6 +571,10 @@ namespace DutilTests
571 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
572 Assert::Equal<DWORD>(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);
@@ -509,6 +585,10 @@ namespace DutilTests
585 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
586 Assert::Equal<DWORD>(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);
@@ -519,6 +599,10 @@ namespace DutilTests
599 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
600 Assert::Equal<DWORD>(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);
@@ -573,6 +657,10 @@ namespace DutilTests
657 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
658 Assert::Equal<DWORD>(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);
@@ -583,6 +671,10 @@ namespace DutilTests
671 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
672 Assert::Equal<DWORD>(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);
@@ -593,6 +685,10 @@ namespace DutilTests
685 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
686 Assert::Equal<DWORD>(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);
@@ -608,6 +704,10 @@ namespace DutilTests
704
705 Assert::Equal<DWORD>(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);
@@ -618,6 +718,10 @@ namespace DutilTests
718 Assert::Equal<DWORD>(0, pVersion5->cReleaseLabels);
719 Assert::Equal<DWORD>(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);
@@ -659,6 +763,10 @@ namespace DutilTests
763 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
764 Assert::Equal<DWORD>(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);
@@ -669,6 +777,10 @@ namespace DutilTests
777 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
778 Assert::Equal<DWORD>(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 }
@@ -705,6 +817,10 @@ namespace DutilTests
817 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
818 Assert::Equal<DWORD>(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);
@@ -715,6 +831,10 @@ namespace DutilTests
831 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
832 Assert::Equal<DWORD>(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 }
@@ -749,6 +869,10 @@ namespace DutilTests
869
870 Assert::Equal<DWORD>(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");
@@ -756,6 +880,10 @@ namespace DutilTests
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");
@@ -814,6 +942,10 @@ namespace DutilTests
942
943 Assert::Equal<DWORD>(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");
@@ -822,6 +954,10 @@ namespace DutilTests
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");
@@ -886,6 +1022,10 @@ namespace DutilTests
1022 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
1023 Assert::Equal<DWORD>(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);
@@ -896,6 +1036,10 @@ namespace DutilTests
1036 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
1037 Assert::Equal<DWORD>(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);
@@ -906,6 +1050,10 @@ namespace DutilTests
1050 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
1051 Assert::Equal<DWORD>(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);
@@ -916,6 +1064,10 @@ namespace DutilTests
1064 Assert::Equal<DWORD>(0, pVersion4->cReleaseLabels);
1065 Assert::Equal<DWORD>(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);
@@ -926,6 +1078,10 @@ namespace DutilTests
1078 Assert::Equal<DWORD>(0, pVersion5->cReleaseLabels);
1079 Assert::Equal<DWORD>(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);
@@ -936,6 +1092,10 @@ namespace DutilTests
1092 Assert::Equal<DWORD>(0, pVersion6->cReleaseLabels);
1093 Assert::Equal<DWORD>(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);
@@ -951,6 +1111,10 @@ namespace DutilTests
1111
1112 Assert::Equal<DWORD>(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 {
@@ -984,6 +1148,10 @@ namespace DutilTests
1148 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
1149 Assert::Equal<DWORD>(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 {
src/wix/WixToolset.Core.Burn/Bundles/CreateBundleExeCommand.cs
+5 -5
@@ -254,10 +254,10 @@ namespace WixToolset.Core.Burn.Bundles
254 return new Version(0, 0);
255 }
256
257 - var major = wixVersion.Major ?? 0;
258 - var minor = wixVersion.Minor ?? 0;
259 - var build = wixVersion.Patch ?? 0;
260 - var revision = wixVersion.Revision ?? 0;
257 + var major = wixVersion.Major;
258 + var minor = wixVersion.Minor;
259 + var build = wixVersion.Patch;
260 + var revision = wixVersion.Revision;
261
262 if (UInt16.MaxValue < major || UInt16.MaxValue < minor || UInt16.MaxValue < build || UInt16.MaxValue < revision)
263 {
@@ -369,7 +369,7 @@ namespace WixToolset.Core.Burn.Bundles
369 public BURN_SPLASH_SCREEN_TYPE Type;
370
371 [MarshalAs(UnmanagedType.U2)]
372 - public UInt16 ResourceId;
372 + public ushort ResourceId;
373
374 public byte[] ToBytes()
375 {