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

Return null when WixVersion.TryParse returns false.

6776

9 files changed, 322 insertions, 22 deletions

diff --git a/src/api/burn/WixToolset.Mba.Core/VerUtil.cs b/src/api/burn/WixToolset.Mba.Core/VerUtil.cs
index 611f9710..14552310 100644
--- a/src/api/burn/WixToolset.Mba.Core/VerUtil.cs
+++ b/src/api/burn/WixToolset.Mba.Core/VerUtil.cs
@@ -68,6 +68,10 @@ namespace WixToolset.Mba.Core
             public IntPtr rgReleaseLabels;
             public IntPtr cchMetadataOffset;
             public bool fInvalid;
+            public bool fHasMajor;
+            public bool fHasMinor;
+            public bool fHasPatch;
+            public bool fHasRevision;
         }
 
         internal static string VersionStringFromOffset(IntPtr wzVersion, IntPtr cchOffset, int? cchLength = null)
diff --git a/src/api/burn/WixToolset.Mba.Core/VerUtilVersion.cs b/src/api/burn/WixToolset.Mba.Core/VerUtilVersion.cs
index 731dedaf..e0312474 100644
--- a/src/api/burn/WixToolset.Mba.Core/VerUtilVersion.cs
+++ b/src/api/burn/WixToolset.Mba.Core/VerUtilVersion.cs
@@ -25,6 +25,10 @@ namespace WixToolset.Mba.Core
             this.ReleaseLabels = new VerUtilVersionReleaseLabel[version.cReleaseLabels];
             this.Metadata = VerUtil.VersionStringFromOffset(version.sczVersion, version.cchMetadataOffset);
             this.IsInvalid = version.fInvalid;
