Store the prefix character in VERUTIL_VERSION.

Fix edge case where version string is all v's.

7 files changed, 118 insertions, 14 deletions

diff --git a/src/api/burn/WixToolset.Mba.Core/VerUtil.cs b/src/api/burn/WixToolset.Mba.Core/VerUtil.cs
index a342f85c..611f9710 100644
--- a/src/api/burn/WixToolset.Mba.Core/VerUtil.cs
+++ b/src/api/burn/WixToolset.Mba.Core/VerUtil.cs
@@ -59,6 +59,7 @@ namespace WixToolset.Mba.Core
         internal struct VersionStruct
         {
             public IntPtr sczVersion;
+            public char chPrefix;
             public uint dwMajor;
             public uint dwMinor;
             public uint dwPatch;
diff --git a/src/api/burn/WixToolset.Mba.Core/VerUtilVersion.cs b/src/api/burn/WixToolset.Mba.Core/VerUtilVersion.cs
index 7408c26f..731dedaf 100644
--- a/src/api/burn/WixToolset.Mba.Core/VerUtilVersion.cs
+++ b/src/api/burn/WixToolset.Mba.Core/VerUtilVersion.cs
@@ -17,6 +17,7 @@ namespace WixToolset.Mba.Core
             var pVersion = handle.DangerousGetHandle();
             var version = (VerUtil.VersionStruct)Marshal.PtrToStructure(pVersion, typeof(VerUtil.VersionStruct));
             this.Version = Marshal.PtrToStringUni(version.sczVersion);
+            this.Prefix = version.chPrefix;
             this.Major = version.dwMajor;
             this.Minor = version.dwMinor;
             this.Patch = version.dwPatch;
@@ -39,6 +40,11 @@ namespace WixToolset.Mba.Core
         public string Version { get; private set; }
 
         /// <summary>
+        /// Prefix character that was stripped from <c>Version</c>, or the null character if there was no prefix.
+        /// </summary>
+        public char Prefix { get; private set; }
+
+        /// <summary>
         /// For version A.B.C.D, Major is A. It is 0 if not specified.
         /// </summary>
         public uint Major { get; private set; }
diff --git a/src/api/burn/test/WixToolsetTest.Mba.Core/VerUtilFixture.cs b/src/api/burn/test/WixToolsetTest.Mba.Core/VerUtilFixture.cs
index 44142e3d..ceb1b12a 100644
--- a/src/api/burn/test/WixToolsetTest.Mba.Core/VerUtilFixture.cs
+++ b/src/api/burn/test/WixToolsetTest.Mba.Core/VerUtilFixture.cs
@@ -49,6 +49,7 @@ namespace WixToolsetTest.Mba.Core
 
             using var parsedVersion = VerUtil.VersionFromQword(qwVersion);
             Assert.Equal("100.200.300.400", parsedVersion.Version);
+            Assert.Equal('\0', parsedVersion.Prefix);
             Assert.Equal(100u, parsedVersion.Major);
             Assert.Equal(200u, parsedVersion.Minor);
             Assert.Equal(300u, parsedVersion.Patch);
@@ -65,6 +66,7 @@ namespace WixToolsetTest.Mba.Core
 
             using var parsedVersion = VerUtil.ParseVersion(version, strict: false);
             Assert.Equal(version, parsedVersion.Version);
+            Assert.Equal('\0', parsedVersion.Prefix);
             Assert.Equal(1u, parsedVersion.Major);
             Assert.Equal(2u, parsedVersion.Minor);
             Assert.Equal(3u, parsedVersion.Patch);
diff --git a/src/burn/test/BurnUnitTest/RegistrationTest.cpp b/src/burn/test/BurnUnitTest/RegistrationTest.cpp
index 9aadc2cc..883b9cc8 100644
--- a/src/burn/test/BurnUnitTest/RegistrationTest.cpp
+++ b/src/burn/test/BurnUnitTest/RegistrationTest.cpp
@@ -559,6 +559,7 @@ namespace Bootstrapper
                     L"    <Variable Id='MyBurnVariable2' Type='string' Value='foo' Hidden='no' Persisted='yes' />"
                     L"    <Variable Id='MyBurnVariable3' Type='version' Value='v1.1-alpha' Hidden='no' Persisted='yes' />"
                     L"    <Variable Id='MyBurnVariable4' Type='string' Value='foo' Hidden='no' Persisted='no' />"
+                    L"    <Variable Id='MyBurnVariable5' Type='version' Hidden='no' Persisted='yes' />"
                     L"    <CommandLine Variables='upperCase' />"
                     L"</Bundle>";
 
@@ -597,6 +598,7 @@ namespace Bootstrapper
                 VariableSetNumericHelper(&variables, L"MyBurnVariable1", 42);
                 VariableSetStringHelper(&variables, L"MyBurnVariable2", L"bar", FALSE);
                 VariableSetVersionHelper(&variables, L"MyBurnVariable3", L"v1.0-beta");
+                VariableSetVersionHelper(&variables, L"MyBurnVariable5", L"vvv");
 
                 hr = VariableSerialize(&variables, TRUE, &pbBuffer, &cbBuffer);
                 TestThrowOnFailure(hr, "Failed to serialize variables.");
@@ -616,6 +618,7 @@ namespace Bootstrapper
                 this->ValidateVariableKey(L"MyBurnVariable1", gcnew String(L"42"));
                 this->ValidateVariableKey(L"MyBurnVariable2", gcnew String(L"bar"));
                 this->ValidateVariableKey(L"MyBurnVariable3", gcnew String(L"1.0-beta"));
+                this->ValidateVariableKey(L"MyBurnVariable5", gcnew String(L"vvv"));
                 this->ValidateVariableKeyEmpty(L"WixBundleForcedRestartPackage");
 
                 hr = StrAlloc(&sczRelatedBundleId, MAX_GUID_CHARS + 1);
diff --git a/src/libs/dutil/WixToolset.DUtil/inc/verutil.h b/src/libs/dutil/WixToolset.DUtil/inc/verutil.h
index 5247bb61..4fdaa522 100644
--- a/src/libs/dutil/WixToolset.DUtil/inc/verutil.h
+++ b/src/libs/dutil/WixToolset.DUtil/inc/verutil.h
@@ -19,6 +19,7 @@ typedef struct _VERUTIL_VERSION_RELEASE_LABEL
 typedef struct _VERUTIL_VERSION
 {
     LPWSTR sczVersion;
+    WCHAR chPrefix;
     DWORD dwMajor;
     DWORD dwMinor;
     DWORD dwPatch;
diff --git a/src/libs/dutil/WixToolset.DUtil/verutil.cpp b/src/libs/dutil/WixToolset.DUtil/verutil.cpp
index 8881d7bc..30b979b1 100644
--- a/src/libs/dutil/WixToolset.DUtil/verutil.cpp
+++ b/src/libs/dutil/WixToolset.DUtil/verutil.cpp
@@ -194,6 +194,7 @@ DAPI_(HRESULT) VerCopyVersion(
     hr = StrAllocString(&pCopy->sczVersion, pSource->sczVersion, 0);
     VerExitOnFailure(hr, "Failed to copy Verutil version string '%ls'.", pSource->sczVersion);
 
+    pCopy->chPrefix = pSource->chPrefix;
     pCopy->dwMajor = pSource->dwMajor;
     pCopy->dwMinor = pSource->dwMinor;
     pCopy->dwPatch = pSource->dwPatch;
@@ -251,6 +252,7 @@ DAPI_(HRESULT) VerParseVersion(
 {
     HRESULT hr = S_OK;
     VERUTIL_VERSION* pVersion = NULL;
+    LPCWSTR wzString = NULL;
     LPCWSTR wzEnd = NULL;
     LPCWSTR wzPartBegin = NULL;
     LPCWSTR wzPartEnd = NULL;
@@ -277,22 +279,22 @@ DAPI_(HRESULT) VerParseVersion(
         VerExitOnRootFailure(hr = E_INVALIDARG, "Version string is too long: %Iu", cchVersion);
     }
 
-    if (L'v' == *wzVersion || L'V' == *wzVersion)
-    {
-        ++wzVersion;
-        --cchVersion;
-    }
-
     pVersion = reinterpret_cast<VERUTIL_VERSION*>(MemAlloc(sizeof(VERUTIL_VERSION), TRUE));
     VerExitOnNull(pVersion, hr, E_OUTOFMEMORY, "Failed to allocate memory for Verutil version '%ls'.", wzVersion);
 
-    hr = StrAllocString(&pVersion->sczVersion, wzVersion, cchVersion);
-    VerExitOnFailure(hr, "Failed to copy Verutil version string '%ls'.", wzVersion);
+    wzString = wzVersion;
+
+    if (L'v' == *wzString || L'V' == *wzString)
+    {
+        pVersion->chPrefix = *wzString;
+        ++wzString;
+        --cchVersion;
+    }
 
-    wzVersion = wzPartBegin = wzPartEnd = pVersion->sczVersion;
+    wzPartBegin = wzPartEnd = wzString;
 
     // Save end pointer.
-    wzEnd = wzVersion + cchVersion;
+    wzEnd = wzString + cchVersion;
 
     // Parse version number
     while (wzPartBegin < wzEnd)
@@ -473,7 +475,7 @@ DAPI_(HRESULT) VerParseVersion(
             pReleaseLabel->dwValue = uLabel;
         }
 
-        pReleaseLabel->cchLabelOffset = wzPartBegin - pVersion->sczVersion;
+        pReleaseLabel->cchLabelOffset = wzPartBegin - wzString;
         pReleaseLabel->cchLabel = cchLabel;
 
         if (fTrailingDot)
@@ -507,9 +509,20 @@ DAPI_(HRESULT) VerParseVersion(
         ExitFunction1(hr = E_INVALIDARG);
     }
 
-    pVersion->cchMetadataOffset = min(wzPartBegin, wzEnd) - pVersion->sczVersion;
+    pVersion->cchMetadataOffset = min(wzPartBegin, wzEnd) - wzString;
     pVersion->fInvalid = fInvalid;
 
+    // If the whole string was invalid, then don't clip off the prefix.
+    if (!pVersion->cchMetadataOffset && pVersion->chPrefix)
+    {
+        pVersion->chPrefix = '\0';
+        wzString = wzVersion;
+        ++cchVersion;
+    }
+
+    hr = StrAllocString(&pVersion->sczVersion, wzString, cchVersion);
+    VerExitOnFailure(hr, "Failed to copy Verutil version string '%ls'.", wzVersion);
+
     *ppVersion = pVersion;
     pVersion = NULL;
     hr = S_OK;
diff --git a/src/libs/dutil/test/DUtilUnitTest/VerUtilTests.cpp b/src/libs/dutil/test/DUtilUnitTest/VerUtilTests.cpp
index 8f24ad1a..c20b9887 100644
--- a/src/libs/dutil/test/DUtilUnitTest/VerUtilTests.cpp
+++ b/src/libs/dutil/test/DUtilUnitTest/VerUtilTests.cpp
@@ -34,6 +34,7 @@ namespace DutilTests
                 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion3);
 
                 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
                 Assert::Equal<DWORD>(1, pVersion1->dwMajor);
                 Assert::Equal<DWORD>(2, pVersion1->dwMinor);
                 Assert::Equal<DWORD>(3, pVersion1->dwPatch);
@@ -43,6 +44,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
                 Assert::Equal<DWORD>(1, pVersion2->dwMajor);
                 Assert::Equal<DWORD>(2, pVersion2->dwMinor);
                 Assert::Equal<DWORD>(3, pVersion2->dwPatch);
@@ -52,6 +54,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion3->chPrefix);
                 Assert::Equal<DWORD>(1, pVersion3->dwMajor);
                 Assert::Equal<DWORD>(2, pVersion3->dwMinor);
                 Assert::Equal<DWORD>(3, pVersion3->dwPatch);
@@ -89,6 +92,7 @@ namespace DutilTests
                 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion2);
 
                 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
                 Assert::Equal<DWORD>(1, pVersion1->dwMajor);
                 Assert::Equal<DWORD>(0, pVersion1->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion1->dwPatch);
@@ -109,6 +113,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
                 Assert::Equal<DWORD>(1, pVersion2->dwMajor);
                 Assert::Equal<DWORD>(0, pVersion2->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion2->dwPatch);
@@ -170,6 +175,7 @@ namespace DutilTests
                 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion6);
 
                 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
                 Assert::Equal<DWORD>(10, pVersion1->dwMajor);
                 Assert::Equal<DWORD>(0, pVersion1->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion1->dwPatch);
@@ -179,6 +185,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(TRUE, pVersion1->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
                 Assert::Equal<DWORD>(10, pVersion2->dwMajor);
                 Assert::Equal<DWORD>(0, pVersion2->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion2->dwPatch);
@@ -188,6 +195,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion3->chPrefix);
                 Assert::Equal<DWORD>(0, pVersion3->dwMajor);
                 Assert::Equal<DWORD>(0, pVersion3->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion3->dwPatch);
@@ -197,6 +205,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion4, pVersion4->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion4->chPrefix);
                 Assert::Equal<DWORD>(0, pVersion4->dwMajor);
                 Assert::Equal<DWORD>(0, pVersion4->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion4->dwPatch);
