From 46fb0597d4d6192833ddcf836f4bcf6295ef0aaf Mon Sep 17 00:00:00 2001 From: Sean Hall Date: Mon, 16 May 2022 16:07:43 -0500 Subject: Keep track of when parts of verutil/WixVersions are missing. Return null when WixVersion.TryParse returns false. 6776 --- src/api/burn/WixToolset.Mba.Core/VerUtil.cs | 4 + src/api/burn/WixToolset.Mba.Core/VerUtilVersion.cs | 24 +++ .../test/WixToolsetTest.Mba.Core/VerUtilFixture.cs | 8 + src/api/wix/WixToolset.Data/WixVersion.cs | 33 +++- .../wix/test/WixToolsetTest.Data/WixVerFixture.cs | 80 ++++++++-- src/libs/dutil/WixToolset.DUtil/inc/verutil.h | 4 + src/libs/dutil/WixToolset.DUtil/verutil.cpp | 13 ++ src/libs/dutil/test/DUtilUnitTest/VerUtilTests.cpp | 168 +++++++++++++++++++++ .../Bundles/CreateBundleExeCommand.cs | 10 +- 9 files changed, 322 insertions(+), 22 deletions(-) (limited to 'src') 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 /// public bool IsInvalid { get; private set; } + /// + /// Whether the Major part was specified. + /// + public bool HasMajor { get; private set; } + + /// + /// Whether the Minor part was specified. + /// + public bool HasMinor { get; private set; } + + /// + /// Whether the Patch part was specified. + /// + public bool HasPatch { get; private set; } + + /// + /// Whether the Revision part was specified. + /// + public bool HasRevision { get; private set; } + /// 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 /// /// Gets or sets the major version. /// - public uint? Major { get; set; } + public uint Major { get; set; } /// /// Gets or sets the minor version. /// - public uint? Minor { get; set; } + public uint Minor { get; set; } /// /// Gets or sets the patch version. /// - public uint? Patch { get; set; } + public uint Patch { get; set; } /// /// Gets or sets the revision version. /// - public uint? Revision { get; set; } + public uint Revision { get; set; } + + /// + /// Gets or sets whether the major version was defined. + /// + public bool HasMajor { get; set; } + + /// + /// Gets or sets the whether the minor version was defined. + /// + public bool HasMinor { get; set; } + + /// + /// Gets or sets the whether the patch version was defined. + /// + public bool HasPatch { get; set; } + + /// + /// Gets or sets the whether the revision version was defined. + /// + public bool HasRevision { get; set; } /// /// 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(0, pVersion1->cReleaseLabels); Assert::Equal(7, pVersion1->cchMetadataOffset); Assert::Equal(FALSE, pVersion1->fInvalid); + Assert::Equal(TRUE, pVersion1->fHasMajor); + Assert::Equal(TRUE, pVersion1->fHasMinor); + Assert::Equal(TRUE, pVersion1->fHasPatch); + Assert::Equal(TRUE, pVersion1->fHasRevision); NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion); Assert::Equal(L'\0', pVersion2->chPrefix); @@ -52,6 +56,10 @@ namespace DutilTests Assert::Equal(0, pVersion2->cReleaseLabels); Assert::Equal(5, pVersion2->cchMetadataOffset); Assert::Equal(FALSE, pVersion2->fInvalid); + Assert::Equal(TRUE, pVersion2->fHasMajor); + Assert::Equal(TRUE, pVersion2->fHasMinor); + Assert::Equal(TRUE, pVersion2->fHasPatch); + Assert::Equal(FALSE, pVersion2->fHasRevision); NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion); Assert::Equal(L'\0', pVersion3->chPrefix); @@ -62,6 +70,10 @@ namespace DutilTests Assert::Equal(0, pVersion3->cReleaseLabels); Assert::Equal(7, pVersion3->cchMetadataOffset); Assert::Equal(FALSE, pVersion3->fInvalid); + Assert::Equal(TRUE, pVersion3->fHasMajor); + Assert::Equal(TRUE, pVersion3->fHasMinor); + Assert::Equal(TRUE, pVersion3->fHasPatch); + Assert::Equal(TRUE, pVersion3->fHasRevision); TestVerutilCompareParsedVersions(pVersion1, pVersion2, 1); TestVerutilCompareParsedVersions(pVersion3, pVersion2, 0); @@ -111,6 +123,10 @@ namespace DutilTests Assert::Equal(7, pVersion1->cchMetadataOffset); Assert::Equal(FALSE, pVersion1->fInvalid); + Assert::Equal(TRUE, pVersion1->fHasMajor); + Assert::Equal(TRUE, pVersion1->fHasMinor); + Assert::Equal(FALSE, pVersion1->fHasPatch); + Assert::Equal(FALSE, pVersion1->fHasRevision); NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion); Assert::Equal(L'\0', pVersion2->chPrefix); @@ -127,6 +143,10 @@ namespace DutilTests Assert::Equal(6, pVersion2->cchMetadataOffset); Assert::Equal(FALSE, pVersion2->fInvalid); + Assert::Equal(TRUE, pVersion2->fHasMajor); + Assert::Equal(TRUE, pVersion2->fHasMinor); + Assert::Equal(FALSE, pVersion2->fHasPatch); + Assert::Equal(FALSE, pVersion2->fHasRevision); TestVerutilCompareParsedVersions(pVersion1, pVersion2, -1); } @@ -183,6 +203,10 @@ namespace DutilTests Assert::Equal(0, pVersion1->cReleaseLabels); Assert::Equal(3, pVersion1->cchMetadataOffset); Assert::Equal(TRUE, pVersion1->fInvalid); + Assert::Equal(TRUE, pVersion1->fHasMajor); + Assert::Equal(FALSE, pVersion1->fHasMinor); + Assert::Equal(FALSE, pVersion1->fHasPatch); + Assert::Equal(FALSE, pVersion1->fHasRevision); NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion); Assert::Equal(L'\0', pVersion2->chPrefix); @@ -193,6 +217,10 @@ namespace DutilTests Assert::Equal(0, pVersion2->cReleaseLabels); Assert::Equal(3, pVersion2->cchMetadataOffset); Assert::Equal(TRUE, pVersion2->fInvalid); + Assert::Equal(TRUE, pVersion2->fHasMajor); + Assert::Equal(FALSE, pVersion2->fHasMinor); + Assert::Equal(FALSE, pVersion2->fHasPatch); + Assert::Equal(FALSE, pVersion2->fHasRevision); NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion); Assert::Equal(L'\0', pVersion3->chPrefix); @@ -203,6 +231,10 @@ namespace DutilTests Assert::Equal(0, pVersion3->cReleaseLabels); Assert::Equal(1, pVersion3->cchMetadataOffset); Assert::Equal(FALSE, pVersion3->fInvalid); + Assert::Equal(TRUE, pVersion3->fHasMajor); + Assert::Equal(FALSE, pVersion3->fHasMinor); + Assert::Equal(FALSE, pVersion3->fHasPatch); + Assert::Equal(FALSE, pVersion3->fHasRevision); NativeAssert::StringEqual(wzVersion4, pVersion4->sczVersion); Assert::Equal(L'\0', pVersion4->chPrefix); @@ -213,6 +245,10 @@ namespace DutilTests Assert::Equal(0, pVersion4->cReleaseLabels); Assert::Equal(0, pVersion4->cchMetadataOffset); Assert::Equal(TRUE, pVersion4->fInvalid); + Assert::Equal(FALSE, pVersion4->fHasMajor); + Assert::Equal(FALSE, pVersion4->fHasMinor); + Assert::Equal(FALSE, pVersion4->fHasPatch); + Assert::Equal(FALSE, pVersion4->fHasRevision); NativeAssert::StringEqual(wzVersion5, pVersion5->sczVersion); Assert::Equal(L'\0', pVersion5->chPrefix); @@ -229,6 +265,10 @@ namespace DutilTests Assert::Equal(4, pVersion5->cchMetadataOffset); Assert::Equal(FALSE, pVersion5->fInvalid); + Assert::Equal(TRUE, pVersion5->fHasMajor); + Assert::Equal(FALSE, pVersion5->fHasMinor); + Assert::Equal(FALSE, pVersion5->fHasPatch); + Assert::Equal(FALSE, pVersion5->fHasRevision); NativeAssert::StringEqual(wzVersion6, pVersion6->sczVersion); Assert::Equal(L'\0', pVersion6->chPrefix); @@ -245,6 +285,10 @@ namespace DutilTests Assert::Equal(5, pVersion6->cchMetadataOffset); Assert::Equal(TRUE, pVersion6->fInvalid); + Assert::Equal(TRUE, pVersion6->fHasMajor); + Assert::Equal(FALSE, pVersion6->fHasMinor); + Assert::Equal(FALSE, pVersion6->fHasPatch); + Assert::Equal(FALSE, pVersion6->fHasRevision); TestVerutilCompareParsedVersions(pVersion1, pVersion2, 1); TestVerutilCompareParsedVersions(pVersion3, pVersion4, 1); @@ -297,6 +341,10 @@ namespace DutilTests Assert::Equal(7, pVersion1->cchMetadataOffset); Assert::Equal(FALSE, pVersion1->fInvalid); + Assert::Equal(TRUE, pVersion1->fHasMajor); + Assert::Equal(TRUE, pVersion1->fHasMinor); + Assert::Equal(TRUE, pVersion1->fHasPatch); + Assert::Equal(FALSE, pVersion1->fHasRevision); NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion); Assert::Equal(L'\0', pVersion2->chPrefix); @@ -313,6 +361,10 @@ namespace DutilTests Assert::Equal(3, pVersion2->cchMetadataOffset); Assert::Equal(FALSE, pVersion2->fInvalid); + Assert::Equal(TRUE, pVersion2->fHasMajor); + Assert::Equal(FALSE, pVersion2->fHasMinor); + Assert::Equal(FALSE, pVersion2->fHasPatch); + Assert::Equal(FALSE, pVersion2->fHasRevision); NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion); Assert::Equal(L'\0', pVersion3->chPrefix); @@ -329,6 +381,10 @@ namespace DutilTests Assert::Equal(3, pVersion3->cchMetadataOffset); Assert::Equal(FALSE, pVersion3->fInvalid); + Assert::Equal(TRUE, pVersion3->fHasMajor); + Assert::Equal(FALSE, pVersion3->fHasMinor); + Assert::Equal(FALSE, pVersion3->fHasPatch); + Assert::Equal(FALSE, pVersion3->fHasRevision); TestVerutilCompareParsedVersions(pVersion1, pVersion2, 1); TestVerutilCompareParsedVersions(pVersion1, pVersion3, -1); @@ -387,6 +443,10 @@ namespace DutilTests Assert::Equal(8, pVersion1->cchMetadataOffset); Assert::Equal(FALSE, pVersion1->fInvalid); + Assert::Equal(TRUE, pVersion1->fHasMajor); + Assert::Equal(TRUE, pVersion1->fHasMinor); + Assert::Equal(FALSE, pVersion1->fHasPatch); + Assert::Equal(FALSE, pVersion1->fHasRevision); NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion); Assert::Equal(L'\0', pVersion2->chPrefix); @@ -407,6 +467,10 @@ namespace DutilTests Assert::Equal(9, pVersion2->cchMetadataOffset); Assert::Equal(FALSE, pVersion2->fInvalid); + Assert::Equal(TRUE, pVersion2->fHasMajor); + Assert::Equal(TRUE, pVersion2->fHasMinor); + Assert::Equal(TRUE, pVersion2->fHasPatch); + Assert::Equal(FALSE, pVersion2->fHasRevision); NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion); Assert::Equal(L'\0', pVersion3->chPrefix); @@ -431,6 +495,10 @@ namespace DutilTests Assert::Equal(9, pVersion3->cchMetadataOffset); Assert::Equal(FALSE, pVersion3->fInvalid); + Assert::Equal(TRUE, pVersion3->fHasMajor); + Assert::Equal(TRUE, pVersion3->fHasMinor); + Assert::Equal(FALSE, pVersion3->fHasPatch); + Assert::Equal(FALSE, pVersion3->fHasRevision); NativeAssert::StringEqual(wzVersion4, pVersion4->sczVersion); Assert::Equal(L'\0', pVersion4->chPrefix); @@ -455,6 +523,10 @@ namespace DutilTests Assert::Equal(13, pVersion4->cchMetadataOffset); Assert::Equal(FALSE, pVersion4->fInvalid); + Assert::Equal(TRUE, pVersion4->fHasMajor); + Assert::Equal(TRUE, pVersion4->fHasMinor); + Assert::Equal(TRUE, pVersion4->fHasPatch); + Assert::Equal(FALSE, pVersion4->fHasRevision); TestVerutilCompareParsedVersions(pVersion1, pVersion2, 0); TestVerutilCompareParsedVersions(pVersion3, pVersion4, 0); @@ -499,6 +571,10 @@ namespace DutilTests Assert::Equal(0, pVersion1->cReleaseLabels); Assert::Equal(6, pVersion1->cchMetadataOffset); Assert::Equal(FALSE, pVersion1->fInvalid); + Assert::Equal(TRUE, pVersion1->fHasMajor); + Assert::Equal(TRUE, pVersion1->fHasMinor); + Assert::Equal(TRUE, pVersion1->fHasPatch); + Assert::Equal(FALSE, pVersion1->fHasRevision); NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion); Assert::Equal(L'\0', pVersion2->chPrefix); @@ -509,6 +585,10 @@ namespace DutilTests Assert::Equal(0, pVersion2->cReleaseLabels); Assert::Equal(6, pVersion2->cchMetadataOffset); Assert::Equal(TRUE, pVersion2->fInvalid); + Assert::Equal(TRUE, pVersion2->fHasMajor); + Assert::Equal(TRUE, pVersion2->fHasMinor); + Assert::Equal(TRUE, pVersion2->fHasPatch); + Assert::Equal(FALSE, pVersion2->fHasRevision); NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion); Assert::Equal(L'\0', pVersion3->chPrefix); @@ -519,6 +599,10 @@ namespace DutilTests Assert::Equal(0, pVersion3->cReleaseLabels); Assert::Equal(6, pVersion3->cchMetadataOffset); Assert::Equal(TRUE, pVersion3->fInvalid); + Assert::Equal(TRUE, pVersion3->fHasMajor); + Assert::Equal(TRUE, pVersion3->fHasMinor); + Assert::Equal(TRUE, pVersion3->fHasPatch); + Assert::Equal(FALSE, pVersion3->fHasRevision); TestVerutilCompareParsedVersions(pVersion1, pVersion2, 1); TestVerutilCompareParsedVersions(pVersion1, pVersion3, 1); @@ -573,6 +657,10 @@ namespace DutilTests Assert::Equal(0, pVersion1->cReleaseLabels); Assert::Equal(11, pVersion1->cchMetadataOffset); Assert::Equal(FALSE, pVersion1->fInvalid); + Assert::Equal(TRUE, pVersion1->fHasMajor); + Assert::Equal(TRUE, pVersion1->fHasMinor); + Assert::Equal(TRUE, pVersion1->fHasPatch); + Assert::Equal(TRUE, pVersion1->fHasRevision); NativeAssert::StringEqual(wzVersion1, pVersion2->sczVersion); Assert::Equal(L'v', pVersion2->chPrefix); @@ -583,6 +671,10 @@ namespace DutilTests Assert::Equal(0, pVersion2->cReleaseLabels); Assert::Equal(11, pVersion2->cchMetadataOffset); Assert::Equal(FALSE, pVersion2->fInvalid); + Assert::Equal(TRUE, pVersion2->fHasMajor); + Assert::Equal(TRUE, pVersion2->fHasMinor); + Assert::Equal(TRUE, pVersion2->fHasPatch); + Assert::Equal(TRUE, pVersion2->fHasRevision); NativeAssert::StringEqual(wzVersion1, pVersion3->sczVersion); Assert::Equal(L'V', pVersion3->chPrefix); @@ -593,6 +685,10 @@ namespace DutilTests Assert::Equal(0, pVersion3->cReleaseLabels); Assert::Equal(11, pVersion3->cchMetadataOffset); Assert::Equal(FALSE, pVersion3->fInvalid); + Assert::Equal(TRUE, pVersion3->fHasMajor); + Assert::Equal(TRUE, pVersion3->fHasMinor); + Assert::Equal(TRUE, pVersion3->fHasPatch); + Assert::Equal(TRUE, pVersion3->fHasRevision); NativeAssert::StringEqual(L"10.20.30.40-abc", pVersion4->sczVersion); Assert::Equal(L'v', pVersion4->chPrefix); @@ -608,6 +704,10 @@ namespace DutilTests Assert::Equal(15, pVersion4->cchMetadataOffset); Assert::Equal(FALSE, pVersion4->fInvalid); + Assert::Equal(TRUE, pVersion4->fHasMajor); + Assert::Equal(TRUE, pVersion4->fHasMinor); + Assert::Equal(TRUE, pVersion4->fHasPatch); + Assert::Equal(TRUE, pVersion4->fHasRevision); NativeAssert::StringEqual(wzVersion5, pVersion5->sczVersion); Assert::Equal(L'\0', pVersion5->chPrefix); @@ -618,6 +718,10 @@ namespace DutilTests Assert::Equal(0, pVersion5->cReleaseLabels); Assert::Equal(0, pVersion5->cchMetadataOffset); Assert::Equal(TRUE, pVersion5->fInvalid); + Assert::Equal(FALSE, pVersion5->fHasMajor); + Assert::Equal(FALSE, pVersion5->fHasMinor); + Assert::Equal(FALSE, pVersion5->fHasPatch); + Assert::Equal(FALSE, pVersion5->fHasRevision); TestVerutilCompareParsedVersions(pVersion1, pVersion2, 0); TestVerutilCompareParsedVersions(pVersion1, pVersion3, 0); @@ -659,6 +763,10 @@ namespace DutilTests Assert::Equal(0, pVersion1->cReleaseLabels); Assert::Equal(43, pVersion1->cchMetadataOffset); Assert::Equal(FALSE, pVersion1->fInvalid); + Assert::Equal(TRUE, pVersion1->fHasMajor); + Assert::Equal(TRUE, pVersion1->fHasMinor); + Assert::Equal(TRUE, pVersion1->fHasPatch); + Assert::Equal(TRUE, pVersion1->fHasRevision); NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion); Assert::Equal(L'\0', pVersion2->chPrefix); @@ -669,6 +777,10 @@ namespace DutilTests Assert::Equal(0, pVersion2->cReleaseLabels); Assert::Equal(0, pVersion2->cchMetadataOffset); Assert::Equal(TRUE, pVersion2->fInvalid); + Assert::Equal(FALSE, pVersion2->fHasMajor); + Assert::Equal(FALSE, pVersion2->fHasMinor); + Assert::Equal(FALSE, pVersion2->fHasPatch); + Assert::Equal(FALSE, pVersion2->fHasRevision); TestVerutilCompareParsedVersions(pVersion1, pVersion2, 1); } @@ -705,6 +817,10 @@ namespace DutilTests Assert::Equal(0, pVersion1->cReleaseLabels); Assert::Equal(6, pVersion1->cchMetadataOffset); Assert::Equal(FALSE, pVersion1->fInvalid); + Assert::Equal(TRUE, pVersion1->fHasMajor); + Assert::Equal(TRUE, pVersion1->fHasMinor); + Assert::Equal(TRUE, pVersion1->fHasPatch); + Assert::Equal(FALSE, pVersion1->fHasRevision); NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion); Assert::Equal(L'\0', pVersion2->chPrefix); @@ -715,6 +831,10 @@ namespace DutilTests Assert::Equal(0, pVersion2->cReleaseLabels); Assert::Equal(6, pVersion2->cchMetadataOffset); Assert::Equal(FALSE, pVersion2->fInvalid); + Assert::Equal(TRUE, pVersion2->fHasMajor); + Assert::Equal(TRUE, pVersion2->fHasMinor); + Assert::Equal(TRUE, pVersion2->fHasPatch); + Assert::Equal(FALSE, pVersion2->fHasRevision); TestVerutilCompareParsedVersions(pVersion1, pVersion2, 0); } @@ -749,6 +869,10 @@ namespace DutilTests Assert::Equal(8, pSource->cchMetadataOffset); Assert::Equal(FALSE, pSource->fInvalid); + Assert::Equal(TRUE, pSource->fHasMajor); + Assert::Equal(TRUE, pSource->fHasMinor); + Assert::Equal(TRUE, pSource->fHasPatch); + Assert::Equal(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(L'\0', pCopy->chPrefix); + Assert::Equal(TRUE, pCopy->fHasMajor); + Assert::Equal(TRUE, pCopy->fHasMinor); + Assert::Equal(TRUE, pCopy->fHasPatch); + Assert::Equal(TRUE, pCopy->fHasRevision); hr = VerCompareParsedVersions(pSource, pCopy, &nResult); NativeAssert::Succeeded(hr, "VerCompareParsedVersions failed"); @@ -814,6 +942,10 @@ namespace DutilTests Assert::Equal(18, pSource->cchMetadataOffset); Assert::Equal(TRUE, pSource->fInvalid); + Assert::Equal(TRUE, pSource->fHasMajor); + Assert::Equal(TRUE, pSource->fHasMinor); + Assert::Equal(TRUE, pSource->fHasPatch); + Assert::Equal(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(L'v', pCopy->chPrefix); + Assert::Equal(TRUE, pCopy->fHasMajor); + Assert::Equal(TRUE, pCopy->fHasMinor); + Assert::Equal(TRUE, pCopy->fHasPatch); + Assert::Equal(TRUE, pCopy->fHasRevision); hr = VerCompareParsedVersions(pSource, pCopy, &nResult); NativeAssert::Succeeded(hr, "VerCompareParsedVersions failed"); @@ -886,6 +1022,10 @@ namespace DutilTests Assert::Equal(0, pVersion1->cReleaseLabels); Assert::Equal(0, pVersion1->cchMetadataOffset); Assert::Equal(TRUE, pVersion1->fInvalid); + Assert::Equal(FALSE, pVersion1->fHasMajor); + Assert::Equal(FALSE, pVersion1->fHasMinor); + Assert::Equal(FALSE, pVersion1->fHasPatch); + Assert::Equal(FALSE, pVersion1->fHasRevision); NativeAssert::StringEqual(wzVersion2, pVersion2->sczVersion); Assert::Equal(L'\0', pVersion2->chPrefix); @@ -896,6 +1036,10 @@ namespace DutilTests Assert::Equal(0, pVersion2->cReleaseLabels); Assert::Equal(2, pVersion2->cchMetadataOffset); Assert::Equal(TRUE, pVersion2->fInvalid); + Assert::Equal(TRUE, pVersion2->fHasMajor); + Assert::Equal(FALSE, pVersion2->fHasMinor); + Assert::Equal(FALSE, pVersion2->fHasPatch); + Assert::Equal(FALSE, pVersion2->fHasRevision); NativeAssert::StringEqual(wzVersion3, pVersion3->sczVersion); Assert::Equal(L'\0', pVersion3->chPrefix); @@ -906,6 +1050,10 @@ namespace DutilTests Assert::Equal(0, pVersion3->cReleaseLabels); Assert::Equal(4, pVersion3->cchMetadataOffset); Assert::Equal(TRUE, pVersion3->fInvalid); + Assert::Equal(TRUE, pVersion3->fHasMajor); + Assert::Equal(TRUE, pVersion3->fHasMinor); + Assert::Equal(FALSE, pVersion3->fHasPatch); + Assert::Equal(FALSE, pVersion3->fHasRevision); NativeAssert::StringEqual(wzVersion4, pVersion4->sczVersion); Assert::Equal(L'\0', pVersion4->chPrefix); @@ -916,6 +1064,10 @@ namespace DutilTests Assert::Equal(0, pVersion4->cReleaseLabels); Assert::Equal(6, pVersion4->cchMetadataOffset); Assert::Equal(TRUE, pVersion4->fInvalid); + Assert::Equal(TRUE, pVersion4->fHasMajor); + Assert::Equal(TRUE, pVersion4->fHasMinor); + Assert::Equal(TRUE, pVersion4->fHasPatch); + Assert::Equal(FALSE, pVersion4->fHasRevision); NativeAssert::StringEqual(wzVersion5, pVersion5->sczVersion); Assert::Equal(L'\0', pVersion5->chPrefix); @@ -926,6 +1078,10 @@ namespace DutilTests Assert::Equal(0, pVersion5->cReleaseLabels); Assert::Equal(8, pVersion5->cchMetadataOffset); Assert::Equal(TRUE, pVersion5->fInvalid); + Assert::Equal(TRUE, pVersion5->fHasMajor); + Assert::Equal(TRUE, pVersion5->fHasMinor); + Assert::Equal(TRUE, pVersion5->fHasPatch); + Assert::Equal(TRUE, pVersion5->fHasRevision); NativeAssert::StringEqual(wzVersion6, pVersion6->sczVersion); Assert::Equal(L'\0', pVersion6->chPrefix); @@ -936,6 +1092,10 @@ namespace DutilTests Assert::Equal(0, pVersion6->cReleaseLabels); Assert::Equal(2, pVersion6->cchMetadataOffset); Assert::Equal(TRUE, pVersion6->fInvalid); + Assert::Equal(TRUE, pVersion6->fHasMajor); + Assert::Equal(FALSE, pVersion6->fHasMinor); + Assert::Equal(FALSE, pVersion6->fHasPatch); + Assert::Equal(FALSE, pVersion6->fHasRevision); NativeAssert::StringEqual(wzVersion7, pVersion7->sczVersion); Assert::Equal(L'\0', pVersion7->chPrefix); @@ -951,6 +1111,10 @@ namespace DutilTests Assert::Equal(4, pVersion7->cchMetadataOffset); Assert::Equal(TRUE, pVersion7->fInvalid); + Assert::Equal(TRUE, pVersion7->fHasMajor); + Assert::Equal(FALSE, pVersion7->fHasMinor); + Assert::Equal(FALSE, pVersion7->fHasPatch); + Assert::Equal(FALSE, pVersion7->fHasRevision); } finally { @@ -984,6 +1148,10 @@ namespace DutilTests Assert::Equal(0, pVersion1->cReleaseLabels); Assert::Equal(7, pVersion1->cchMetadataOffset); Assert::Equal(FALSE, pVersion1->fInvalid); + Assert::Equal(TRUE, pVersion1->fHasMajor); + Assert::Equal(TRUE, pVersion1->fHasMinor); + Assert::Equal(TRUE, pVersion1->fHasPatch); + Assert::Equal(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() { -- cgit v1.2.3-55-g6feb