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

Return null when WixVersion.TryParse returns false.

6776

3 files changed, 185 insertions, 0 deletions

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
             {