@@ -206,6 +215,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(TRUE, pVersion4->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion5, pVersion5->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion5->chPrefix);
                 Assert::Equal<DWORD>(10, pVersion5->dwMajor);
                 Assert::Equal<DWORD>(0, pVersion5->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion5->dwPatch);
@@ -221,6 +231,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(FALSE, pVersion5->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion6, pVersion6->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion6->chPrefix);
                 Assert::Equal<DWORD>(10, pVersion6->dwMajor);
                 Assert::Equal<DWORD>(0, pVersion6->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion6->dwPatch);
@@ -273,6 +284,7 @@ namespace DutilTests
                 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion3);
 
                 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
                 Assert::Equal<DWORD>(0, pVersion1->dwMajor);
                 Assert::Equal<DWORD>(0, pVersion1->dwMinor);
                 Assert::Equal<DWORD>(1, pVersion1->dwPatch);
@@ -287,6 +299,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
                 Assert::Equal<DWORD>(0, pVersion2->dwMajor);
                 Assert::Equal<DWORD>(0, pVersion2->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion2->dwPatch);
@@ -302,6 +315,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion3->chPrefix);
                 Assert::Equal<DWORD>(1, pVersion3->dwMajor);
                 Assert::Equal<DWORD>(0, pVersion3->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion3->dwPatch);