+            this.HasMajor = version.fHasMajor;
+            this.HasMinor = version.fHasMinor;
+            this.HasPatch = version.fHasPatch;
+            this.HasRevision = version.fHasRevision;
 
             for (var i = 0; i < version.cReleaseLabels; ++i)
             {
@@ -80,6 +84,26 @@ namespace WixToolset.Mba.Core
         /// </summary>
         public bool IsInvalid { get; private set; }
 
+        /// <summary>
+        /// Whether the Major part was specified.
+        /// </summary>
+        public bool HasMajor { get; private set; }
+
+        /// <summary>
+        /// Whether the Minor part was specified.
+        /// </summary>
+        public bool HasMinor { get; private set; }
+
+        /// <summary>
+        /// Whether the Patch part was specified.
+        /// </summary>
+        public bool HasPatch { get; private set; }
+
+        /// <summary>
+        /// Whether the Revision part was specified.
+        /// </summary>
+        public bool HasRevision { get; private set; }
+
         /// <inheritdoc/>
         public void Dispose()
         {
diff --git a/src/api/burn/test/WixToolsetTest.Mba.Core/VerUtilFixture.cs b/src/api/burn/test/WixToolsetTest.Mba.Core/VerUtilFixture.cs
index ceb1b12a..6fb8aced 100644
--- a/src/api/burn/test/WixToolsetTest.Mba.Core/VerUtilFixture.cs
+++ b/src/api/burn/test/WixToolsetTest.Mba.Core/VerUtilFixture.cs
@@ -57,6 +57,10 @@ namespace WixToolsetTest.Mba.Core
             Assert.Empty(parsedVersion.ReleaseLabels);
             Assert.Equal("", parsedVersion.Metadata);
             Assert.False(parsedVersion.IsInvalid);
+            Assert.True(parsedVersion.HasMajor);
+            Assert.True(parsedVersion.HasMinor);
+            Assert.True(parsedVersion.HasPatch);
+            Assert.True(parsedVersion.HasRevision);
         }
 
         [Fact]
@@ -74,6 +78,10 @@ namespace WixToolsetTest.Mba.Core
             Assert.Equal(5, parsedVersion.ReleaseLabels.Length);
             Assert.Equal("+abc123", parsedVersion.Metadata);
             Assert.True(parsedVersion.IsInvalid);
+            Assert.True(parsedVersion.HasMajor);
+            Assert.True(parsedVersion.HasMinor);
+            Assert.True(parsedVersion.HasPatch);
+            Assert.True(parsedVersion.HasRevision);
 
             Assert.Equal("a", parsedVersion.ReleaseLabels[0].Label);
             Assert.False(parsedVersion.ReleaseLabels[0].IsNumeric);
diff --git a/src/api/wix/WixToolset.Data/WixVersion.cs b/src/api/wix/WixToolset.Data/WixVersion.cs
index 2b02bd7d..ab68b55a 100644
--- a/src/api/wix/WixToolset.Data/WixVersion.cs
+++ b/src/api/wix/WixToolset.Data/WixVersion.cs
@@ -22,22 +22,42 @@ namespace WixToolset.Data
         /// <summary>
         /// Gets or sets the major version.
         /// </summary>
-        public uint? Major { get; set; }
+        public uint Major { get; set; }
 
         /// <summary>
         /// Gets or sets the minor version.
         /// </summary>
-        public uint? Minor { get; set; }
+        public uint Minor { get; set; }
 
         /// <summary>
         /// Gets or sets the patch version.
         /// </summary>
-        public uint? Patch { get; set; }
+        public uint Patch { get; set; }
 
         /// <summary>
         /// Gets or sets the revision version.
         /// </summary>
-        public uint? Revision { get; set; }
+        public uint Revision { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether the major version was defined.
+        /// </summary>
+        public bool HasMajor { get; set; }
+
+        /// <summary>
+        /// Gets or sets the whether the minor version was defined.
+        /// </summary>
+        public bool HasMinor { get; set; }
+
+        /// <summary>
+        /// Gets or sets the whether the patch version was defined.
+        /// </summary>
+        public bool HasPatch { get; set; }
+
+        /// <summary>
+        /// Gets or sets the whether the revision version was defined.
+        /// </summary>
+        public bool HasRevision { get; set; }
 
         /// <summary>
         /// Gets or sets the labels in the version.
@@ -143,15 +163,19 @@ namespace WixToolset.Data
                 {
                     case 0:
                         version.Major = part;
+                        version.HasMajor = true;
                         break;
                     case 1:
                         version.Minor = part;
+                        version.HasMinor = true;
                         break;
                     case 2:
                         version.Patch = part;
+                        version.HasPatch = true;
                         break;
                     case 3:
                         version.Revision = part;
+                        version.HasRevision = true;
                         break;
                 }
 
@@ -264,6 +288,7 @@ namespace WixToolset.Data
 
             if (invalid)
             {
+                version = null;
                 return false;
             }
 
diff --git a/src/api/wix/test/WixToolsetTest.Data/WixVerFixture.cs b/src/api/wix/test/WixToolsetTest.Data/WixVerFixture.cs
index 45253460..ffa3213a 100644
--- a/src/api/wix/test/WixToolsetTest.Data/WixVerFixture.cs
+++ b/src/api/wix/test/WixToolsetTest.Data/WixVerFixture.cs
@@ -11,13 +11,15 @@ namespace WixToolsetTest.Data
         [Fact]
         public void CannotParseEmptyStringAsVersion()
         {
-            Assert.False(WixVersion.TryParse(String.Empty, out var _));
+            Assert.False(WixVersion.TryParse(String.Empty, out var version));
+            Assert.Null(version);
         }
 
         [Fact]
         public void CannotParseInvalidStringAsVersion()
         {
-            Assert.False(WixVersion.TryParse("invalid", out var _));
+            Assert.False(WixVersion.TryParse("invalid", out var version));
+            Assert.Null(version);
         }
 
         [Fact]
@@ -29,6 +31,10 @@ namespace WixToolsetTest.Data
             Assert.Equal((uint)2, version.Minor);
             Assert.Equal((uint)3, version.Patch);
             Assert.Equal((uint)4, version.Revision);
+            Assert.True(version.HasMajor);
+            Assert.True(version.HasMinor);
+            Assert.True(version.HasPatch);
+            Assert.True(version.HasRevision);
             Assert.Null(version.Labels);
             Assert.Null(version.Metadata);
         }
@@ -41,7 +47,11 @@ namespace WixToolsetTest.Data
             Assert.Equal((uint)1, version.Major);
             Assert.Equal((uint)2, version.Minor);
             Assert.Equal((uint)3, version.Patch);
-            Assert.Null(version.Revision);
+            Assert.Equal((uint)0, version.Revision);
+            Assert.True(version.HasMajor);
+            Assert.True(version.HasMinor);
+            Assert.True(version.HasPatch);
+            Assert.False(version.HasRevision);
             Assert.Null(version.Labels);
             Assert.Null(version.Metadata);
         }
