summaryrefslogtreecommitdiff
path: root/src/libs/test/WixToolsetTest.Versioning/VerUtilTestsFixture.cs
diff options
context:
space:
mode:
Diffstat (limited to 'src/libs/test/WixToolsetTest.Versioning/VerUtilTestsFixture.cs')
-rw-r--r--src/libs/test/WixToolsetTest.Versioning/VerUtilTestsFixture.cs683
1 files changed, 683 insertions, 0 deletions
diff --git a/src/libs/test/WixToolsetTest.Versioning/VerUtilTestsFixture.cs b/src/libs/test/WixToolsetTest.Versioning/VerUtilTestsFixture.cs
new file mode 100644
index 00000000..3dff28c6
--- /dev/null
+++ b/src/libs/test/WixToolsetTest.Versioning/VerUtilTestsFixture.cs
@@ -0,0 +1,683 @@
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 WixToolset.Versioning;
7 using Xunit;
8
9 public class VerUtilTestsFixture
10 {
11 [Fact]
12 public void VerCompareVersionsTreatsMissingRevisionAsZero()
13 {
14 var version1 = WixVersion.Parse("1.2.3.4");
15 var version2 = WixVersion.Parse("1.2.3");
16 var version3 = WixVersion.Parse("1.2.3.0");
17
18 Assert.Null(version1.Prefix);
19 Assert.Equal(1U, version1.Major);
20 Assert.Equal(2U, version1.Minor);
21 Assert.Equal(3U, version1.Patch);
22 Assert.Equal(4U, version1.Revision);
23 Assert.Null(version1.Labels);
24 Assert.Null(version1.Metadata);
25 Assert.False(version1.Invalid);
26 Assert.True(version1.HasMajor);
27 Assert.True(version1.HasMinor);
28 Assert.True(version1.HasPatch);
29 Assert.True(version1.HasRevision);
30
31 Assert.Null(version2.Prefix);
32 Assert.Equal(1U, version2.Major);
33 Assert.Equal(2U, version2.Minor);
34 Assert.Equal(3U, version2.Patch);
35 Assert.Equal(0U, version2.Revision);
36 Assert.Null(version2.Labels);
37 Assert.Null(version2.Metadata);
38 Assert.False(version2.Invalid);
39 Assert.True(version2.HasMajor);
40 Assert.True(version2.HasMinor);
41 Assert.True(version2.HasPatch);
42 Assert.False(version2.HasRevision);
43
44 Assert.Null(version3.Prefix);
45 Assert.Equal(1U, version3.Major);
46 Assert.Equal(2U, version3.Minor);
47 Assert.Equal(3U, version3.Patch);
48 Assert.Equal(0U, version3.Revision);
49 Assert.Null(version3.Labels);
50 Assert.Null(version3.Metadata);
51 Assert.False(version3.Invalid);
52 Assert.True(version3.HasMajor);
53 Assert.True(version3.HasMinor);
54 Assert.True(version3.HasPatch);
55 Assert.True(version3.HasRevision);
56
57 Assert.Equal(1, version1.CompareTo(version2));
58 Assert.Equal(0, version3.CompareTo(version2));
59 }
60
61 [Fact]
62 public void VerCompareVersionsTreatsNumericReleaseLabelsAsNumbers()
63 {
64 var version1 = WixVersion.Parse("1.0-2.0");
65 var version2 = WixVersion.Parse("1.0-19");
66
67 Assert.Null(version1.Prefix);
68 Assert.Equal(1U, version1.Major);
69 Assert.Equal(0U, version1.Minor);
70 Assert.Equal(0U, version1.Patch);
71 Assert.Equal(0U, version1.Revision);
72 Assert.Equal(2, version1.Labels.Length);
73
74 Assert.Equal(2U, version1.Labels[0].Numeric);
75 Assert.Equal("2", version1.Labels[0].Label);
76
77 Assert.Equal(0U, version1.Labels[1].Numeric);
78 Assert.Equal("0", version1.Labels[1].Label);
79
80 Assert.Null(version1.Metadata);
81 Assert.False(version1.Invalid);
82 Assert.True(version1.HasMajor);
83 Assert.True(version1.HasMinor);
84 Assert.False(version1.HasPatch);
85 Assert.False(version1.HasRevision);
86
87
88 Assert.Null(version2.Prefix);
89 Assert.Equal(1U, version2.Major);
90 Assert.Equal(0U, version2.Minor);
91 Assert.Equal(0U, version2.Patch);
92 Assert.Equal(0U, version2.Revision);
93 Assert.Single(version2.Labels);
94
95 Assert.Equal(19U, version2.Labels[0].Numeric);
96 Assert.Equal("19", version2.Labels[0].Label);
97
98 Assert.Null(version2.Metadata);
99 Assert.False(version2.Invalid);
100 Assert.True(version2.HasMajor);
101 Assert.True(version2.HasMinor);
102 Assert.False(version2.HasPatch);
103 Assert.False(version2.HasRevision);
104
105 TestVerutilCompareParsedVersions(version1, version2, -1);
106 }
107
108 [Fact]
109 public void VerCompareVersionsHandlesNormallyInvalidVersions()
110 {
111 var version1 = WixVersion.Parse("10.-4.0");
112 var version2 = WixVersion.Parse("10.-2.0");
113 var version3 = WixVersion.Parse("0");
114 var version4 = WixVersion.Parse("");
115 var version5 = WixVersion.Parse("10-2");
116 var version6 = WixVersion.Parse("10-4.@");
117
118
119 Assert.Null(version1.Prefix);
120 Assert.Equal(10U, version1.Major);
121 Assert.Equal(0U, version1.Minor);
122 Assert.Equal(0U, version1.Patch);
123 Assert.Equal(0U, version1.Revision);
124 Assert.Null(version1.Labels);
125 Assert.Equal("-4.0", version1.Metadata);
126 Assert.True(version1.Invalid);
127 Assert.True(version1.HasMajor);
128 Assert.False(version1.HasMinor);
129 Assert.False(version1.HasPatch);
130 Assert.False(version1.HasRevision);
131
132
133 Assert.Null(version2.Prefix);
134 Assert.Equal(10U, version2.Major);
135 Assert.Equal(0U, version2.Minor);
136 Assert.Equal(0U, version2.Patch);
137 Assert.Equal(0U, version2.Revision);
138 Assert.Null(version2.Labels);
139 Assert.Equal("-2.0", version2.Metadata);
140 Assert.True(version2.Invalid);
141 Assert.True(version2.HasMajor);
142 Assert.False(version2.HasMinor);
143 Assert.False(version2.HasPatch);
144 Assert.False(version2.HasRevision);
145
146
147 Assert.Null(version3.Prefix);
148 Assert.Equal(0U, version3.Major);
149 Assert.Equal(0U, version3.Minor);
150 Assert.Equal(0U, version3.Patch);
151 Assert.Equal(0U, version3.Revision);
152 Assert.Null(version3.Labels);
153 Assert.Null(version3.Metadata);
154 Assert.False(version3.Invalid);
155 Assert.True(version3.HasMajor);
156 Assert.False(version3.HasMinor);
157 Assert.False(version3.HasPatch);
158 Assert.False(version3.HasRevision);
159
160 Assert.Null(version4.Prefix);
161 Assert.Equal(0U, version4.Major);
162 Assert.Equal(0U, version4.Minor);
163 Assert.Equal(0U, version4.Patch);
164 Assert.Equal(0U, version4.Revision);
165 Assert.Null(version4.Labels);
166 Assert.Equal(String.Empty, version4.Metadata);
167 Assert.True(version4.Invalid);
168 Assert.False(version4.HasMajor);
169 Assert.False(version4.HasMinor);
170 Assert.False(version4.HasPatch);
171 Assert.False(version4.HasRevision);
172
173 Assert.Null(version5.Prefix);
174 Assert.Equal(10U, version5.Major);
175 Assert.Equal(0U, version5.Minor);
176 Assert.Equal(0U, version5.Patch);
177 Assert.Equal(0U, version5.Revision);
178 Assert.Single(version5.Labels);
179 Assert.Equal(2U, version5.Labels[0].Numeric);
180 Assert.Equal("2", version5.Labels[0].Label);
181
182 Assert.Null(version5.Metadata);
183 Assert.False(version5.Invalid);
184 Assert.True(version5.HasMajor);
185 Assert.False(version5.HasMinor);
186 Assert.False(version5.HasPatch);
187 Assert.False(version5.HasRevision);
188
189 Assert.Null(version6.Prefix);
190 Assert.Equal(10U, version6.Major);
191 Assert.Equal(0U, version6.Minor);
192 Assert.Equal(0U, version6.Patch);
193 Assert.Equal(0U, version6.Revision);
194 Assert.Single(version6.Labels);
195 Assert.Equal(4U, version6.Labels[0].Numeric);
196 Assert.Equal("4", version6.Labels[0].Label);
197
198 Assert.Equal("@", version6.Metadata);
199 Assert.True(version6.Invalid);
200 Assert.True(version6.HasMajor);
201 Assert.False(version6.HasMinor);
202 Assert.False(version6.HasPatch);
203 Assert.False(version6.HasRevision);
204
205 TestVerutilCompareParsedVersions(version1, version2, 1);
206 TestVerutilCompareParsedVersions(version3, version4, 1);
207 TestVerutilCompareParsedVersions(version5, version6, -1);
208 }
209
210 [Fact]
211 public void VerCompareVersionsTreatsHyphenAsVersionSeparator()
212 {
213 var version1 = WixVersion.Parse("0.0.1-a");
214 var version2 = WixVersion.Parse("0-2");
215 var version3 = WixVersion.Parse("1-2");
216
217
218 Assert.Null(version1.Prefix);
219 Assert.Equal(0U, version1.Major);
220 Assert.Equal(0U, version1.Minor);
221 Assert.Equal(1U, version1.Patch);
222 Assert.Equal(0U, version1.Revision);
223 Assert.Single(version1.Labels);
224 Assert.Null(version1.Labels[0].Numeric);
225 Assert.Equal("a", version1.Labels[0].Label);
226
227 Assert.Null(version1.Metadata);
228 Assert.False(version1.Invalid);
229 Assert.True(version1.HasMajor);
230 Assert.True(version1.HasMinor);
231 Assert.True(version1.HasPatch);
232 Assert.False(version1.HasRevision);
233
234 Assert.Null(version2.Prefix);
235 Assert.Equal(0U, version2.Major);
236 Assert.Equal(0U, version2.Minor);
237 Assert.Equal(0U, version2.Patch);
238 Assert.Equal(0U, version2.Revision);
239 Assert.Single(version2.Labels);
240 Assert.Equal(2U, version2.Labels[0].Numeric);
241 Assert.Equal("2", version2.Labels[0].Label);
242
243 Assert.Null(version2.Metadata);
244 Assert.False(version2.Invalid);
245 Assert.True(version2.HasMajor);
246 Assert.False(version2.HasMinor);
247 Assert.False(version2.HasPatch);
248 Assert.False(version2.HasRevision);
249
250 Assert.Null(version3.Prefix);
251 Assert.Equal(1U, version3.Major);
252 Assert.Equal(0U, version3.Minor);
253 Assert.Equal(0U, version3.Patch);
254 Assert.Equal(0U, version3.Revision);
255 Assert.Single(version3.Labels);
256 Assert.Equal(2U, version3.Labels[0].Numeric);
257 Assert.Equal("2", version3.Labels[0].Label);
258
259 Assert.Null(version3.Metadata);
260 Assert.False(version3.Invalid);
261 Assert.True(version3.HasMajor);
262 Assert.False(version3.HasMinor);
263 Assert.False(version3.HasPatch);
264 Assert.False(version3.HasRevision);
265
266 TestVerutilCompareParsedVersions(version1, version2, 1);
267 TestVerutilCompareParsedVersions(version1, version3, -1);
268 }
269
270 [Fact]
271 public void VerCompareVersionsIgnoresLeadingZeroes()
272 {
273 var version1 = WixVersion.Parse("0.01-a.1");
274 var version2 = WixVersion.Parse("0.1.0-a.1");
275 var version3 = WixVersion.Parse("0.1-a.b.0");
276 var version4 = WixVersion.Parse("0.1.0-a.b.000");
277
278 Assert.Null(version1.Prefix);
279 Assert.Equal(0U, version1.Major);
280 Assert.Equal(1U, version1.Minor);
281 Assert.Equal(0U, version1.Patch);
282 Assert.Equal(0U, version1.Revision);
283 Assert.Equal(2, version1.Labels.Length);
284 Assert.Null(version1.Labels[0].Numeric);
285 Assert.Equal("a", version1.Labels[0].Label);
286 Assert.Equal(1U, version1.Labels[1].Numeric);
287 Assert.Equal("1", version1.Labels[1].Label);
288
289 Assert.Null(version1.Metadata);
290 Assert.False(version1.Invalid);
291 Assert.True(version1.HasMajor);
292 Assert.True(version1.HasMinor);
293 Assert.False(version1.HasPatch);
294 Assert.False(version1.HasRevision);
295
296 Assert.Null(version2.Prefix);
297 Assert.Equal(0U, version2.Major);
298 Assert.Equal(1U, version2.Minor);
299 Assert.Equal(0U, version2.Patch);
300 Assert.Equal(0U, version2.Revision);
301 Assert.Equal(2, version2.Labels.Length);
302
303 Assert.Null(version2.Labels[0].Numeric);
304 Assert.Equal("a", version2.Labels[0].Label);
305 Assert.Equal(1U, version2.Labels[1].Numeric);
306 Assert.Equal("1", version2.Labels[1].Label);
307
308 Assert.Null(version2.Metadata);
309 Assert.False(version2.Invalid);
310 Assert.True(version2.HasMajor);
311 Assert.True(version2.HasMinor);
312 Assert.True(version2.HasPatch);
313 Assert.False(version2.HasRevision);
314
315 Assert.Null(version3.Prefix);
316 Assert.Equal(0U, version3.Major);
317 Assert.Equal(1U, version3.Minor);
318 Assert.Equal(0U, version3.Patch);
319 Assert.Equal(0U, version3.Revision);
320 Assert.Equal(3, version3.Labels.Length);
321 Assert.Null(version3.Labels[0].Numeric);
322 Assert.Equal("a", version3.Labels[0].Label);
323 Assert.Null(version3.Labels[1].Numeric);
324 Assert.Equal("b", version3.Labels[1].Label);
325 Assert.Equal(0U, version3.Labels[2].Numeric);
326 Assert.Equal("0", version3.Labels[2].Label);
327
328 Assert.Null(version3.Metadata);
329 Assert.False(version3.Invalid);
330 Assert.True(version3.HasMajor);
331 Assert.True(version3.HasMinor);
332 Assert.False(version3.HasPatch);
333 Assert.False(version3.HasRevision);
334
335 Assert.Null(version4.Prefix);
336 Assert.Equal(0U, version4.Major);
337 Assert.Equal(1U, version4.Minor);
338 Assert.Equal(0U, version4.Patch);
339 Assert.Equal(0U, version4.Revision);
340 Assert.Equal(3, version4.Labels.Length);
341 Assert.Null(version4.Labels[0].Numeric);
342 Assert.Equal("a", version4.Labels[0].Label);
343 Assert.Null(version4.Labels[1].Numeric);
344 Assert.Equal("b", version4.Labels[1].Label);
345 Assert.Equal(0U, version4.Labels[2].Numeric);
346 Assert.Equal("000", version4.Labels[2].Label);
347
348 Assert.Null(version4.Metadata);
349 Assert.False(version4.Invalid);
350 Assert.True(version4.HasMajor);
351 Assert.True(version4.HasMinor);
352 Assert.True(version4.HasPatch);
353 Assert.False(version4.HasRevision);
354
355 TestVerutilCompareParsedVersions(version1, version2, 0);
356 TestVerutilCompareParsedVersions(version3, version4, 0);
357 }
358
359 [Fact]
360 public void VerCompareVersionsTreatsUnexpectedContentAsMetadata()
361 {
362 var version1 = WixVersion.Parse("1.2.3+abcd");
363 var version2 = WixVersion.Parse("1.2.3.abcd");
364 var version3 = WixVersion.Parse("1.2.3.-abcd");
365
366 Assert.Null(version1.Prefix);
367 Assert.Equal(1U, version1.Major);
368 Assert.Equal(2U, version1.Minor);
369 Assert.Equal(3U, version1.Patch);
370 Assert.Equal(0U, version1.Revision);
371 Assert.Null(version1.Labels);
372 Assert.Equal("abcd", version1.Metadata);
373 Assert.False(version1.Invalid);
374 Assert.True(version1.HasMajor);
375 Assert.True(version1.HasMinor);
376 Assert.True(version1.HasPatch);
377 Assert.False(version1.HasRevision);
378
379 Assert.Null(version2.Prefix);
380 Assert.Equal(1U, version2.Major);
381 Assert.Equal(2U, version2.Minor);
382 Assert.Equal(3U, version2.Patch);
383 Assert.Equal(0U, version2.Revision);
384 Assert.Null(version2.Labels);
385 Assert.Equal("abcd", version2.Metadata);
386 Assert.True(version2.Invalid);
387 Assert.True(version2.HasMajor);
388 Assert.True(version2.HasMinor);
389 Assert.True(version2.HasPatch);
390 Assert.False(version2.HasRevision);
391
392
393 Assert.Null(version3.Prefix);
394 Assert.Equal(1U, version3.Major);
395 Assert.Equal(2U, version3.Minor);
396 Assert.Equal(3U, version3.Patch);
397 Assert.Equal(0U, version3.Revision);
398 Assert.Null(version3.Labels);
399 Assert.Equal("-abcd", version3.Metadata);
400 Assert.True(version3.Invalid);
401 Assert.True(version3.HasMajor);
402 Assert.True(version3.HasMinor);
403 Assert.True(version3.HasPatch);
404 Assert.False(version3.HasRevision);
405
406 TestVerutilCompareParsedVersions(version1, version2, 1);
407 TestVerutilCompareParsedVersions(version1, version3, 1);
408 TestVerutilCompareParsedVersions(version2, version3, 1);
409 }
410
411 [Fact]
412 public void VerCompareVersionsIgnoresLeadingV()
413 {
414 var version1 = WixVersion.Parse("10.20.30.40");
415 var version2 = WixVersion.Parse("v10.20.30.40");
416 var version3 = WixVersion.Parse("V10.20.30.40");
417 var version4 = WixVersion.Parse("v10.20.30.40-abc");
418 var version5 = WixVersion.Parse("vvv");
419
420 Assert.Null(version1.Prefix);
421 Assert.Equal(10U, version1.Major);
422 Assert.Equal(20U, version1.Minor);
423 Assert.Equal(30U, version1.Patch);
424 Assert.Equal(40U, version1.Revision);
425 Assert.Null(version1.Labels);
426 Assert.Null(version1.Metadata);
427 Assert.False(version1.Invalid);
428 Assert.True(version1.HasMajor);
429 Assert.True(version1.HasMinor);
430 Assert.True(version1.HasPatch);
431 Assert.True(version1.HasRevision);
432
433 Assert.Equal('v', version2.Prefix);
434 Assert.Equal(10U, version2.Major);
435 Assert.Equal(20U, version2.Minor);
436 Assert.Equal(30U, version2.Patch);
437 Assert.Equal(40U, version2.Revision);
438 Assert.Null(version2.Labels);
439 Assert.Null(version2.Metadata);
440 Assert.False(version2.Invalid);
441 Assert.True(version2.HasMajor);
442 Assert.True(version2.HasMinor);
443 Assert.True(version2.HasPatch);
444 Assert.True(version2.HasRevision);
445
446 Assert.Equal('V', version3.Prefix);
447 Assert.Equal(10U, version3.Major);
448 Assert.Equal(20U, version3.Minor);
449 Assert.Equal(30U, version3.Patch);
450 Assert.Equal(40U, version3.Revision);
451 Assert.Null(version3.Labels);
452 Assert.Null(version3.Metadata);
453 Assert.False(version3.Invalid);
454 Assert.True(version3.HasMajor);
455 Assert.True(version3.HasMinor);
456 Assert.True(version3.HasPatch);
457 Assert.True(version3.HasRevision);
458
459 Assert.Equal('v', version4.Prefix);
460 Assert.Equal(10U, version4.Major);
461 Assert.Equal(20U, version4.Minor);
462 Assert.Equal(30U, version4.Patch);
463 Assert.Equal(40U, version4.Revision);
464 Assert.Single(version4.Labels);
465 Assert.Null(version4.Labels[0].Numeric);
466 Assert.Equal("abc", version4.Labels[0].Label);
467
468 Assert.Null(version4.Metadata);
469 Assert.False(version4.Invalid);
470 Assert.True(version4.HasMajor);
471 Assert.True(version4.HasMinor);
472 Assert.True(version4.HasPatch);
473 Assert.True(version4.HasRevision);
474
475 Assert.Null(version5.Prefix);
476 Assert.Equal(0U, version5.Major);
477 Assert.Equal(0U, version5.Minor);
478 Assert.Equal(0U, version5.Patch);
479 Assert.Equal(0U, version5.Revision);
480 Assert.Null(version5.Labels);
481 Assert.Equal("vvv", version5.Metadata);
482 Assert.True(version5.Invalid);
483 Assert.False(version5.HasMajor);
484 Assert.False(version5.HasMinor);
485 Assert.False(version5.HasPatch);
486 Assert.False(version5.HasRevision);
487
488 TestVerutilCompareParsedVersions(version1, version2, 0);
489 TestVerutilCompareParsedVersions(version1, version3, 0);
490 TestVerutilCompareParsedVersions(version1, version4, 1);
491 }
492
493 [Fact]
494 public void VerCompareVersionsHandlesTooLargeNumbers()
495 {
496 var version1 = WixVersion.Parse("4294967295.4294967295.4294967295.4294967295");
497 var version2 = WixVersion.Parse("4294967296.4294967296.4294967296.4294967296");
498
499 Assert.Null(version1.Prefix);
500 Assert.Equal(4294967295, version1.Major);
501 Assert.Equal(4294967295, version1.Minor);
502 Assert.Equal(4294967295, version1.Patch);
503 Assert.Equal(4294967295, version1.Revision);
504 Assert.Null(version1.Labels);
505 Assert.Null(version1.Metadata);
506 Assert.False(version1.Invalid);
507 Assert.True(version1.HasMajor);
508 Assert.True(version1.HasMinor);
509 Assert.True(version1.HasPatch);
510 Assert.True(version1.HasRevision);
511
512 Assert.Null(version2.Prefix);
513 Assert.Equal(0U, version2.Major);
514 Assert.Equal(0U, version2.Minor);
515 Assert.Equal(0U, version2.Patch);
516 Assert.Equal(0U, version2.Revision);
517 Assert.Null(version2.Labels);
518 Assert.Equal("4294967296.4294967296.4294967296.4294967296", version2.Metadata);
519 Assert.True(version2.Invalid);
520 Assert.False(version2.HasMajor);
521 Assert.False(version2.HasMinor);
522 Assert.False(version2.HasPatch);
523 Assert.False(version2.HasRevision);
524
525 TestVerutilCompareParsedVersions(version1, version2, 1);
526 }
527
528 [Fact]
529 public void VerCompareVersionsIgnoresMetadataForValidVersions()
530 {
531 var version1 = WixVersion.Parse("1.2.3+abc");
532 var version2 = WixVersion.Parse("1.2.3+xyz");
533
534 Assert.Null(version1.Prefix);
535 Assert.Equal(1U, version1.Major);
536 Assert.Equal(2U, version1.Minor);
537 Assert.Equal(3U, version1.Patch);
538 Assert.Equal(0U, version1.Revision);
539 Assert.Null(version1.Labels);
540 Assert.Equal("abc", version1.Metadata);
541 Assert.False(version1.Invalid);
542 Assert.True(version1.HasMajor);
543 Assert.True(version1.HasMinor);
544 Assert.True(version1.HasPatch);
545 Assert.False(version1.HasRevision);
546
547
548 Assert.Null(version2.Prefix);
549 Assert.Equal(1U, version2.Major);
550 Assert.Equal(2U, version2.Minor);
551 Assert.Equal(3U, version2.Patch);
552 Assert.Equal(0U, version2.Revision);
553 Assert.Null(version2.Labels);
554 Assert.Equal("xyz", version2.Metadata);
555 Assert.False(version2.Invalid);
556 Assert.True(version2.HasMajor);
557 Assert.True(version2.HasMinor);
558 Assert.True(version2.HasPatch);
559 Assert.False(version2.HasRevision);
560
561 TestVerutilCompareParsedVersions(version1, version2, 0);
562 }
563
564 [Fact]
565 public void VerParseVersionTreatsTrailingDotsAsInvalid()
566 {
567 var version1 = WixVersion.Parse(".");
568 var version2 = WixVersion.Parse("1.");
569 var version3 = WixVersion.Parse("2.1.");
570 var version4 = WixVersion.Parse("3.2.1.");
571 var version5 = WixVersion.Parse("4.3.2.1.");
572 var version6 = WixVersion.Parse("5-.");
573 var version7 = WixVersion.Parse("6-a.");
574
575 Assert.Null(version1.Prefix);
576 Assert.Equal(0U, version1.Major);
577 Assert.Equal(0U, version1.Minor);
578 Assert.Equal(0U, version1.Patch);
579 Assert.Equal(0U, version1.Revision);
580 Assert.Null(version1.Labels);
581 Assert.Equal(".", version1.Metadata);
582 Assert.True(version1.Invalid);
583 Assert.False(version1.HasMajor);
584 Assert.False(version1.HasMinor);
585 Assert.False(version1.HasPatch);
586 Assert.False(version1.HasRevision);
587
588
589 Assert.Null(version2.Prefix);
590 Assert.Equal(1U, version2.Major);
591 Assert.Equal(0U, version2.Minor);
592 Assert.Equal(0U, version2.Patch);
593 Assert.Equal(0U, version2.Revision);
594 Assert.Null(version2.Labels);
595 Assert.Empty(version2.Metadata);
596 Assert.True(version2.Invalid);
597 Assert.True(version2.HasMajor);
598 Assert.False(version2.HasMinor);
599 Assert.False(version2.HasPatch);
600 Assert.False(version2.HasRevision);
601
602
603 Assert.Null(version3.Prefix);
604 Assert.Equal(2U, version3.Major);
605 Assert.Equal(1U, version3.Minor);
606 Assert.Equal(0U, version3.Patch);
607 Assert.Equal(0U, version3.Revision);
608 Assert.Null(version3.Labels);
609 Assert.Empty(version3.Metadata);
610 Assert.True(version3.Invalid);
611 Assert.True(version3.HasMajor);
612 Assert.True(version3.HasMinor);
613 Assert.False(version3.HasPatch);
614 Assert.False(version3.HasRevision);
615
616 Assert.Null(version4.Prefix);
617 Assert.Equal(3U, version4.Major);
618 Assert.Equal(2U, version4.Minor);
619 Assert.Equal(1U, version4.Patch);
620 Assert.Equal(0U, version4.Revision);
621 Assert.Null(version4.Labels);
622 Assert.Empty(version4.Metadata);
623 Assert.True(version4.Invalid);
624 Assert.True(version4.HasMajor);
625 Assert.True(version4.HasMinor);
626 Assert.True(version4.HasPatch);
627 Assert.False(version4.HasRevision);
628
629 Assert.Null(version5.Prefix);
630 Assert.Equal(4U, version5.Major);
631 Assert.Equal(3U, version5.Minor);
632 Assert.Equal(2U, version5.Patch);
633 Assert.Equal(1U, version5.Revision);
634 Assert.Null(version5.Labels);
635 Assert.Empty(version5.Metadata);
636 Assert.True(version5.Invalid);
637 Assert.True(version5.HasMajor);
638 Assert.True(version5.HasMinor);
639 Assert.True(version5.HasPatch);
640 Assert.True(version5.HasRevision);
641
642 Assert.Null(version6.Prefix);
643 Assert.Equal(5U, version6.Major);
644 Assert.Equal(0U, version6.Minor);
645 Assert.Equal(0U, version6.Patch);
646 Assert.Equal(0U, version6.Revision);
647 Assert.Null(version6.Labels);
648 Assert.Equal(".", version6.Metadata);
649 Assert.True(version6.Invalid);
650 Assert.True(version6.HasMajor);
651 Assert.False(version6.HasMinor);
652 Assert.False(version6.HasPatch);
653 Assert.False(version6.HasRevision);
654
655 Assert.Null(version7.Prefix);
656 Assert.Equal(6U, version7.Major);
657 Assert.Equal(0U, version7.Minor);
658 Assert.Equal(0U, version7.Patch);
659 Assert.Equal(0U, version7.Revision);
660 Assert.Single(version7.Labels);
661 Assert.Null(version7.Labels[0].Numeric);
662 Assert.Equal("a", version7.Labels[0].Label);
663 Assert.Empty(version7.Metadata);
664 Assert.True(version7.Invalid);
665 Assert.True(version7.HasMajor);
666 Assert.False(version7.HasMinor);
667 Assert.False(version7.HasPatch);
668 Assert.False(version7.HasRevision);
669 }
670
671 private static void TestVerutilCompareParsedVersions(WixVersion version1, WixVersion version2, int expectedResult)
672 {
673 var result = version1.CompareTo(version2);
674 Assert.Equal(expectedResult, result);
675
676 result = version2.CompareTo(version1);
677 Assert.Equal(expectedResult, -result);
678
679 var equal = version1.Equals(version2);
680 Assert.Equal(expectedResult == 0, equal);
681 }
682 }
683}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-04-25 08:17:29 +0000