@@ -355,6 +369,7 @@ namespace DutilTests
                 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion4);
 
                 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
                 Assert::Equal<DWORD>(0, pVersion1->dwMajor);
                 Assert::Equal<DWORD>(1, pVersion1->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion1->dwPatch);
@@ -374,6 +389,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
                 Assert::Equal<DWORD>(0, pVersion2->dwMajor);
                 Assert::Equal<DWORD>(1, pVersion2->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion2->dwPatch);
@@ -393,6 +409,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion3->chPrefix);
                 Assert::Equal<DWORD>(0, pVersion3->dwMajor);
                 Assert::Equal<DWORD>(1, pVersion3->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion3->dwPatch);
@@ -416,6 +433,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion4, pVersion4->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion4->chPrefix);
                 Assert::Equal<DWORD>(0, pVersion4->dwMajor);
                 Assert::Equal<DWORD>(1, pVersion4->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion4->dwPatch);
@@ -473,6 +491,7 @@ namespace DutilTests
                 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion3);
 
                 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
                 Assert::Equal<DWORD>(1, pVersion1->dwMajor);
                 Assert::Equal<DWORD>(2, pVersion1->dwMinor);
                 Assert::Equal<DWORD>(3, pVersion1->dwPatch);
@@ -482,6 +501,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
                 Assert::Equal<DWORD>(1, pVersion2->dwMajor);
                 Assert::Equal<DWORD>(2, pVersion2->dwMinor);
                 Assert::Equal<DWORD>(3, pVersion2->dwPatch);