@@ -55,6 +65,10 @@ namespace WixToolsetTest.Data
             Assert.Equal((uint)2, version.Minor);
             Assert.Equal((uint)3, version.Patch);
             Assert.Equal((uint)0, version.Revision);
+            Assert.True(version.HasMajor);
+            Assert.True(version.HasMinor);
+            Assert.True(version.HasPatch);
+            Assert.True(version.HasRevision);
             Assert.Null(version.Labels);
             Assert.Null(version.Metadata);
         }
@@ -66,8 +80,12 @@ namespace WixToolsetTest.Data
             Assert.Null(version.Prefix);
             Assert.Equal((uint)1, version.Major);
             Assert.Equal((uint)2, version.Minor);
-            Assert.Null(version.Patch);
-            Assert.Null(version.Revision);
+            Assert.Equal((uint)0, version.Patch);
+            Assert.Equal((uint)0, version.Revision);
+            Assert.True(version.HasMajor);
+            Assert.True(version.HasMinor);
+            Assert.False(version.HasPatch);
+            Assert.False(version.HasRevision);
             Assert.Equal("19", version.Labels[0].Label);
             Assert.Equal((uint)19, version.Labels[0].Numeric);
             Assert.Null(version.Metadata);
@@ -80,8 +98,12 @@ namespace WixToolsetTest.Data
             Assert.Null(version.Prefix);
             Assert.Equal((uint)1, version.Major);
             Assert.Equal((uint)2, version.Minor);
-            Assert.Null(version.Patch);
-            Assert.Null(version.Revision);
+            Assert.Equal((uint)0, version.Patch);
+            Assert.Equal((uint)0, version.Revision);
+            Assert.True(version.HasMajor);
+            Assert.True(version.HasMinor);
+            Assert.False(version.HasPatch);
+            Assert.False(version.HasRevision);
             Assert.Equal("2", version.Labels[0].Label);
             Assert.Equal((uint)2, version.Labels[0].Numeric);
             Assert.Equal("0", version.Labels[1].Label);
@@ -97,6 +119,11 @@ namespace WixToolsetTest.Data
             Assert.Equal((uint)0, version.Major);
             Assert.Equal((uint)0, version.Minor);
             Assert.Equal((uint)1, version.Patch);
+            Assert.Equal((uint)0, version.Revision);
+            Assert.True(version.HasMajor);
+            Assert.True(version.HasMinor);
+            Assert.True(version.HasPatch);
+            Assert.False(version.HasRevision);
             Assert.Equal("a", version.Labels[0].Label);
             Assert.Null(version.Labels[0].Numeric);
             Assert.Null(version.Metadata);
@@ -109,8 +136,12 @@ namespace WixToolsetTest.Data
             Assert.Null(version.Prefix);
             Assert.Equal((uint)0, version.Major);
             Assert.Equal((uint)1, version.Minor);
-            Assert.Null(version.Patch);
-            Assert.Null(version.Revision);
+            Assert.Equal((uint)0, version.Patch);
+            Assert.Equal((uint)0, version.Revision);
+            Assert.True(version.HasMajor);
+            Assert.True(version.HasMinor);
+            Assert.False(version.HasPatch);
+            Assert.False(version.HasRevision);
             Assert.Equal("a", version.Labels[0].Label);
             Assert.Null(version.Labels[0].Numeric);
             Assert.Equal("000", version.Labels[1].Label);
@@ -126,7 +157,11 @@ namespace WixToolsetTest.Data
             Assert.Equal((uint)1, version.Major);
             Assert.Equal((uint)2, version.Minor);
             Assert.Equal((uint)3, version.Patch);
