aboutsummaryrefslogtreecommitdiff
path: root/src/api
diff options
context:
space:
mode:
authorRob Mensching <rob@firegiant.com>2022-10-02 19:37:55 -0700
committerRob Mensching <rob@firegiant.com>2022-10-04 10:44:49 -0700
commit5c509f5611a45bdf9d252b88605537bd28f24a35 (patch)
treef2ac4c1509fe69f6489c56f257b59f4e346a51c7 /src/api
parente901e04cfb8f1b759903f41b5c8f2f91e3f877aa (diff)
downloadwix-5c509f5611a45bdf9d252b88605537bd28f24a35.tar.gz
wix-5c509f5611a45bdf9d252b88605537bd28f24a35.tar.bz2
wix-5c509f5611a45bdf9d252b88605537bd28f24a35.zip
Move WixVersion to new WixToolset.Versioning package in libs segment
WixVersion is already used by the Core toolset but could also be useful for bootstrapper applications parsing bundle versions. The WixToolset.Data assembly contains a significant amount of data that bloats its size that bootstrapper applications would never need. Extracting WixVersion to its own assembly makes it much more useable. Fixes 6943
Diffstat (limited to 'src/api')
-rw-r--r--src/api/wix/WixToolset.Data/WixVersion.cs335
-rw-r--r--src/api/wix/test/WixToolsetTest.Data/WixVerFixture.cs408
2 files changed, 0 insertions, 743 deletions
diff --git a/src/api/wix/WixToolset.Data/WixVersion.cs b/src/api/wix/WixToolset.Data/WixVersion.cs
deleted file mode 100644
index a0de7a10..00000000
--- a/src/api/wix/WixToolset.Data/WixVersion.cs
+++ /dev/null
@@ -1,335 +0,0 @@
1// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
2
3namespace WixToolset.Data
4{
5 using System;
6 using System.Collections.Generic;
7
8 /// <summary>
9 /// WiX Toolset's representation of a version designed to support
10 /// a different version types including 4-part versions with very
11 /// large numbers and semantic versions with 4-part versions with
12 /// or without leading "v" indicators.
13 /// </summary>
14 [CLSCompliant(false)]
15 public class WixVersion
16 {
17 /// <summary>
18 /// Gets the prefix of the version if present when parsed. Usually, 'v' or 'V'.
19 /// </summary>
20 public char? Prefix { get; set; }
21
22 /// <summary>
23 /// Gets or sets the major version.
24 /// </summary>
25 public uint Major { get; set; }
26
27 /// <summary>
28 /// Gets or sets the minor version.
29 /// </summary>
30 public uint Minor { get; set; }
31
32 /// <summary>
33 /// Gets or sets the patch version.
34 /// </summary>
35 public uint Patch { get; set; }
36
37 /// <summary>
38 /// Gets or sets the revision version.
39 /// </summary>
40 public uint Revision { get; set; }
41
42 /// <summary>
43 /// Gets or sets whether the version did not parse correctly.
44 /// </summary>
45 public bool Invalid { get; set; }
46
47 /// <summary>
48 /// Gets or sets whether the major version was defined.
49 /// </summary>
50 public bool HasMajor { get; set; }
51
52 /// <summary>
53 /// Gets or sets the whether the minor version was defined.
54 /// </summary>
55 public bool HasMinor { get; set; }
56
57 /// <summary>
58 /// Gets or sets the whether the patch version was defined.
59 /// </summary>
60 public bool HasPatch { get; set; }
61
62 /// <summary>
63 /// Gets or sets the whether the revision version was defined.
64 /// </summary>
65 public bool HasRevision { get; set; }
66
67 /// <summary>
68 /// Gets or sets the labels in the version.
69 /// </summary>
70 public WixVersionLabel[] Labels { get; set; }
71
72 /// <summary>
73 /// Gets or sets the metadata in the version.
74 /// </summary>
75 public string Metadata { get; set; }
76
77 /// <summary>
78 /// Parse a string value into a <c>WixVersion</c>. The returned version may be invalid.
79 /// </summary>
80 /// <param name="parse">String value to parse into a version.</param>
81 /// <returns>Parsed version.</returns>
82 public static WixVersion Parse(string parse)
83 {
84 var version = new WixVersion();
85
86 var labels = new List<WixVersionLabel>();
87 var start = 0;
88 var end = parse.Length;
89
90 if (end > 0 && (parse[0] == 'v' || parse[0] == 'V'))
91 {
92 version.Prefix = parse[0];
93
94 ++start;
95 }
96
97 var partBegin = start;
98 var partEnd = start;
99 var lastPart = false;
100 var trailingDot = false;
101 var invalid = false;
102 var currentPart = 0;
103 var parsedVersionNumber = false;
104 var expectedReleaseLabels = false;
105
106 // Parse version number
107 while (start < end)
108 {
109 trailingDot = false;
110
111 // Find end of part.
112 for (; ; )
113 {
114 if (partEnd >= end)
115 {
116 lastPart = true;
117 break;
118 }
119
120 var ch = parse[partEnd];
121
122 switch (ch)
123 {
124 case '0':
125 case '1':
126 case '2':
127 case '3':
128 case '4':
129 case '5':
130 case '6':
131 case '7':
132 case '8':
133 case '9':
134 ++partEnd;
135 continue;
136 case '.':
137 trailingDot = true;
138 break;
139 case '-':
140 case '+':
141 lastPart = true;
142 break;
143 default:
144 invalid = true;
145 break;
146 }
147
148 break;
149 }
150
151 var partLength = partEnd - partBegin;
152 if (invalid || partLength <= 0)
153 {
154 invalid = true;
155 break;
156 }
157
158 // Parse version part.
159 var s = parse.Substring(partBegin, partLength);
160 if (!UInt32.TryParse(s, out var part))
161 {
162 invalid = true;
163 break;
164 }
165
166 switch (currentPart)
167 {
168 case 0:
169 version.Major = part;
170 version.HasMajor = true;
171 break;
172 case 1:
173 version.Minor = part;
174 version.HasMinor = true;
175 break;
176 case 2:
177 version.Patch = part;
178 version.HasPatch = true;
179 break;
180 case 3:
181 version.Revision = part;
182 version.HasRevision = true;
183 break;
184 }
185
186 if (trailingDot)
187 {
188 ++partEnd;
189 }
190 partBegin = partEnd;
191 ++currentPart;
192
193 if (4 <= currentPart || lastPart)
194 {
195 parsedVersionNumber = true;
196 break;
197 }
198 }
199
200 invalid |= !parsedVersionNumber || trailingDot;
201
202 if (!invalid && partBegin < end && parse[partBegin] == '-')
203 {
204 partBegin = partEnd = partBegin + 1;
205 expectedReleaseLabels = true;
206 lastPart = false;
207 }
208
209 while (expectedReleaseLabels && partBegin < end)
210 {
211 trailingDot = false;
212
213 // Find end of part.
214 for (; ; )
215 {
216 if (partEnd >= end)
217 {
218 lastPart = true;
219 break;
220 }
221
222 var ch = parse[partEnd];
223 if (ch >= '0' && ch <= '9' ||
224 ch >= 'A' && ch <= 'Z' ||
225 ch >= 'a' && ch <= 'z' ||
226 ch == '-')
227 {
228 ++partEnd;
229 continue;
230 }
231 else if (ch == '+')
232 {
233 lastPart = true;
234 }
235 else if (ch == '.')
236 {
237 trailingDot = true;
238 }
239 else
240 {
241 invalid = true;
242 }
243
244 break;
245 }
246
247 var partLength = partEnd - partBegin;
248 if (invalid || partLength <= 0)
249 {
250 invalid = true;
251 break;
252 }
253
254 WixVersionLabel label;
255 var partString = parse.Substring(partBegin, partLength);
256 if (UInt32.TryParse(partString, out var numericPart))
257 {
258 label = new WixVersionLabel(partString, numericPart);
259 }
260 else
261 {
262 label = new WixVersionLabel(partString);
263 }
264
265 labels.Add(label);
266
267 if (trailingDot)
268 {
269 ++partEnd;
270 }
271 partBegin = partEnd;
272
273 if (lastPart)
274 {
275 break;
276 }
277 }
278
279 invalid |= expectedReleaseLabels && (labels.Count == 0 || trailingDot);
280
281 if (!invalid && partBegin < end)
282 {
283 if (parse[partBegin] == '+')
284 {
285 version.Metadata = parse.Substring(partBegin + 1);
286 }
287 else
288 {
289 invalid = true;
290 }
291 }
292
293 version.Labels = labels.Count == 0 ? null : labels.ToArray();
294
295 if (invalid)
296 {
297 // If the prefix was parsed but the rest of the version was
298 // invalid, store the full invalid version in the Metadata
299 // and clear the prefix.
300 if (version.Prefix.HasValue && partBegin == 1)
301 {
302 version.Prefix = null;
303 version.Metadata = parse;
304 }
305 else // store the remaining invalid content in Metadata.
306 {
307 version.Metadata = (partBegin < end) ? parse.Substring(partBegin) : String.Empty;
308 }
309
310 version.Invalid = true;
311 }
312
313 return version;
314 }
315
316 /// <summary>
317 /// Tries to parse a string value into a valid <c>WixVersion</c>.
318 /// </summary>
319 /// <param name="parse">String value to parse into a version.</param>
320 /// <param name="version">Parsed version.</param>
321 /// <returns>True if the version was successfully parsed, or false otherwise.</returns>
322 public static bool TryParse(string parse, out WixVersion version)
323 {
324 version = WixVersion.Parse(parse);
325
326 if (version.Invalid)
327 {
328 version = null;
329 return false;
330 }
331
332 return true;
333 }
334 }
335}
diff --git a/src/api/wix/test/WixToolsetTest.Data/WixVerFixture.cs b/src/api/wix/test/WixToolsetTest.Data/WixVerFixture.cs
deleted file mode 100644
index 56c72896..00000000
--- a/src/api/wix/test/WixToolsetTest.Data/WixVerFixture.cs
+++ /dev/null
@@ -1,408 +0,0 @@
1// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
2
3namespace WixToolsetTest.Data
4{
5 using System;
6 using System.Linq;
7 using WixToolset.Data;
8 using Xunit;
9
10 public class WixVerFixture
11 {
12 [Fact]
13 public void CannotParseEmptyStringAsVersion()
14 {
15 Assert.False(WixVersion.TryParse(String.Empty, out var version));
16 Assert.Null(version);
17 }
18
19 [Fact]
20 public void CanParseEmptyStringAsInvalidVersion()
21 {
22 var version = WixVersion.Parse(String.Empty);
23 Assert.Empty(version.Metadata);
24 Assert.True(version.Invalid);
25 }
26
27 [Fact]
28 public void CannotParseInvalidStringAsVersion()
29 {
30 Assert.False(WixVersion.TryParse("invalid", out var version));
31 Assert.Null(version);
32 }
33
34 [Fact]
35 public void CanParseInvalidStringAsInvalidVersion()
36 {
37 var version = WixVersion.Parse("invalid");
38 Assert.Equal("invalid", version.Metadata);
39 Assert.True(version.Invalid);
40 }
41
42 [Fact]
43 public void CanParseFourPartVersion()
44 {
45 Assert.True(WixVersion.TryParse("1.2.3.4", out var version));
46 Assert.Null(version.Prefix);
47 Assert.Equal((uint)1, version.Major);
48 Assert.Equal((uint)2, version.Minor);
49 Assert.Equal((uint)3, version.Patch);
50 Assert.Equal((uint)4, version.Revision);
51 Assert.True(version.HasMajor);
52 Assert.True(version.HasMinor);
53 Assert.True(version.HasPatch);
54 Assert.True(version.HasRevision);
55 Assert.Null(version.Labels);
56 Assert.Null(version.Metadata);
57 Assert.False(version.Invalid);
58 }
59
60 [Fact]
61 public void CanParseThreePartVersion()
62 {
63 Assert.True(WixVersion.TryParse("1.2.3", out var version));
64 Assert.Null(version.Prefix);
65 Assert.Equal((uint)1, version.Major);
66 Assert.Equal((uint)2, version.Minor);
67 Assert.Equal((uint)3, version.Patch);
68 Assert.Equal((uint)0, version.Revision);
69 Assert.True(version.HasMajor);
70 Assert.True(version.HasMinor);
71 Assert.True(version.HasPatch);
72 Assert.False(version.HasRevision);
73 Assert.Null(version.Labels);
74 Assert.Null(version.Metadata);
75 Assert.False(version.Invalid);
76 }
77
78 [Fact]
79 public void CanParseFourPartVersionWithTrailingZero()
80 {
81 Assert.True(WixVersion.TryParse("1.2.3.0", out var version));
82 Assert.Null(version.Prefix);
83 Assert.Equal((uint)1, version.Major);
84 Assert.Equal((uint)2, version.Minor);
85 Assert.Equal((uint)3, version.Patch);
86 Assert.Equal((uint)0, version.Revision);
87 Assert.True(version.HasMajor);
88 Assert.True(version.HasMinor);
89 Assert.True(version.HasPatch);
90 Assert.True(version.HasRevision);
91 Assert.Null(version.Labels);
92 Assert.Null(version.Metadata);
93 Assert.False(version.Invalid);
94 }
95
96 [Fact]
97 public void CanParseNumericReleaseLabels()
98 {
99 Assert.True(WixVersion.TryParse("1.2-19", out var version));
100 Assert.Null(version.Prefix);
101 Assert.Equal((uint)1, version.Major);
102 Assert.Equal((uint)2, version.Minor);
103 Assert.Equal((uint)0, version.Patch);
104 Assert.Equal((uint)0, version.Revision);
105 Assert.True(version.HasMajor);
106 Assert.True(version.HasMinor);
107 Assert.False(version.HasPatch);
108 Assert.False(version.HasRevision);
109 Assert.Equal(new[] { "19" }, version.Labels.Select(l => l.Label).ToArray());
110 Assert.Equal(new uint?[] { 19 }, version.Labels.Select(l => l.Numeric).ToArray());
111 Assert.Null(version.Metadata);
112 Assert.False(version.Invalid);
113 }
114
115 [Fact]
116 public void CanParseDottedNumericReleaseLabels()
117 {
118 Assert.True(WixVersion.TryParse("1.2-2.0", out var version));
119 Assert.Null(version.Prefix);
120 Assert.Equal((uint)1, version.Major);
121 Assert.Equal((uint)2, version.Minor);
122 Assert.Equal((uint)0, version.Patch);
123 Assert.Equal((uint)0, version.Revision);
124 Assert.True(version.HasMajor);
125 Assert.True(version.HasMinor);
126 Assert.False(version.HasPatch);
127 Assert.False(version.HasRevision);
128 Assert.Equal(new[] { "2", "0" }, version.Labels.Select(l => l.Label).ToArray());
129 Assert.Equal(new uint?[] { 2, 0 }, version.Labels.Select(l => l.Numeric).ToArray());
130 Assert.Null(version.Metadata);
131 Assert.False(version.Invalid);
132 }
133
134 [Fact]
135 public void CanParseHyphenAsVersionSeparator()
136 {
137 Assert.True(WixVersion.TryParse("0.0.1-a", out var version));
138 Assert.Null(version.Prefix);
139 Assert.Equal((uint)0, version.Major);
140 Assert.Equal((uint)0, version.Minor);
141 Assert.Equal((uint)1, version.Patch);
142 Assert.Equal((uint)0, version.Revision);
143 Assert.True(version.HasMajor);
144 Assert.True(version.HasMinor);
145 Assert.True(version.HasPatch);
146 Assert.False(version.HasRevision);
147 Assert.Equal(new[] { "a" }, version.Labels.Select(l => l.Label).ToArray());
148 Assert.Equal(new uint?[] { null }, version.Labels.Select(l => l.Numeric).ToArray());
149 Assert.Null(version.Metadata);
150 Assert.False(version.Invalid);
151 }
152
153 [Fact]
154 public void CanParseIgnoringLeadingZeros()
155 {
156 Assert.True(WixVersion.TryParse("0.01-a.000", out var version));
157 Assert.Null(version.Prefix);
158 Assert.Equal((uint)0, version.Major);
159 Assert.Equal((uint)1, version.Minor);
160 Assert.Equal((uint)0, version.Patch);
161 Assert.Equal((uint)0, version.Revision);
162 Assert.True(version.HasMajor);
163 Assert.True(version.HasMinor);
164 Assert.False(version.HasPatch);
165 Assert.False(version.HasRevision);
166 Assert.Equal(new[] { "a", "000" }, version.Labels.Select(l => l.Label).ToArray());
167 Assert.Equal(new uint?[] { null, 0 }, version.Labels.Select(l => l.Numeric).ToArray());
168 Assert.Null(version.Metadata);
169 Assert.False(version.Invalid);
170 }
171
172 [Fact]
173 public void CanParseMetadata()
174 {
175 Assert.True(WixVersion.TryParse("1.2.3+abcd", out var version));
176 Assert.Null(version.Prefix);
177 Assert.Equal((uint)1, version.Major);
178 Assert.Equal((uint)2, version.Minor);
179 Assert.Equal((uint)3, version.Patch);
180 Assert.Equal((uint)0, version.Revision);
181 Assert.True(version.HasMajor);
182 Assert.True(version.HasMinor);
183 Assert.True(version.HasPatch);
184 Assert.False(version.HasRevision);
185 Assert.Null(version.Labels);
186 Assert.Equal("abcd", version.Metadata);
187 Assert.False(version.Invalid);
188 }
189
190 [Fact]
191 public void CannotParseUnexpectedContentAsMetadata()
192 {
193 Assert.False(WixVersion.TryParse("1.2.3.abcd", out var version));
194 Assert.Null(version);
195 Assert.False(WixVersion.TryParse("1.2.3.-abcd", out version));
196 Assert.Null(version);
197 }
198
199 [Fact]
200 public void CanParseUnexpectedContentAsInvalidMetadata()
201 {
202 var version = WixVersion.Parse("1.2.3.abcd");
203 Assert.Equal("abcd", version.Metadata);
204 Assert.True(version.Invalid);
205
206 version = WixVersion.Parse("1.2.3.-abcd");
207 Assert.Equal("-abcd", version.Metadata);
208 Assert.True(version.Invalid);
209 }
210
211 [Fact]
212 public void CanParseLeadingPrefix()
213 {
214 Assert.True(WixVersion.TryParse("v10.20.30.40", out var version));
215 Assert.Equal('v', version.Prefix);
216 Assert.Equal((uint)10, version.Major);
217 Assert.Equal((uint)20, version.Minor);
218 Assert.Equal((uint)30, version.Patch);
219 Assert.Equal((uint)40, version.Revision);
220 Assert.True(version.HasMajor);
221 Assert.True(version.HasMinor);
222 Assert.True(version.HasPatch);
223 Assert.True(version.HasRevision);
224 Assert.Null(version.Labels);
225 Assert.Null(version.Metadata);
226 Assert.False(version.Invalid);
227
228 Assert.True(WixVersion.TryParse("V100.200.300.400", out var version2));
229 Assert.Equal('V', version2.Prefix);
230 Assert.Equal((uint)100, version2.Major);
231 Assert.Equal((uint)200, version2.Minor);
232 Assert.Equal((uint)300, version2.Patch);
233 Assert.Equal((uint)400, version2.Revision);
234 Assert.True(version.HasMajor);
235 Assert.True(version.HasMinor);
236 Assert.True(version.HasPatch);
237 Assert.True(version.HasRevision);
238 Assert.Null(version2.Labels);
239 Assert.Null(version2.Metadata);
240 Assert.False(version.Invalid);
241 }
242
243 [Fact]
244 public void CanParseVeryLargeNumbers()
245 {
246 Assert.True(WixVersion.TryParse("4294967295.4294967295.4294967295.4294967295", out var version));
247 Assert.Null(version.Prefix);
248 Assert.Equal(4294967295, version.Major);
249 Assert.Equal(4294967295, version.Minor);
250 Assert.Equal(4294967295, version.Patch);
251 Assert.Equal(4294967295, version.Revision);
252 Assert.True(version.HasMajor);
253 Assert.True(version.HasMinor);
254 Assert.True(version.HasPatch);
255 Assert.True(version.HasRevision);
256 Assert.Null(version.Labels);
257 Assert.Null(version.Metadata);
258 Assert.False(version.Invalid);
259 }
260
261 [Fact]
262 public void CannotParseTooLargeNumbers()
263 {
264 Assert.False(WixVersion.TryParse("4294967296.4294967296.4294967296.4294967296", out var version));
265 Assert.Null(version);
266 }
267
268 [Fact]
269 public void CanParseInvalidTooLargeNumbers()
270 {
271 var version = WixVersion.Parse("4294967296.4294967296.4294967296.4294967296");
272 Assert.Equal(0U, version.Major);
273 Assert.Equal("4294967296.4294967296.4294967296.4294967296", version.Metadata);
274 Assert.True(version.Invalid);
275 }
276
277 [Fact]
278 public void CanParseInvalidTooLargeNumbersWithPrefix()
279 {
280 var version = WixVersion.Parse("v4294967296.4294967296.4294967296.4294967296");
281 Assert.Equal("v4294967296.4294967296.4294967296.4294967296", version.Metadata);
282 Assert.Null(version.Prefix);
283 Assert.True(version.Invalid);
284 }
285
286 [Fact]
287 public void CanParseLabelsWithMetadata()
288 {
289 Assert.True(WixVersion.TryParse("1.2.3.4-a.b.c.d.5+abc123", out var version));
290 Assert.Null(version.Prefix);
291 Assert.Equal((uint)1, version.Major);
292 Assert.Equal((uint)2, version.Minor);
293 Assert.Equal((uint)3, version.Patch);
294 Assert.Equal((uint)4, version.Revision);
295 Assert.True(version.HasMajor);
296 Assert.True(version.HasMinor);
297 Assert.True(version.HasPatch);
298 Assert.True(version.HasRevision);
299 Assert.Equal(new[] { "a", "b", "c", "d", "5" }, version.Labels.Select(l => l.Label).ToArray());
300 Assert.Equal(new uint?[] { null, null, null, null, 5 }, version.Labels.Select(l => l.Numeric).ToArray());
301 Assert.Equal("abc123", version.Metadata);
302 Assert.False(version.Invalid);
303 }
304
305 [Fact]
306 public void CanParseVersionWithTrailingDotsAsInvalid()
307 {
308 var version = WixVersion.Parse(".");
309 Assert.Null(version.Prefix);
310 Assert.Equal(0U, version.Major);
311 Assert.Equal(0U, version.Minor);
312 Assert.Equal(0U, version.Patch);
313 Assert.Equal(0U, version.Revision);
314 Assert.Null(version.Labels);
315 Assert.False(version.HasMajor);
316 Assert.False(version.HasMinor);
317 Assert.False(version.HasPatch);
318 Assert.False(version.HasRevision);
319 Assert.Equal(".", version.Metadata);
320 Assert.True(version.Invalid);
321
322 version = WixVersion.Parse("1.");
323 Assert.Null(version.Prefix);
324 Assert.Equal(1U, version.Major);
325 Assert.Equal(0U, version.Minor);
326 Assert.Equal(0U, version.Patch);
327 Assert.Equal(0U, version.Revision);
328 Assert.Null(version.Labels);
329 Assert.True(version.HasMajor);
330 Assert.False(version.HasMinor);
331 Assert.False(version.HasPatch);
332 Assert.False(version.HasRevision);
333 Assert.Equal(String.Empty, version.Metadata);
334 Assert.True(version.Invalid);
335
336 version = WixVersion.Parse("2.1.");
337 Assert.Null(version.Prefix);
338 Assert.Equal(2U, version.Major);
339 Assert.Equal(1U, version.Minor);
340 Assert.Equal(0U, version.Patch);
341 Assert.Equal(0U, version.Revision);
342 Assert.Null(version.Labels);
343 Assert.True(version.HasMajor);
344 Assert.True(version.HasMinor);
345 Assert.False(version.HasPatch);
346 Assert.False(version.HasRevision);
347 Assert.Equal(String.Empty, version.Metadata);
348 Assert.True(version.Invalid);
349
350 version = WixVersion.Parse("3.2.1.");
351 Assert.Null(version.Prefix);
352 Assert.Equal(3U, version.Major);
353 Assert.Equal(2U, version.Minor);
354 Assert.Equal(1U, version.Patch);
355 Assert.Equal(0U, version.Revision);
356 Assert.Null(version.Labels);
357 Assert.True(version.HasMajor);
358 Assert.True(version.HasMinor);
359 Assert.True(version.HasPatch);
360 Assert.False(version.HasRevision);
361 Assert.Equal(String.Empty, version.Metadata);
362 Assert.True(version.Invalid);
363
364 version = WixVersion.Parse("4.3.2.1.");
365 Assert.Null(version.Prefix);
366 Assert.Equal(4U, version.Major);
367 Assert.Equal(3U, version.Minor);
368 Assert.Equal(2U, version.Patch);
369 Assert.Equal(1U, version.Revision);
370 Assert.Null(version.Labels);
371 Assert.True(version.HasMajor);
372 Assert.True(version.HasMinor);
373 Assert.True(version.HasPatch);
374 Assert.True(version.HasRevision);
375 Assert.Equal(String.Empty, version.Metadata);
376 Assert.True(version.Invalid);
377
378 version = WixVersion.Parse("5-.");
379 Assert.Null(version.Prefix);
380 Assert.Equal(5U, version.Major);
381 Assert.Equal(0U, version.Minor);
382 Assert.Equal(0U, version.Patch);
383 Assert.Equal(0U, version.Revision);
384 Assert.Null(version.Labels);
385 Assert.True(version.HasMajor);
386 Assert.False(version.HasMinor);
387 Assert.False(version.HasPatch);
388 Assert.False(version.HasRevision);
389 Assert.Equal(".", version.Metadata);
390 Assert.True(version.Invalid);
391
392 version = WixVersion.Parse("6-a.");
393 Assert.Null(version.Prefix);
394 Assert.Equal(6U, version.Major);
395 Assert.Equal(0U, version.Minor);
396 Assert.Equal(0U, version.Patch);
397 Assert.Equal(0U, version.Revision);
398 Assert.Equal(new[] { "a" }, version.Labels.Select(l => l.Label).ToArray());
399 Assert.Equal(new uint?[] { null }, version.Labels.Select(l => l.Numeric).ToArray());
400 Assert.True(version.HasMajor);
401 Assert.False(version.HasMinor);
402 Assert.False(version.HasPatch);
403 Assert.False(version.HasRevision);
404 Assert.Equal(String.Empty, version.Metadata);
405 Assert.True(version.Invalid);
406 }
407 }
408}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-22 07:21:28 +0000