@@ -491,6 +511,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion3->chPrefix);
                 Assert::Equal<DWORD>(1, pVersion3->dwMajor);
                 Assert::Equal<DWORD>(2, pVersion3->dwMinor);
                 Assert::Equal<DWORD>(3, pVersion3->dwPatch);
@@ -518,9 +539,13 @@ namespace DutilTests
             VERUTIL_VERSION* pVersion1 = NULL;
             VERUTIL_VERSION* pVersion2 = NULL;
             VERUTIL_VERSION* pVersion3 = NULL;
+            VERUTIL_VERSION* pVersion4 = NULL;
+            VERUTIL_VERSION* pVersion5 = NULL;
             LPCWSTR wzVersion1 = L"10.20.30.40";
             LPCWSTR wzVersion2 = L"v10.20.30.40";
             LPCWSTR wzVersion3 = L"V10.20.30.40";
+            LPCWSTR wzVersion4 = L"v10.20.30.40-abc";
+            LPCWSTR wzVersion5 = L"vvv";
 
             try
             {
@@ -533,7 +558,14 @@ namespace DutilTests
                 hr = VerParseVersion(wzVersion3, 0, FALSE, &pVersion3);
                 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion3);
 
+                hr = VerParseVersion(wzVersion4, 0, FALSE, &pVersion4);
+                NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion4);
+
+                hr = VerParseVersion(wzVersion5, 0, FALSE, &pVersion5);
+                NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion5);
+
                 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
                 Assert::Equal<DWORD>(10, pVersion1->dwMajor);
                 Assert::Equal<DWORD>(20, pVersion1->dwMinor);
                 Assert::Equal<DWORD>(30, pVersion1->dwPatch);