-            Assert.Null(version.Revision);
+            Assert.Equal((uint)0, version.Revision);
+            Assert.True(version.HasMajor);
+            Assert.True(version.HasMinor);
+            Assert.True(version.HasPatch);
+            Assert.False(version.HasRevision);
             Assert.Null(version.Labels);
             Assert.Equal("abcd", version.Metadata);
         }
@@ -134,8 +169,10 @@ namespace WixToolsetTest.Data
         [Fact]
         public void CannotParseUnexpectedContentAsMetadata()
         {
-            Assert.False(WixVersion.TryParse("1.2.3.abcd", out var _));
-            Assert.False(WixVersion.TryParse("1.2.3.-abcd", out var _));
+            Assert.False(WixVersion.TryParse("1.2.3.abcd", out var version));
+            Assert.Null(version);
+            Assert.False(WixVersion.TryParse("1.2.3.-abcd", out version));
+            Assert.Null(version);
         }
 
         [Fact]
@@ -147,6 +184,10 @@ namespace WixToolsetTest.Data
             Assert.Equal((uint)20, version.Minor);
             Assert.Equal((uint)30, version.Patch);
             Assert.Equal((uint)40, version.Revision);
+            Assert.True(version.HasMajor);
+            Assert.True(version.HasMinor);
+            Assert.True(version.HasPatch);
+            Assert.True(version.HasRevision);
             Assert.Null(version.Labels);
             Assert.Null(version.Metadata);
 
@@ -156,6 +197,10 @@ namespace WixToolsetTest.Data
             Assert.Equal((uint)200, version2.Minor);
             Assert.Equal((uint)300, version2.Patch);
             Assert.Equal((uint)400, version2.Revision);
+            Assert.True(version.HasMajor);
+            Assert.True(version.HasMinor);
+            Assert.True(version.HasPatch);
+            Assert.True(version.HasRevision);
             Assert.Null(version2.Labels);
             Assert.Null(version2.Metadata);
         }
@@ -169,6 +214,10 @@ namespace WixToolsetTest.Data
             Assert.Equal(4294967295, version.Minor);
             Assert.Equal(4294967295, version.Patch);
             Assert.Equal(4294967295, version.Revision);
+            Assert.True(version.HasMajor);
+            Assert.True(version.HasMinor);
+            Assert.True(version.HasPatch);
+            Assert.True(version.HasRevision);
             Assert.Null(version.Labels);
             Assert.Null(version.Metadata);
         }
@@ -176,7 +225,8 @@ namespace WixToolsetTest.Data
         [Fact]
         public void CannotParseTooLargeNumbers()
         {
-            Assert.False(WixVersion.TryParse("4294967296.4294967296.4294967296.4294967296", out var _));
+            Assert.False(WixVersion.TryParse("4294967296.4294967296.4294967296.4294967296", out var version));
+            Assert.Null(version);
         }
 
         [Fact]
@@ -188,6 +238,10 @@ namespace WixToolsetTest.Data
             Assert.Equal((uint)2, version.Minor);
             Assert.Equal((uint)3, version.Patch);
             Assert.Equal((uint)4, version.Revision);
+            Assert.True(version.HasMajor);
+            Assert.True(version.HasMinor);
+            Assert.True(version.HasPatch);
+            Assert.True(version.HasRevision);
             Assert.Equal("a", version.Labels[0].Label);
             Assert.Null(version.Labels[0].Numeric);
             Assert.Equal("b", version.Labels[1].Label);
diff --git a/src/libs/dutil/WixToolset.DUtil/inc/verutil.h b/src/libs/dutil/WixToolset.DUtil/inc/verutil.h
index 4fdaa522..cab18be7 100644
--- a/src/libs/dutil/WixToolset.DUtil/inc/verutil.h
+++ b/src/libs/dutil/WixToolset.DUtil/inc/verutil.h
@@ -28,6 +28,10 @@ typedef struct _VERUTIL_VERSION
     VERUTIL_VERSION_RELEASE_LABEL* rgReleaseLabels;
     SIZE_T cchMetadataOffset;
     BOOL fInvalid;
