aboutsummaryrefslogtreecommitdiff
path: root/src/api
diff options
context:
space:
mode:
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 2026-01-24 21:49:38 +0000