@@ -543,6 +575,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion1, pVersion2->sczVersion);
+                Assert::Equal<WCHAR>(L'v', pVersion2->chPrefix);
                 Assert::Equal<DWORD>(10, pVersion2->dwMajor);
                 Assert::Equal<DWORD>(20, pVersion2->dwMinor);
                 Assert::Equal<DWORD>(30, pVersion2->dwPatch);
@@ -552,6 +585,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(FALSE, pVersion2->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion1, pVersion3->sczVersion);
+                Assert::Equal<WCHAR>(L'V', pVersion3->chPrefix);
                 Assert::Equal<DWORD>(10, pVersion3->dwMajor);
                 Assert::Equal<DWORD>(20, pVersion3->dwMinor);
                 Assert::Equal<DWORD>(30, pVersion3->dwPatch);
@@ -560,14 +594,42 @@ namespace DutilTests
                 Assert::Equal<DWORD>(11, pVersion3->cchMetadataOffset);
                 Assert::Equal<BOOL>(FALSE, pVersion3->fInvalid);
 
+                NativeAssert::StringEqual(L"10.20.30.40-abc", pVersion4->sczVersion);
+                Assert::Equal<WCHAR>(L'v', pVersion4->chPrefix);
+                Assert::Equal<DWORD>(10, pVersion4->dwMajor);
+                Assert::Equal<DWORD>(20, pVersion4->dwMinor);
+                Assert::Equal<DWORD>(30, pVersion4->dwPatch);
+                Assert::Equal<DWORD>(40, pVersion4->dwRevision);
+                Assert::Equal<DWORD>(1, pVersion4->cReleaseLabels);
+
+                Assert::Equal<BOOL>(FALSE, pVersion4->rgReleaseLabels[0].fNumeric);
+                Assert::Equal<DWORD>(3, pVersion4->rgReleaseLabels[0].cchLabel);
+                Assert::Equal<DWORD>(12, pVersion4->rgReleaseLabels[0].cchLabelOffset);
+
+                Assert::Equal<DWORD>(15, pVersion4->cchMetadataOffset);
+                Assert::Equal<BOOL>(FALSE, pVersion4->fInvalid);
+
+                NativeAssert::StringEqual(wzVersion5, pVersion5->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion5->chPrefix);
+                Assert::Equal<DWORD>(0, pVersion5->dwMajor);
+                Assert::Equal<DWORD>(0, pVersion5->dwMinor);
+                Assert::Equal<DWORD>(0, pVersion5->dwPatch);
+                Assert::Equal<DWORD>(0, pVersion5->dwRevision);
+                Assert::Equal<DWORD>(0, pVersion5->cReleaseLabels);
+                Assert::Equal<DWORD>(0, pVersion5->cchMetadataOffset);
+                Assert::Equal<BOOL>(TRUE, pVersion5->fInvalid);
+
                 TestVerutilCompareParsedVersions(pVersion1, pVersion2, 0);
                 TestVerutilCompareParsedVersions(pVersion1, pVersion3, 0);