+    BOOL fHasMajor;
+    BOOL fHasMinor;
+    BOOL fHasPatch;
+    BOOL fHasRevision;
 } VERUTIL_VERSION;
 
 /*******************************************************************
diff --git a/src/libs/dutil/WixToolset.DUtil/verutil.cpp b/src/libs/dutil/WixToolset.DUtil/verutil.cpp
index 30b979b1..276441b5 100644
--- a/src/libs/dutil/WixToolset.DUtil/verutil.cpp
+++ b/src/libs/dutil/WixToolset.DUtil/verutil.cpp
@@ -196,9 +196,13 @@ DAPI_(HRESULT) VerCopyVersion(
 
     pCopy->chPrefix = pSource->chPrefix;
     pCopy->dwMajor = pSource->dwMajor;
+    pCopy->fHasMajor = pSource->fHasMajor;
     pCopy->dwMinor = pSource->dwMinor;
+    pCopy->fHasMinor = pSource->fHasMinor;
     pCopy->dwPatch = pSource->dwPatch;
+    pCopy->fHasPatch = pSource->fHasPatch;
     pCopy->dwRevision = pSource->dwRevision;
+    pCopy->fHasRevision = pSource->fHasRevision;
 
     if (pSource->cReleaseLabels)
     {
@@ -370,15 +374,19 @@ DAPI_(HRESULT) VerParseVersion(
         {
         case 0:
             pVersion->dwMajor = uPart;
+            pVersion->fHasMajor = TRUE;
             break;
         case 1:
             pVersion->dwMinor = uPart;
+            pVersion->fHasMinor = TRUE;
             break;
         case 2:
             pVersion->dwPatch = uPart;
+            pVersion->fHasPatch = TRUE;
             break;
         case 3:
             pVersion->dwRevision = uPart;
+            pVersion->fHasRevision = TRUE;
             break;
         }
 
@@ -549,6 +557,11 @@ DAPI_(HRESULT) VerVersionFromQword(
     pVersion->dwPatch = (WORD)(qwVersion >> 16 & 0xffff);
     pVersion->dwRevision = (WORD)(qwVersion & 0xffff);
 
+    pVersion->fHasMajor = TRUE;
+    pVersion->fHasMinor = TRUE;
+    pVersion->fHasPatch = TRUE;
+    pVersion->fHasRevision = TRUE;
+
     hr = StrAllocFormatted(&pVersion->sczVersion, L"%lu.%lu.%lu.%lu", pVersion->dwMajor, pVersion->dwMinor, pVersion->dwPatch, pVersion->dwRevision);
     ExitOnFailure(hr, "Failed to allocate and format the version string.");
 
diff --git a/src/libs/dutil/test/DUtilUnitTest/VerUtilTests.cpp b/src/libs/dutil/test/DUtilUnitTest/VerUtilTests.cpp
index c20b9887..3402097c 100644
--- a/src/libs/dutil/test/DUtilUnitTest/VerUtilTests.cpp
+++ b/src/libs/dutil/test/DUtilUnitTest/VerUtilTests.cpp
@@ -42,6 +42,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
                 Assert::Equal<DWORD>(7, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasPatch);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
@@ -52,6 +56,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
                 Assert::Equal<DWORD>(5, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion3->chPrefix);
@@ -62,6 +70,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
                 Assert::Equal<DWORD>(7, pVersion3->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion3->fHasPatch);
+                Assert::Equal<BOOL>(TRUE, pVersion3->fHasRevision);
 
                 TestVerutilCompareParsedVersions(pVersion1, pVersion2, 1);
                 TestVerutilCompareParsedVersions(pVersion3, pVersion2, 0);
@@ -111,6 +123,10 @@ namespace DutilTests
 
                 Assert::Equal<DWORD>(7, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion1->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion1->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
@@ -127,6 +143,10 @@ namespace DutilTests
 
                 Assert::Equal<DWORD>(6, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasRevision);
 
                 TestVerutilCompareParsedVersions(pVersion1, pVersion2, -1);
             }
@@ -183,6 +203,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
                 Assert::Equal<DWORD>(3, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
+                Assert::Equal<BOOL>(FALSE, pVersion1->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion1->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion1->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
@@ -193,6 +217,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
                 Assert::Equal<DWORD>(3, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion3->chPrefix);
@@ -203,6 +231,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
                 Assert::Equal<DWORD>(1, pVersion3->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);
+                Assert::Equal<BOOL>(FALSE, pVersion3->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion3->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion3->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion4, pVersion4->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion4->chPrefix);
@@ -213,6 +245,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion4->cReleaseLabels);
                 Assert::Equal<DWORD>(0, pVersion4->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion4->fInvalid);
+                Assert::Equal<BOOL>(FALSE, pVersion4->fHasMajor);
+                Assert::Equal<BOOL>(FALSE, pVersion4->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion4->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion4->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion5, pVersion5->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion5->chPrefix);
@@ -229,6 +265,10 @@ namespace DutilTests
 
                 Assert::Equal<DWORD>(4, pVersion5->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion5->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion5->fHasMajor);
+                Assert::Equal<BOOL>(FALSE, pVersion5->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion5->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion5->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion6, pVersion6->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion6->chPrefix);
@@ -245,6 +285,10 @@ namespace DutilTests
 
                 Assert::Equal<DWORD>(5, pVersion6->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion6->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion6->fHasMajor);
+                Assert::Equal<BOOL>(FALSE, pVersion6->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion6->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion6->fHasRevision);
 
                 TestVerutilCompareParsedVersions(pVersion1, pVersion2, 1);
                 TestVerutilCompareParsedVersions(pVersion3, pVersion4, 1);
@@ -297,6 +341,10 @@ namespace DutilTests
 
                 Assert::Equal<DWORD>(7, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion1->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
@@ -313,6 +361,10 @@ namespace DutilTests
 
                 Assert::Equal<DWORD>(3, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion3->chPrefix);
@@ -329,6 +381,10 @@ namespace DutilTests
 
                 Assert::Equal<DWORD>(3, pVersion3->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);
+                Assert::Equal<BOOL>(FALSE, pVersion3->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion3->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion3->fHasRevision);
 
                 TestVerutilCompareParsedVersions(pVersion1, pVersion2, 1);
                 TestVerutilCompareParsedVersions(pVersion1, pVersion3, -1);
@@ -387,6 +443,10 @@ namespace DutilTests
 
                 Assert::Equal<DWORD>(8, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion1->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion1->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
@@ -407,6 +467,10 @@ namespace DutilTests
 
                 Assert::Equal<DWORD>(9, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion3->chPrefix);
@@ -431,6 +495,10 @@ namespace DutilTests
 
                 Assert::Equal<DWORD>(9, pVersion3->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion3->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion3->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion4, pVersion4->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion4->chPrefix);
@@ -455,6 +523,10 @@ namespace DutilTests
 
                 Assert::Equal<DWORD>(13, pVersion4->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion4->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion4->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion4->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion4->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion4->fHasRevision);
 
                 TestVerutilCompareParsedVersions(pVersion1, pVersion2, 0);
                 TestVerutilCompareParsedVersions(pVersion3, pVersion4, 0);
@@ -499,6 +571,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
                 Assert::Equal<DWORD>(6, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion1->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
@@ -509,6 +585,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
                 Assert::Equal<DWORD>(6, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion3->chPrefix);
@@ -519,6 +599,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
                 Assert::Equal<DWORD>(6, pVersion3->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion3->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion3->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion3->fHasRevision);
 
                 TestVerutilCompareParsedVersions(pVersion1, pVersion2, 1);
                 TestVerutilCompareParsedVersions(pVersion1, pVersion3, 1);
@@ -573,6 +657,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
                 Assert::Equal<DWORD>(11, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasPatch);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion1, pVersion2->sczVersion);
                 Assert::Equal<WCHAR>(L'v', pVersion2->chPrefix);
@@ -583,6 +671,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
                 Assert::Equal<DWORD>(11, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasPatch);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion1, pVersion3->sczVersion);
                 Assert::Equal<WCHAR>(L'V', pVersion3->chPrefix);
@@ -593,6 +685,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
                 Assert::Equal<DWORD>(11, pVersion3->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion3->fHasPatch);
+                Assert::Equal<BOOL>(TRUE, pVersion3->fHasRevision);
 
                 NativeAssert::StringEqual(L"10.20.30.40-abc", pVersion4->sczVersion);
                 Assert::Equal<WCHAR>(L'v', pVersion4->chPrefix);
@@ -608,6 +704,10 @@ namespace DutilTests
 
                 Assert::Equal<DWORD>(15, pVersion4->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion4->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion4->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion4->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion4->fHasPatch);
+                Assert::Equal<BOOL>(TRUE, pVersion4->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion5, pVersion5->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion5->chPrefix);
@@ -618,6 +718,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion5->cReleaseLabels);
                 Assert::Equal<DWORD>(0, pVersion5->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion5->fInvalid);
+                Assert::Equal<BOOL>(FALSE, pVersion5->fHasMajor);
+                Assert::Equal<BOOL>(FALSE, pVersion5->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion5->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion5->fHasRevision);
 
                 TestVerutilCompareParsedVersions(pVersion1, pVersion2, 0);
                 TestVerutilCompareParsedVersions(pVersion1, pVersion3, 0);
@@ -659,6 +763,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
                 Assert::Equal<DWORD>(43, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasPatch);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
@@ -669,6 +777,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
                 Assert::Equal<DWORD>(0, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasMajor);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasRevision);
 
                 TestVerutilCompareParsedVersions(pVersion1, pVersion2, 1);
             }
@@ -705,6 +817,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
                 Assert::Equal<DWORD>(6, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion1->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
@@ -715,6 +831,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
                 Assert::Equal<DWORD>(6, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasRevision);
 
                 TestVerutilCompareParsedVersions(pVersion1, pVersion2, 0);
             }
@@ -749,6 +869,10 @@ namespace DutilTests
 
                 Assert::Equal<DWORD>(8, pSource->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pSource->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pSource->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pSource->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pSource->fHasPatch);
+                Assert::Equal<BOOL>(TRUE, pSource->fHasRevision);
 
                 hr = VerCopyVersion(pSource, &pCopy);
                 NativeAssert::Succeeded(hr, "VerCopyVersion failed");
@@ -756,6 +880,10 @@ namespace DutilTests
                 Assert::False(pSource == pCopy);
                 Assert::False(pSource->sczVersion == pCopy->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pCopy->chPrefix);
+                Assert::Equal<BOOL>(TRUE, pCopy->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pCopy->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pCopy->fHasPatch);
+                Assert::Equal<BOOL>(TRUE, pCopy->fHasRevision);
 
                 hr = VerCompareParsedVersions(pSource, pCopy, &nResult);
                 NativeAssert::Succeeded(hr, "VerCompareParsedVersions failed");
@@ -814,6 +942,10 @@ namespace DutilTests
 
                 Assert::Equal<DWORD>(18, pSource->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pSource->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pSource->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pSource->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pSource->fHasPatch);
+                Assert::Equal<BOOL>(TRUE, pSource->fHasRevision);
 
                 hr = VerCopyVersion(pSource, &pCopy);
                 NativeAssert::Succeeded(hr, "VerCopyVersion failed");
@@ -822,6 +954,10 @@ namespace DutilTests
                 Assert::False(pSource->sczVersion == pCopy->sczVersion);
                 Assert::False(pSource->rgReleaseLabels == pCopy->rgReleaseLabels);
                 Assert::Equal<WCHAR>(L'v', pCopy->chPrefix);
+                Assert::Equal<BOOL>(TRUE, pCopy->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pCopy->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pCopy->fHasPatch);
+                Assert::Equal<BOOL>(TRUE, pCopy->fHasRevision);
 
                 hr = VerCompareParsedVersions(pSource, pCopy, &nResult);
                 NativeAssert::Succeeded(hr, "VerCompareParsedVersions failed");
@@ -886,6 +1022,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
                 Assert::Equal<DWORD>(0, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion1->fInvalid);
+                Assert::Equal<BOOL>(FALSE, pVersion1->fHasMajor);
+                Assert::Equal<BOOL>(FALSE, pVersion1->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion1->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion1->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
@@ -896,6 +1036,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion2->cReleaseLabels);
                 Assert::Equal<DWORD>(2, pVersion2->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion2->fHasMajor);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion2->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion3->chPrefix);
@@ -906,6 +1050,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion3->cReleaseLabels);
                 Assert::Equal<DWORD>(4, pVersion3->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion3->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion3->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion3->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion3->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion3->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion4, pVersion4->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion4->chPrefix);
@@ -916,6 +1064,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion4->cReleaseLabels);
                 Assert::Equal<DWORD>(6, pVersion4->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion4->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion4->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion4->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion4->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion4->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion5, pVersion5->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion5->chPrefix);
@@ -926,6 +1078,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion5->cReleaseLabels);
                 Assert::Equal<DWORD>(8, pVersion5->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion5->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion5->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion5->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion5->fHasPatch);
+                Assert::Equal<BOOL>(TRUE, pVersion5->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion6, pVersion6->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion6->chPrefix);
@@ -936,6 +1092,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion6->cReleaseLabels);
                 Assert::Equal<DWORD>(2, pVersion6->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion6->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion6->fHasMajor);
+                Assert::Equal<BOOL>(FALSE, pVersion6->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion6->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion6->fHasRevision);
 
                 NativeAssert::StringEqual(wzVersion7, pVersion7->sczVersion);
                 Assert::Equal<WCHAR>(L'\0', pVersion7->chPrefix);
@@ -951,6 +1111,10 @@ namespace DutilTests
 
                 Assert::Equal<DWORD>(4, pVersion7->cchMetadataOffset);
                 Assert::Equal<BOOL>(TRUE, pVersion7->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion7->fHasMajor);
+                Assert::Equal<BOOL>(FALSE, pVersion7->fHasMinor);
+                Assert::Equal<BOOL>(FALSE, pVersion7->fHasPatch);
+                Assert::Equal<BOOL>(FALSE, pVersion7->fHasRevision);
             }
             finally
             {
@@ -984,6 +1148,10 @@ namespace DutilTests
                 Assert::Equal<DWORD>(0, pVersion1->cReleaseLabels);
                 Assert::Equal<DWORD>(7, pVersion1->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMajor);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasMinor);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasPatch);
+                Assert::Equal<BOOL>(TRUE, pVersion1->fHasRevision);
             }
             finally
             {
diff --git a/src/wix/WixToolset.Core.Burn/Bundles/CreateBundleExeCommand.cs b/src/wix/WixToolset.Core.Burn/Bundles/CreateBundleExeCommand.cs
index e63bf65c..672bb235 100644
--- a/src/wix/WixToolset.Core.Burn/Bundles/CreateBundleExeCommand.cs
+++ b/src/wix/WixToolset.Core.Burn/Bundles/CreateBundleExeCommand.cs
@@ -254,10 +254,10 @@ namespace WixToolset.Core.Burn.Bundles
                 return new Version(0, 0);
             }
 
-            var major = wixVersion.Major ?? 0;
-            var minor = wixVersion.Minor ?? 0;
-            var build = wixVersion.Patch ?? 0;
-            var revision = wixVersion.Revision ?? 0;
+            var major = wixVersion.Major;
+            var minor = wixVersion.Minor;
+            var build = wixVersion.Patch;
+            var revision = wixVersion.Revision;
 
             if (UInt16.MaxValue < major || UInt16.MaxValue < minor || UInt16.MaxValue < build || UInt16.MaxValue < revision)
             {
@@ -369,7 +369,7 @@ namespace WixToolset.Core.Burn.Bundles
             public BURN_SPLASH_SCREEN_TYPE Type;
 
             [MarshalAs(UnmanagedType.U2)]
-            public UInt16 ResourceId;
+            public ushort ResourceId;
 
             public byte[] ToBytes()
             {