summaryrefslogtreecommitdiff
path: root/src/libs/test/WixToolsetTest.Versioning/WixVerFixture.cs
diff options
context:
space:
mode:
Diffstat (limited to 'src/libs/test/WixToolsetTest.Versioning/WixVerFixture.cs')
-rw-r--r--src/libs/test/WixToolsetTest.Versioning/WixVerFixture.cs451
1 files changed, 451 insertions, 0 deletions
diff --git a/src/libs/test/WixToolsetTest.Versioning/WixVerFixture.cs b/src/libs/test/WixToolsetTest.Versioning/WixVerFixture.cs
new file mode 100644
index 00000000..9026cba6
--- /dev/null
+++ b/src/libs/test/WixToolsetTest.Versioning/WixVerFixture.cs
@@ -0,0 +1,451 @@
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.Versioning
4{
5 using System;
6 using System.Linq;
7 using WixToolset.Versioning;
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 [Fact]
409 public void CanCompareVersions()
410 {
411 var version1 = WixVersion.Parse("1");
412 var version10 = WixVersion.Parse("1.0");
413 var version100 = WixVersion.Parse("1.0.0");
414 var version2 = WixVersion.Parse("2.0.0");
415 var version201 = WixVersion.Parse("2.0.1");
416 var version2a = WixVersion.Parse("2-a");
417 var version2b = WixVersion.Parse("2-b");
418 var versionInvalid3a = WixVersion.Parse("3.-a");
419 var versionInvalid3b = WixVersion.Parse("3.-b");
420
421 Assert.Equal(version1, version1);
422 Assert.Equal(version1, version10);
423 Assert.True(version1 == version10);
424 Assert.True(version1 == version100);
425 Assert.True(version1 <= version10);
426 Assert.True(version1 >= version10);
427 Assert.False(version1 != version10);
428 Assert.False(version1 < version10);
429 Assert.False(version1 < version100);
430 Assert.False(version1 > version10);
431 Assert.False(version1 > version100);
432
433 Assert.NotEqual(version1, version2);
434 Assert.True(version1 < version2);
435 Assert.False(version1 > version2);
436
437 Assert.True(version2 > version2a);
438 Assert.True(version2 != version2a);
439 Assert.False(version2 < version2a);
440
441 Assert.True(version2 < version201);
442
443 Assert.True(version2a < version2b);
444 Assert.False(version2a > version2b);
445
446 Assert.True(versionInvalid3a < versionInvalid3b);
447
448 Assert.True(version1 < versionInvalid3a);
449 }
450 }
451}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-04-25 08:39:31 +0000