+                TestVerutilCompareParsedVersions(pVersion1, pVersion4, 1);
             }
             finally
             {
                 ReleaseVerutilVersion(pVersion1);
                 ReleaseVerutilVersion(pVersion2);
                 ReleaseVerutilVersion(pVersion3);
+                ReleaseVerutilVersion(pVersion4);
+                ReleaseVerutilVersion(pVersion5);
             }
         }
 
@@ -589,6 +651,7 @@ namespace DutilTests
                 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion2);
 
                 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
                 Assert::Equal<DWORD>(4294967295, pVersion1->dwMajor);
                 Assert::Equal<DWORD>(4294967295, pVersion1->dwMinor);
                 Assert::Equal<DWORD>(4294967295, pVersion1->dwPatch);
@@ -598,6 +661,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
                 Assert::Equal<DWORD>(0, pVersion2->dwMajor);
                 Assert::Equal<DWORD>(0, pVersion2->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion2->dwPatch);
@@ -633,6 +697,7 @@ namespace DutilTests
                 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion2);
 
                 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
                 Assert::Equal<DWORD>(1, pVersion1->dwMajor);
                 Assert::Equal<DWORD>(2, pVersion1->dwMinor);
                 Assert::Equal<DWORD>(3, pVersion1->dwPatch);
@@ -642,6 +707,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(FALSE, pVersion1->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
                 Assert::Equal<DWORD>(1, pVersion2->dwMajor);
                 Assert::Equal<DWORD>(2, pVersion2->dwMinor);
                 Assert::Equal<DWORD>(3, pVersion2->dwPatch);
@@ -674,6 +740,7 @@ namespace DutilTests
                 NativeAssert::Succeeded(hr, "VerParseVersion failed");
 
                 NativeAssert::StringEqual(wzVersion, pSource->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pSource->chPrefix);
                 Assert::Equal<DWORD>(1, pSource->dwMajor);
                 Assert::Equal<DWORD>(2, pSource->dwMinor);
                 Assert::Equal<DWORD>(3, pSource->dwPatch);
@@ -688,6 +755,7 @@ namespace DutilTests
 
                 Assert::False(pSource == pCopy);
                 Assert::False(pSource->sczVersion == pCopy->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pCopy->chPrefix);
 
                 hr = VerCompareParsedVersions(pSource, pCopy, &nResult);
                 NativeAssert::Succeeded(hr, "VerCompareParsedVersions failed");
@@ -705,7 +773,7 @@ namespace DutilTests
         void VerCopyVersionCopiesPrereleaseVersion()
         {
             HRESULT hr = S_OK;
-            LPCWSTR wzVersion = L"1.2.3.4-a.b.c.d.5.+abc123";
+            LPCWSTR wzVersion = L"v1.2.3.4-a.b.c.d.5.+abc123";
             VERUTIL_VERSION* pSource = NULL;
             VERUTIL_VERSION* pCopy = NULL;
             int nResult = 0;
@@ -715,7 +783,8 @@ namespace DutilTests
                 hr = VerParseVersion(wzVersion, 0, FALSE, &pSource);
                 NativeAssert::Succeeded(hr, "VerParseVersion failed");
 
-                NativeAssert::StringEqual(wzVersion, pSource->sczVersion);
+                NativeAssert::StringEqual(L"1.2.3.4-a.b.c.d.5.+abc123", pSource->sczVersion);
+                Assert::Equal<WCHAR>(L'v', pSource->chPrefix);
                 Assert::Equal<DWORD>(1, pSource->dwMajor);
                 Assert::Equal<DWORD>(2, pSource->dwMinor);
                 Assert::Equal<DWORD>(3, pSource->dwPatch);
@@ -752,6 +821,7 @@ namespace DutilTests
                 Assert::False(pSource == pCopy);
                 Assert::False(pSource->sczVersion == pCopy->sczVersion);
                 Assert::False(pSource->rgReleaseLabels == pCopy->rgReleaseLabels);
+                Assert::Equal<WCHAR>(L'v', pCopy->chPrefix);
 
                 hr = VerCompareParsedVersions(pSource, pCopy, &nResult);
                 NativeAssert::Succeeded(hr, "VerCompareParsedVersions failed");
@@ -808,6 +878,7 @@ namespace DutilTests
                 NativeAssert::Succeeded(hr, "Failed to parse version '{0}'", wzVersion7);
 
                 NativeAssert::StringEqual(wzVersion1, pVersion1->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
                 Assert::Equal<DWORD>(0, pVersion1->dwMajor);
                 Assert::Equal<DWORD>(0, pVersion1->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion1->dwPatch);
@@ -817,6 +888,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(TRUE, pVersion1->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion2->chPrefix);
                 Assert::Equal<DWORD>(1, pVersion2->dwMajor);
                 Assert::Equal<DWORD>(0, pVersion2->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion2->dwPatch);
@@ -826,6 +898,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(TRUE, pVersion2->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion3->chPrefix);
                 Assert::Equal<DWORD>(2, pVersion3->dwMajor);
                 Assert::Equal<DWORD>(1, pVersion3->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion3->dwPatch);
@@ -835,6 +908,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(TRUE, pVersion3->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion4, pVersion4->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion4->chPrefix);
                 Assert::Equal<DWORD>(3, pVersion4->dwMajor);
                 Assert::Equal<DWORD>(2, pVersion4->dwMinor);
                 Assert::Equal<DWORD>(1, pVersion4->dwPatch);
@@ -844,6 +918,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(TRUE, pVersion4->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion5, pVersion5->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion5->chPrefix);
                 Assert::Equal<DWORD>(4, pVersion5->dwMajor);
                 Assert::Equal<DWORD>(3, pVersion5->dwMinor);
                 Assert::Equal<DWORD>(2, pVersion5->dwPatch);
@@ -853,6 +928,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(TRUE, pVersion5->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion6, pVersion6->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion6->chPrefix);
                 Assert::Equal<DWORD>(5, pVersion6->dwMajor);
                 Assert::Equal<DWORD>(0, pVersion6->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion6->dwPatch);
@@ -862,6 +938,7 @@ namespace DutilTests
                 Assert::Equal<BOOL>(TRUE, pVersion6->fInvalid);
 
                 NativeAssert::StringEqual(wzVersion7, pVersion7->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion7->chPrefix);
                 Assert::Equal<DWORD>(6, pVersion7->dwMajor);
                 Assert::Equal<DWORD>(0, pVersion7->dwMinor);
                 Assert::Equal<DWORD>(0, pVersion7->dwPatch);
@@ -899,6 +976,7 @@ namespace DutilTests
                 NativeAssert::Succeeded(hr, "VerVersionFromQword failed");
 
                 NativeAssert::StringEqual(L"1.2.3.4", pVersion1->sczVersion);
+                Assert::Equal<WCHAR>(L'\0', pVersion1->chPrefix);
                 Assert::Equal<DWORD>(1, pVersion1->dwMajor);
                 Assert::Equal<DWORD>(2, pVersion1->dwMinor);
                 Assert::Equal<DWORD>(3, pVersion1->dwPatch);